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: Wednesday 17 October 2012

NOTE
The information on this page refers to Software Architect 2012. This site will be updated with information on Software Architect 2013 closer to the event.

  TRACKS & SESSIONS
08.30
Registration & Coffee
09.30
Opening Keynote – The journey to becoming a 21st century architect
Simon Brown
Applying the building metaphor to software doesn’t necessarily work, although in medieval times the people that architected buildings were the select few that made into the exclusive society of master-builders. The clue here is in the name, and a master-builder really was a master of their craft. Once elevated to this status though, did the masterbuilder continue to build or was that task left to those less noble?
Fast-forward several hundred years and it seems we’re asking the same question about software development. Thankfully the days of PowerPoint architects providing architecture as a service to software development teams are rapidly coming to an end. And rightly so, because software development isn’t a relay sport and delivering a successful software project isn’t an “implementation detail„. Where does this leave us then?
In this talk you’ll hear what the software architecture role should look like on modern software development teams and understand how you can move into it.
11.00
Coffee Break
11.30
TRACK 1: Principles of programming
Allen Holub
There are a lot of rules-of-thumb lists out there, ranging from Martin’s SOLID principles to the Gang-of-Four design patterns. Underlying those lists, however are a set of core, often unarticulated programming principles that are not linked to any one methodology or style, but inform all of them. All excellent programs incorporate an intuitive understanding of these core principles. This session examines several of these core principles, showing how, when applied in a concrete way, they can turn into more familiar rules of thumb.

 
TRACK 2: Architectural styles
Kevlin Henney
Often the architectural style of a system is not up for discussion, or even explicitly recognised, having been implicitly made by the adoption of a technology or the continuation of existing practice. Working within the frame of a technology choice and through the detail of code it is sometimes hard to see that the challenges of a system may be down to inappropriate choice of architectural style.
The style of an architecture relates to the dominant pattern or set of patterns that characterise a system. Recognising and reasoning about the style can reveal opportunities for improvement, such as replacing the common but typically inappropriate use of a thread-and-locks approach to concurrency with an architecture based on a shared repository or one based on dataflow and immutability.
This talk examines patterns and architectural style, listing some of the common and classic styles, reasoning through their strengths and weaknesses.

 
TRACK 3: Understanding Windows 8
David Wheeler
Windows 8 is different.
It is more than an operating system.
It represents a powerful ecosystem that attempts to deliver an integrated and delightful experience for users.
And this requires us to upgrade our thinking far more than our hardware.
Come to this session to discover the real story of what Windows 8 might mean to you, your organization, and the way that you develop applications for users in the future.
You might well be pleasantly surprised.

 
TRACK 4: Emergent design
Neal Ford
This session describes the current thinking about emergent design, discovering design in code. The hazard of Big Design Up Front in software is that you don’t yet know what you don’t know, and design decisions made too early are just speculations without facts. Emergent design techniques allow you to wait until the last responsible moment to make design decisions.
This talk covers four areas: emergent design enablers, battling things that make emergent design hard, finding idiomatic patterns, and how to leverage the patterns you find. It includes both proactive (test-driven development) and reactive (refactoring, metrics, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing them. The goal of this talk is to provide nomenclature, strategies, and techniques for allowing design to emerge from projects as they proceed, keeping your code in sync with the problem domain.

 
TRACK 5: When MVC goes bad – fixing bad design
Richard Blewett
ASP.NET MVC is a far more natural way to build web sites than web forms. It encourages separation of concerns and can allow high levels of automated unit tests. However, just because a framework can encourage a certain approach doesn’t mean that software gets built that way. This talk looks at some of the pitfalls that can beset people when using MVC badly, and techniques for fixing the problem after the fact.

 
TRACK 6: A pragmatic guide to Domain-driven Design
Dino Esposito & Andrea Saltarello
Domain-driven design is an approach to modeling and implementation of layered systems that many architects and developers know and at least dabbled with. In this session, we aim at offering a concrete and pragmatic guide to DDD principles making any effort to avoid statements of principle and focusing on facts and tips from the trenches. As promoters of DDD love to say, DDD is a way to tackle complexity in the heart of software, but it may also be a way to add complexity if not properly managed. This is just where this session fits in.
13.00
Lunch Break
14.00
TRACK 1: Design patterns in the real world
Allen Holub
Design patterns do not exist in splendid isolation. In the real world patterns overlap one another and interact in complex ways. This class takes a unique approach to teaching patterns by analyzing a real computer program in terms of the patterns used to implement it.
We’ll look at how the design patterns are actually used in practice, and see how the strengths and weaknesses of the patterns play off one another. You’ll also get a chance to see how real-world realizations of the patterns can differ from the Gang-of-Four examples and how a given pattern can be implemented in various ways.
The examples are in Java, but C++ and C# programmers should have no problem following along. Some familiarity with the Gang-of-Four patterns is assumed, however (you should, at minimum, be able to identify them by name).

 
TRACK 2: The frustrated architect
Simon Brown
The IT industry is either taking giant leaps ahead or it’s in deep turmoil. On the one hand we’re pushing forward, reinventing the way that we build software and striving for craftsmanship at every turn. On the other though, we’re continually forgetting the good of the past and software teams are still screwing up on an alarmingly regular basis. Software architecture plays a pivotal role in the delivery of successful software yet it’s frustratingly neglected by many teams. Whether performed by one person or shared amongst the team, the architecture role exists on even the most agile of teams yet the balance of up front and evolutionary thinking often reflects aspiration rather than reality. If we really do want to succeed, we need to get over our fascination with shiny new things and starting asking some questions. Does agile need architecture or does architecture actually need agile? Have we forgotten more about good software design than we’ve learnt in recent years? Does any of this matter if we’re not fostering the software architects of tomorrow? How do we move from frustration to serenity?

 
TRACK 3: NodeJS for the .NET developer
Jesus Rodriguez
In the last few years, NodeJS has emerged as one of the most popular platforms for building distributed applications. What makes this platform so popular, and how can you start using it in your applications?
This session provides an overview of the architecture and capabilities of the NodeJS platform from the perspective of a .NET developer. The session will deep dive into aspects of the NodeJS platform such as concurrency, HTTP processing, asynchronous programming among many others that will help developers to understand and take advantage of NodeJS as part of their applications.
Finally, we will showcase the techniques you can use TODAY to leverage NodeJS as part of your Windows and Windows Azure applications.

 
TRACK 4: The who and what of Agile – personas and story maps
Nathaniel T. Schutta
Successful projects require any number of practices but if you don’t know who you’re building it for or what you’re supposed to build, failure is a distinct possibility. How do we capture the who and what? Personas and story maps are two effective techniques that you can leverage. After discussing the basics, we’ll break into small groups and you’ll have a chance to actually try building a set of personas as well as a story map.

 
TRACK 5: The architecture of an asynchronous application
Kevin Jones
One of the key issues in many web applications is scalability. Listen to many architects and they will tell you that one of the ways to scale is to make everything asynchronous. However writing an asynchronous code application is hard. This talk will look at the architecture of an asynchronous application and at how to write an “end-to-end„ application asynchronously. We will cover ASP.NET MVC, messaging technologies, and SignalR. You will come away with an understanding of the complexity involved in these applications, and learn how using the correct frameworks can address some of that complexity.

 
TRACK 6: The curious Clojureist
Neal Ford
Why should you learn Clojure now? – It’s the coolest new language on the JVM.
What makes it so cool? – It’s a dynamically typed, functional Lisp that offers sophisticated capabilities like software transactional memory.
Why should I learn it? – Lisp is the most powerful style of programming language possible (don’t believe me? Come see – I’ll show you), so you get the best language (Lisp) on the best runtime (JVM).
Isn’t Lisp the one with all the parenthesis? – Yes.
What’s so compelling about Clojure? – It’s fast, expressive, powerful, and allows you to do all sorts of things that other languages won’t let you do. It’s an elegant language.
Why is the entire talk done as question and answer? It’s an homage to a series of books, The Little Lisper and The Little Schemer. Because Lisps are simple and homoiconic, this style works nicely for them. Besides, it’s better than 1000 bullets, isn’t it?
15.30
Coffee Break
16.00
TRACK 1: Architecting for C# 5 async/await
Andrew Clymer
.NET 4 introduced the new “task„ abstraction, and C# 5 will take advantage of integrating this into the language via the async and await keywords. Furthermore, the new task abstraction promotes a new way of architecting asynchronous behaviour; in this talk we will explore how to take advantage of these new keywords and other new types and features being exposed in the next version of .NET to deliver far simpler asynchronous Windows UIs.

 
TRACK 2: Explain it or change it
Kevlin Henney
Ever found yourself struggling to explain a design idea or an architecture? Ever found yourself well practised (even bored) at giving an explanation? Both of these experiences can hint at possibilities for change we might otherwise overlook.
If you struggle to explain something, is that a property of what you are trying to explain? Would an alternative approach or concept be easier to explain… and would it also be more effective? For example, introducing interfaces to reduce dependencies and the need to explain those dependencies. If you are used to explaining something, it sounds like an FAQ… but perhaps changing it so that it no longer raises a question would be the next step beyond recording it as an FAQ?
This talk takes a look at the fact that you struggle to explain something or that you keep having to re-explain something may be more important than the explanation itself. We can use this feedback constructively to change our code, our architecture, our practice, our process.

 
TRACK 3: Preparing for the Windows Runtime
David Wheeler
Windows 8 comes with a new runtime, affectionately known as WinRT. And it is expected to be the bedrock of all future versions of Windows, ultimately replacing the traditional Windows SDK and the .NET Framework.
So getting an early understanding of what it is, what it does, and what if offers is important to decision makers and architects, regardless of whether they intend to develop applications for Windows 8 in the immediate future.
And that is precisely what this session will deliver, giving you the thorough insights that you need in order to make informed decisions about your code today and into the future.

 
TRACK 4: Agile, Scrum, Lean, or just mean – what makes sense when?
Howard Deiner
The development methodology wars seem to be back! What are the differences between these methodologies? What circumstances might be relevant for each one? Must I religiously follow just one, or does process polytheism work? This is a combined lecture, live action workshop, and roundtable. The lecture portion is approximately 40 minutes, where the differences between Agile/Scrum, Lean, Kanban, Crystal, and traditional Waterfall are discussed. The audience will be split into teams for 30 minutes and given different organizational situations. They are tasked to come up with a development methodology that makes sense for their given environment. The results from these teams will then be jointly reflected upon. The final 20 minutes will be spent in an open audience roundtable, to allow audience members to come forward with challenges they face in their organizations and seek guidance from the speaker and their peers as to challenges they face in their day-to-day lives.

 
TRACK 5: HTML5 for developers
Nathaniel T. Schutta
Wonder what all the fuss is about HTML5? This session will show you how to leverage HTML5 in the applications you are building today. We’ll start with a gentle overview describing just what HTML5 is all about and then we’ll delve into the details. We’ll look at the new elements HTML5 brings to the table, why canvas isn’t just something you find in the art department, how geolocation can find Waldo and much much more.
After a brief overview, we’ll talk all about feature detection then jump into web forms. We’ll discuss the new elements that HTML5 brings to our toolbox. After a spin around the canvas API, we’ll touch on geolocation, local storage/offline and finish up web sockets.

 
TRACK 6: Beyond DDD: an introduction to CQRS
Dino Esposito & Andrea Saltarello
At the core of CQRS (short for Command Query Responsibility Segregation) there’s the idea that at times it may be sound to employ distinct models to read and write data in a layered solution. While CQRS is not certainly an approach to software design that may work for everybody, there are situations in which you find it easier to use different entities to read and write data. Ultimately, it’s yet another application of the old motto “Divide et impera„. CQRS is a new architectural pattern and much (if not all) of it has to be understood yet from the field. In this session, we aim at bringing up a few concrete approaches to building a query model specific of a given bound context.
17.30
Drinks Reception


Return to Sessions introduction

 

Bearpark