Software Architect 2012
16 - 19 October 2012, America Square Conference Centre, London
Follow Software Architect on Twitter
Home
The Sessions
The Speakers
Presented Slides/Notes
Sponsors & Exhibitors
Speaking at Software Architect
Who Should Attend?
The Venue
Accommodation
Reserve Your Seat

Sessions: Thursday 18 October 2012

  TRACKS & SESSIONS
09.00
Coffee
09.30
TRACK 1: Agile architecture – Part 1
Allen Holub
Successful Agile projects have an architecture that reflects the needs of the process. You simply can’t accommodate changing requirements or refactor effectively if your system isn’t designed to accommodate those practices. This class shows how good (and bad) structure affects agility, and explores design principles that keep your design on track in an Agile environment.
We’ll look, specifically, at the SOLID principles (Single-Responsibility, Open-Closed, Liskov-Substitution, Dependence-Inversion, and Interface-Segregation Principles), at how design patterns improve agility, and at several common practices that can sabotage your project.

 
TRACK 2: Inside requirements
Kevlin Henney
What should a system do? This apparently simple question is one of the hardest to answer, and cannot be answered simply by an act of requirements gathering, by assigning a requirements phase or by composing a requirements document. What may, with hindsight at the end of a project, be considered as requirements are often emergent and not as easily divided into chunks or documents as we might have hoped.
Instead of approaching requirements with a fixed mindset and the belief that requirements can be gathered and tallied like fallen apples, with only a single role responsible for them, team members need to consider requirements as something not just to be discovered, but to be formulated and negotiated. Requirements need to be approached with patience and with more than a single technique at play.
This talk looks at the challenge of requirements, and some of the conceptual tools we have available, from user stories to problem frames, from tests to architectural viewpoints.

 
TRACK 3: I am a .NET developer but I have an iPhone and an Android
Jesus Rodriguez
Are you a .NET developer looking to build Android and iOS applications, and trying to figure out how to leverage your years of expertise in .NET technologies?
This session will explore the frameworks, tools and techniques that will allow you to build .NET applications for Android and iOS devices. As part of the session, we will deep dive into the capabilities of the MonoTouch and Mono for Android frameworks that will give you a clear picture of how to start using those frameworks as part of your applications. Additionally, we will explore the rapidly growing segment of mobile web frameworks that provide a great alternative to native applications.

 
TRACK 4: Beyond jQuery
Nathaniel T. Schutta
It’s been ages since you copied random JavaScript off a nameless webpage and your JavaScript is every bit as elegant as any server side code. You know the ins and outs of jQuery and you’ve even built a plugin or three…but is that it? How do we build rich web applications without resorting to heavy weight proprietary components? How do we leverage HTML5 and everything it brings to the table? How do we craft elegant user experiences that integrate fully with the RESTful web services that are all the rage on the backend? How do we build apps that are at home on a 3.5 inch phone as they are on the 15 inch notebook? This talk goes beyond jQuery to explore new libraries like Backbone are bringing even more to the front end developer’s toolbox.

 
TRACK 5: From concept to product – 10 lessons from the trenches
Richard Blewett & Andy Clymer
Building, and shipping, a product has some similar and some radically different problems from building in-house software. In this talk we look at the process of shipping our Customer Access Terminal product and the lessons we learned along the way.

 
TRACK 6: NoSQL smackdown 2012
Tim Berglund
Alternative databases continue to establish their role in the technology stack of the future – and for many, the technology stack of the present. Making mature engineering decisions about when to adopt new products is not easy, and requires that we learn about them both from an abstract perspective and from a very concrete one as well. If you are going to recommend a NoSQL database for a new project, you’re going to have to look at code.
In this talk, we’ll examine three important contenders in the NoSQL space: Cassandra, MongoDB, and Neo4J. We’ll review their data models, scaling paradigms, and query idioms. Most importantly, we’ll work through the exercise of modeling a real-world problem with each database, and look at the code and queries we’d use to implement real product features. Come to this session for a thorough and thoroughly practical smackdown between three important NoSQL products.
This session assumes familiarity with relational databases.
11.00
Coffee Break
11.30
TRACK 1: Agile architecture – Part 2
Allen Holub
This session builds on Part 1 by examining UI-related architecture issues, looking in depth at accessor/mutator systems and their problems.
We’ll then present three user-interface architectures suitable for (or at least used by) distributed, typically web or cloud-based, applications, discussing the pros and cons of each approach. We’ll start with Model-View-Controller and explain why it is suboptimal. We’ll then move on to more appropriate architectures: Presentation-Abstraction-Control, Visual Proxy, bifurcated objects, etc.

 
TRACK 2: The code doesn’t tell the whole story
Simon Brown
We all know that writing good code is important and refactoring forces us to think about making methods smaller, more reusable and self-documenting. Some people say that comments are bad and that self-commenting code is what we should strive for. Despite what you’ll hear though, the code isn’t the documentation. The code tells *a* story, but it doesn’t tell the whole story. Join us to find out what’s missing and how to create lightweight documentation for your software projects.

 
TRACK 3: What’s new in unit testing in Visual Studio 11?
Richard Blewett
Unit testing has been built into Visual Studio since 2005. However, until Visual Studio 11 it hasn’t really evolved significantly, while other frameworks have continued to become richer. This talk looks at the new set of features in VS 11 that make MS Test richer but also allow you to use other testing frameworks (such as NUnit and xUnit) within the Visual Studio test manager. In addition, I’ll introduce the new, powerful, mocking framework that is built into this release.

 
TRACK 4: Why M-V-VM is (not) working
David Wheeler
Model-View-ViewModel (M-V-VM) is a UI pattern that is perceived by many as overly complex, by others as the saviour of their projects.
Why is that?
In this session all the complexity of the pattern will be shorn away, all ambiguity removed, leaving you with a clear understanding and highly practical guidance on how and where to use it.
This session will involve an end-to-end analysis of M-V-VM in the context of a multi-state, multi-screen reference application that you can use as the basis of real work.
Full of tips, tricks and solid guidance, this session is a must for anyone working with WPF, Silverlight or Windows 8 Metro-based applications.

 
TRACK 5: Web Service evolution
Rob Daigneau
Some people think that with great effort it’s possible to create Web APIs that never change. Yet these efforts always seem to be futile. Clients evolve at a different rate from the services they use and vice versa. This means that Web API developers must devise ways to accommodate new requirements while ensuring these changes do not break existing users. So how can services be designed to support both backward and forward compatibility?
In this session we’ll discuss how Web API designers introduce breaking changes and how these can be prevented. We’ll examine a few patterns that encourage graceful service evolution, and we’ll also cover some anti-patterns that thwart this objective.

 
TRACK 6: Building interactive clients with knockout.js
Kevin Jones
Client-side development in the browser is becoming more and more important. Clients expect highly interactive applications that respond quickly to changes. To manage this, developers have to cope with the demands of JavaScript. While jQuery is a fantastic tool, sometimes it feels too low-level and maybe needs something layered on top. One such layering is knockout.js. This provides an MVVM programming model for the browser. This talk looks briefly at the basis for MVVM and then into the details of knockout.js. We’ll cover the data-binding that is at the heart of this toolkit, looking at examples of how knockout does data updates and computed values. We will also see how knockout can work with your server-side coding.
13.00
Lunch Break
14.00
TRACK 1: A team, a system, some legacy… and you. How to practice software architecture in the real world.
Eoin Woods
Software architecture is often described as if it is something that is only undertaken (or relevant) when creating a new system from scratch. However in my career I’ve joined many more projects where a system existed already, than projects where I got to design a system from the beginning. In these situations, it is paramount that you are a “master builder„ rather than a designer of castles-in-the-air. A real system exists, it needs help quickly, there is far too much to do and there is no time to wish that things could have been done differently. Action is needed now! In this talk I’ll describe some of my experiences working on the architecture of existing systems and the principles and techniques that I’ve used to be (mostly) successful in doing this.

 
TRACK 2: Technical debt (and other metaphors)
Kevlin Henney
Technical debt is a metaphor coined by Ward Cunningham to discuss the trade-off between writing clean code at higher cost and delayed delivery, and writing messy code cheap and fast, at the cost of higher maintenance efforts once it is shipped. The metaphor has enjoyed increased popularity in recent years.
There are many implications of the metaphor, distinguishing different types of technical debt and how and when to best pay it off. Is it better to pay the interest? If so, what factors influence the decision to service the debt? And if we decide to retire it, what approach should be taken?
This talk examines both the strengths and weaknesses of the metaphor, from how we reason about problem code and legacy architectures, to the entailments of the technical debt metaphor and others, to the how different people in different roles actually respond to the use of this and other metaphors.

 
TRACK 3: Roslyn – compiler as a service
Andrew Clymer
Microsoft is planning to expose the guts of the compiler, through the Roslyn project currently available as a CTP. The new compiler is written in managed code and provides APIs which allow you to get access to the various parts of the compiler pipeline (such as the parser), allowing access to syntax trees to build your own refactorings, code generation enabling meta programming. Roslyn will lower the barrier of entry for developing such tools, hopefully enabling a host of customer specific tooling that previously was too costly to consider. This talk will explore what Roslyn has to offer and showcase some uses of this new service.

 
TRACK 4: From RPC APIs to Resource APIs for Web Services
Rob Daigneau
RESTful APIs have been lauded for many reasons. Not only do they effectively de-couple clients from the remote procedures used to handle web requests, they also provide them with a well-known interface. Unfortunately, developers who have become comfortable with technologies and specifications (e.g. SOAP/WSDL) that encourage RPC APIs often have difficulty traversing the conceptual chasm that separates the two approaches.
In this session we’ll expand upon the patterns described in the book ‘Service Design Patterns’. You’ll see how to convert a typical RPC API to a Resource API. You’ll see how the contract for Resource APIs is defined, how to manage them and what client developers need to know about them. You’ll also see that Resource APIs aren’t just for CRUD operations as we explore workflow and transactional scenarios.

 
TRACK 5: The mobile app smackdown: native apps vs. the mobile web
Nathaniel T. Schutta
Mobile is the next big thing and your company needs to there. But what does there actually entail? Should you build a native app? On which platforms? Do you have the skills for that? What about the web? Can you deliver an awesome experience using nothing but a mobile web browser? This talk will help you navigate these treacherous waters. We’ll discuss the pros and cons of the various approaches and give you a framework for choosing.

 
TRACK 6: Complexity theory and software development
Tim Berglund
Some systems are too large to be understood entirely by any one human mind. They are composed of a diverse array of individual components capable of interacting with each other and adapting to a changing environment. As systems, they produce behavior that differs in kind from the behavior of their components. Complexity Theory is an emerging discipline that seeks to describe such phenomena previously encountered in biology, sociology, economics, and other disciplines.
Beyond new ways of looking at ant colonies, fashion trends, and national economies, complexity theory promises powerful insights to software development. The Internet – perhaps the most valuable piece of computing infrastructure of the present day – may fit the description of a complex system. Large corporate organizations in which developers are employed have complex characteristics. In this session, we’ll explore what makes a complex system, what advantages complexity has to offer us, and how to harness these in the systems we build.
15.30
Coffee Break
16.00
TRACK 1: Contracts in the age of agility
Howard Deiner
Organizations that perform professional services for software development or develop software on a work for hire basis are usually bound by extensive contracts. These contracts are typically characterized as “fixed price, fixed deliverables, and fixed schedule„. These, of course, are the vertices of the “Iron Triangle of Software Development„, and foreshadow a poor outcome due to issues that make the requirements gathering and project estimation phases that precede contract negotiation so prone to error. Given this, the question becomes one of “how can I engage clients in a way that allows us each to achieve our goals?„. If Agile and Lean methods are the status quo for good development practices, how can I write contracts for development services that embrace this mindset and let each side achieve its goals better? This lecture and roundtable explores the many facets of this question and aims to provide attendees with answers that they can use going forward.

 
TRACK 2: Coaching you to coach your team
Simon Brown
I regularly run deliberate practice sessions where I ask people to pair up and design a software solution for a given problem before communicating it using pictures. This allows people to experience collaborative software design and to hone their communication skills, as well as being a great way to illustrate what “just enough„ up front design is all about. The same exercise undertaken with your own team can be used contextualise what “just enough„ means to you, in terms of both the software design process and communicating it through a collection of lightweight yet effective architecture sketches. But how do you actually do that? This session is about coaching you to coach your team.

 
TRACK 3: Engaging users, engaging interfaces
David Wheeler
No matter whether you’re using HTML 5, XAML, Cocoa or are even considering Metro-style applications, the user interface is becoming ever more capable.
It is also becoming a significant part of our users’ lives as a consequence of the pervasive nature of devices.
Come to this session to gain practical insights into crafting engaging and effective user interfaces, and why this critical and exclusive interaction experience with your users requires specialist thinking, so that it can’t be left to a developer.

 
TRACK 4: Web application architecture: the whole stack
Allen Holub
This class provides an integrated look at the architecture of an entire “vertical slice„ of the web-application stack, from the UI at the top to the database at the bottom, and all of the interior plumbing (messaging, caching, etc.) in the middle. We’ll discuss various trade-offs and alternatives (several UI architectures are available, for example), as well as specific technologies that you can use to implement various components, and you’ll see how all the pieces work together. The focus is on good object-oriented structure throughout.

 
TRACK 5: Mobile site development: myths, facts and real pains
Dino Esposito
A mobile site is not simply a web site with a different layout and CSS skin. A mobile site should know its users and the devices they’re using. In this session, we’ll review myths and facts of mobile sites and put some buzzwords into perspective. We’ll compare Responsive Web Design and multi-serving, and focus on the role of device detection and related repositories such as WURFL. We’ll focus on practical issues such as redirecting to a mobile landing page, analysis of relevant use-cases, and creating classes of devices for serving ad hoc markup.

 
TRACK 6: 4 practical uses for Domain Specific Languages
Neal Ford
Domain Specific Languages seem like a cool idea, but where’s the payoff? This talk provides an overview of how to build both internal and external DSLs (including the state of the art tools), stopping along the way to show how this is practical to your day job. This talk defines DSLs, distinguishes the types of DSLs (internal and external), and shows examples of building DSLs of several kinds. It shows how to utilize DSLs for externalizing configuration (which you’re already doing, whether you realize it or not), how to make your code readable to humans, how DSLs make developer tools better (and how to use DSL techniques to build your own tools), and how DSLs can provide your users with unprecedented flexibility and power, by building DSLs customized to their job. This talk provides a good foundation for the subject if you’ve never seen anything about it, but keeps the focus on practical goals.
17.30
End of Conference


Return to Sessions introduction

 

Bearpark