•  

Sessions at Software Architect 2011 about Software Architecture

Your current filters are…

Tuesday 18th October 2011

  • Agile OO-Design from start to finish [workshop]

    by Allen Holub

    Many people who think they’re doing OO aren’t. For example, the dynamic model (which shows how run-time objects interact) should drive the design process; the class diagram is an artifact you build while doing dynamic modeling. If you do the class diagram first, your model will be at best unwieldy, at worst non-functional. It turns out that the design process you use influences both the quality and the basic structure of the design. The process matters.
    This class covers an Agile version of the OO-Design process, with an emphasis on how to arrive at an optimal design. We’ll start by looking at Agile methodologies to see how design fits into them. We’ll then look, in depth, at the entire process from front to back: requirements gathering and problem-statement definition, use-case analysis, and the simultaneous construction of the dynamic and static models using UML.
    We’ll construct a model for a small program, so that you can see how each step plays out in a practical context.

    At 9:30am to 5:30pm, Tuesday 18th October

  • Distributed agile development [workshop]

    by Neal Ford

    Reading and hearing about agile practices is one thing, but actually doing it is completely different. This workshop puts you to work in an agile fashion, applying agile development practices. During this workshop, we’re going to take a problem and iteratively develop the solution, using test-driven development, pair programming, retrospectives, pair rotation, and other agile development techniques. To make it interesting, we’re going to split the room into two continents and work through the issues faced by real distributed agile teams. We work through several 20-minute iterations during the workshop, giving you a hands-on feel for real agile development. If you have a laptop, bring it, but only half the class needs one, so if you don’t have a laptop, don’t let it discourage you. Come see what it’s like to work on a real distributed agile project, even if it’s only for a few hours.

    At 9:30am to 5:30pm, Tuesday 18th October

  • One day of mobile application development [workshop]

    Mobile today refers to a number of radically different platforms requiring radically different skills. There are differences in development approach, languages, API and it even requires different computers. A mobile application is also simpler than a desktop application for the logic, but more complex for resource management and life cycle. Based on four modules, this workshop offers a summary of the issues you face in a mobile project. The first module attempts to identify the most common patterns of mobile development. The remaining three cover each one of the most popular platforms – iPhone, Android and Windows Phone 7 – and the same application will be discussed for the three platforms.

    At 9:30am to 5:30pm, Tuesday 18th October

  • Pragmatic .NET architecture [workshop]

    by Oliver Sturm

    Planning application architecture is a complex task which requires detailed understanding of the technological platforms that you’re targeting. This whole-day workshop leads you through the process of creating an architectural concept for a medium size distributed .NET application: data access, distribution, services, layering concerns, UI platforms and presentation patterns – every topic is considered. Oliver lets you participate and benefit from his experiences from project work and consulting – architects, programmers and owners of other job titles are all equally welcome!

    At 9:30am to 5:30pm, Tuesday 18th October

  • Software architecture in a day [workshop]

    by Simon Brown

    This one-day workshop is an introduction to software architecture and what it means to take on the software architect role. It’s aimed at software developers who are looking towards their first software architect role, developers who want to become more architecturally aware, and software architects that are new to the role.
    We’ll be asking and answering the following questions:
    1. What is software architecture?
    2. What is the role of a software architect?
    3. How do you define software architecture?
    4. How do you share software architecture?
    5. How do you deliver software architecture?

    At 9:30am to 5:30pm, Tuesday 18th October

Wednesday 19th October 2011

  • Opening Keynote – Abstraction distractions

    by Neal Ford

    Computer science is built on a shaky tower of abstractions, but we’ve been distracted by other things until we believe it is reality. This talk teases apart some of the tangled abstractions that have become so common they are invisible yet impact important decisions. I cover languages, tools, platforms, and burrow all the way down to fundamental concepts. This wide-ranging keynote answers these questions and more:
    • Why does my keyboard look the way it does?
    • Why is the iPad the most revolutionary device in the last 30 years?
    • Why do some people hate Maven so much?
    • How can I choose technologies with long shelf lives?
    • Is hiding always a good thing?
    Oh, and some jokes too.

    At 9:30am to 11:00am, Wednesday 19th October

  • Credit crunch code: time to pay back the technical debt

    by Gary Short

    Technical debt is the cost of putting off good development practices. This debt must be paid back to avoid the “interest payments” becoming crippling.
    This presentation will further define technical debt, before examining some anti-patterns and how to avoid them. We’ll then look at how to put a financial cost on technical debt, and end by examining some measures to identify technical debt in a code base.

    At 11:30am to 1:00pm, Wednesday 19th October

  • Design patterns in the real world

    by Allen Holub

    Design patterns do not exist 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 analysing 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 realisations 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).

    At 11:30am to 1:00pm, Wednesday 19th October

  • Effective sketches

    by Simon Brown

    The code might be the architecture but at some point in time you’re going to have to explain how it works, and that’s when the whiteboard pens make their appearance. Where do you start though? How much detail should you include? Technology decisions included or omitted? UML or block diagrams? Join us as we look at some typical diagramming bloopers and show you how to produce effective sketches.

    At 11:30am to 1:00pm, Wednesday 19th October

  • Design smart, not hard – how flow-orientation makes software design easier

    by Ralf Westphal

    TDD seems to take all the credit for getting software designed right these days. But how do you approach a User Story or a whole application with TDD? Use UML? Right – except hardly anybody does. So let’s get real: whoever said object orientation would make designing software easy, was wrong. OOAD, UML, even Clean Code are not easy, not even intuitive. Enter flow-orientation. If you temporarily give up any fixation on “real” objects there is a way to escape many design difficulties. Want a design that is easily readable? Want a design method that lends itself to teamwork? Want a design method that can describe software on any number of abstraction levels – and can easily and losslessly be translated into code? Want designs that result in code that can be tested without mock-ups? Flow-oriented designs promise to give you this and more. It’s designing software the smart way; it brings out the best in groups. And there is still a place for “real” objects. Promised.

    At 2:00pm to 3:30pm, Wednesday 19th October

  • Emergent design

    by 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, visualisations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilising 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.

    At 2:00pm to 3:30pm, Wednesday 19th October

  • MEF in a hurry

    by Dave Wheeler

    The Managed Extensibility Framework, or MEF for short, is an excellent way of structuring applications in .NET. This session focuses on how you might use MEF as more than just a simple IoC container, examining everything from the basics of importing and exporting parts through to dynamic re-composition and flexible deployment catalogs.
    MEF is a rising star in the .NET firmament. Come to this session to see how it might fit into your application architecture.

    At 2:00pm to 3:30pm, Wednesday 19th October

  • Patterns for securing web services and web APIs

    by Christian Weyer and Dominick Baier

    The service pattern is pervasive – either operation centric (aka SOAP) or resource centric (aka REST). The security challenges are the same in both worlds – authentication, authorisation and secure communication. Common scenarios are direct authentication (like passwords or client certificates) as well as brokered authentication where the identity provider is external (at least to the application). This talk walks through those common scenarios and shows the architectural and technical approaches to design and implement those services in a secure fashion.

    At 2:00pm to 3:30pm, Wednesday 19th October

  • The Agile architect – oxymoron or saviour?

    by Howard Deiner

    The title of “architect” has historically been a sought-after title on one’s business card and resumé. This is, in part, a natural outgrowth of the way that architects employed in the construction of buildings have been revered over time as the smart and creative “brains” behind important endeavours that last over time. But modern software development processes, such as Agile, Scrum, and eXtreme Programming play down the role of grand upfront design. Does that mean that software architects are no longer needed? We’ll explore the role of the architect in modern process, and suggest why such individuals are needed as much now as ever before, with perhaps some changes in approach to the work at hand. The session will be conducted as a presentation followed by roundtable discussion.

    At 2:00pm to 3:30pm, Wednesday 19th October

  • Agile architecture and design principles

    by Allen Holub

    For an Agile project to be successful, the architecture of the system has to reflect the needs of the process. You simply won’t be able to refactor constantly, accommodate changing business requirements, and so forth, unless your system is designed to accommodate those practices. This talk will look at the characteristics of an Agile design, and explore several design principles that will keep your design on track in an Agile environment. We’ll look, specifically, at the Single-Responsibility, Open-Closed, Liskov-Substitution, Dependence-Inversion, and Interface-Segregation principles.

    At 4:00pm to 5:30pm, Wednesday 19th October

  • Because you suck at design patterns

    by Gary Short

    In this session we’ll look at a number of common mispractices and misconceptions that the speaker has seen in his 20 years of experience using design patterns. Together, we’ll examine them and look at fixes for them, so that, by the end of the session, you will no longer suck at design patterns. :-)

    At 4:00pm to 5:30pm, Wednesday 19th October

  • Code craft

    by Nate Schutta

    Despite what some developers think, we spend a lot more of our time reading code, code that was often written by someone that isn’t around anymore. How do we deal with this common scenario without resorting to burning our predecessor in effigy? Better, how can we write code in such a way that our successors will heap effusive praise upon us at the mere mention of our name? During this talk, we’ll read actual code and discuss ways it could be improved. As we work through real examples, we’ll explore the importance of patterns, principles like SOLID and SLAP, and essential practices like unit testing and continuous integration.

    At 4:00pm to 5:30pm, Wednesday 19th October

  • Software project SOS

    by Simon Brown

    The more vocal in our industry would have you believe that all software teams consist of agile test-driven craftsmen using the latest and greatest technology. This is the real world though, and a number of things often get in the way. This session puts you in the shoes of somebody that has been asked to rescue a struggling .NET project. What are the problems and how would *you* put the project back on track?

    At 4:00pm to 5:30pm, Wednesday 19th October

Thursday 20th October 2011

  • Agile.next

    by Neal Ford

    Agile has matured to the point of mainstream success. Even large companies have discovered that it helps them build better quality software faster. But the agile practices that are mainstream today have been around for a long time. What is the next wave of innovation in the Agile world going to bring?
    Agile software development works because of feedback loops, and to make it better (or repair what’s broken), you identify missing feedback loops, or replace broken ones. This talk uncovers two feedback loops missing from most projects. The first uses Behavior Driven Development & Cucumber to incorporate business analysts, testers, subject matter experts, and developers on one platform for requirements definition and verification. The other anaemic feedback loop in many organisations involves the last mile to production: you have error prone, horrific manual releases that everyone hates. Continuous Delivery delivers proven techniques and tools to make “Done” better.

    At 9:30am to 11:00am, Thursday 20th October

  • Designing & building services the web & HTTP way with WCF 4.5

    by Christian Weyer

    The Windows Communication Foundation (WCF) has had basic support for building HTTP-enabled services since .NET 3.5. But now new & powerful features are available that let you design and implement an even more HTTP- and web-centric view on your service-oriented applications. Christian will show you how to build WCF services that can leverage the full power of HTTP. Come and learn how to create & expose HTTP-based services and also consume REST APIs in .NET and on mobile platforms.

    At 9:30am to 11:00am, Thursday 20th October

  • How much is “just enough”?

    by Simon Brown

    One of the major points of disagreement about software relates to how much up front design to do, with people being very polarised as to when they should do design and how much they should do. “Just enough” sits somewhere in the chasm between big design up front’s analysis paralysis and emergent design’s refactor distractor, but how much is “just enough”? Join us to find out.

    At 9:30am to 11:00am, Thursday 20th October

  • Living on Cloud 1001

    by Allen Holub

    This session attempts to dispel some of the fog surrounding cloud computing. We’ll define what “cloud” actually means, and then go on to look at the two primary architectures available for cloud-based deployment: the virtual-machine model (as characterised by Amazon’s EC2 service) and the application-server model (as characterised by Google’s App Engine), and look at the general cloud infrastructure provided by both Amazon and Google. We’ll finish up with a quick discussion of how cloud applications differ from other applications, and the sorts of programming problems that are unique to cloud apps.

    At 9:30am to 11:00am, Thursday 20th October

  • 15 lessons from 15 years as a software architect

    by Ingo Rammer

    This session will give a point-by-point analysis of the fifteen key lessons the speaker has learned from his involvement in dozens of software architecture reviews, i.e. the things which will make or break a project, or at least cause severe budget overruns, technical and organisational issues.

    At 11:30am to 1:00pm, Thursday 20th October

  • Architecting async UIs using C# 5 and beyond

    by Andrew Clymer

    NET 4 introduced the new ‘task’ abstraction, and C#5 will take advantage of integrating this task abstraction 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.

    At 11:30am to 1:00pm, Thursday 20th October

  • Production operations: an architect and developer’s point of view

    by Dave Ingram

    Understanding the production environment and the core functions of the live service Operations and Service Delivery teams helps us to design and build solutions that can be better operated and supported during live service and beyond. This session provides practical insights and proven principles for architects and developers to help them design, build and implement solutions that are resilient and operable. The session is framed around a medium-scale production environment and introduces & highlights the importance of the Operations Manual as well as the Operations and Service Delivery activities such as backup & recovery, batch, reporting, monitoring, incident investigation and fix-on-fail. This session is targeted at developers and architects of all levels.

    At 11:30am to 1:00pm, Thursday 20th October

  • Windows Azure Platform for architects

    by Christian Weyer

    As a solution architect you should be aware of the benefits (and the risks) of Cloud computing. In this session Christian Weyer will walk you through the holistic set of Cloud features that the Windows Azure Platform (WAP) offers. Whether you want to run applications and services in Windows Azure, store data in Windows Azure or SQL Azure or securely communicate with and through the Cloud with the help of the Windows Azure AppFabric: come and see a pragmatic view on WAP and learn which slice of the Cloud may fit for you.

    At 11:30am to 1:00pm, Thursday 20th October

  • Agile engineering practices

    by Neal Ford

    Most of the time when people talk about agile software development, they talk about project and planning practices but never mention actual development, as if development were an afterthought when writing software. This talk drills into the real details of how to do agile development. I discuss best practices like continuous integration, pair programming, how developers should interact with story cards, how to handle enterprise concerns like integration with other software packages, and a slew of other topics related to agile software development.

    At 2:00pm to 3:30pm, Thursday 20th October

  • How to eat an elephant

    by Gary Short

    Or, how to architect a codebase-wide refactoring project. In this advanced refactoring session, we’ll look at such things as functional decomposition, code criticality, the correctness continuum, sub-tree refactoring index and prioritisation. All these terms will be defined, explained and demonstrated, so that by the end of this presentation you’ll have the knowledge and confidence to architect such a refactoring project… or eat an elephant, whichever you prefer.

    At 2:00pm to 3:30pm, Thursday 20th October

  • Making WCF simple: best practices for testing, deploying and managing WCF solutions in the big enterprise

    by Jesus Rodriguez

    During the past few years, Windows Communication Foundation (WCF) has established itself as the fundamental technology to enable service orientation in the Microsoft platform. However, adopting WCF in the big enterprise requires complementing the sophisticated capabilities of WCF with efficient practices in areas such as configuration management, unit/load testing, dependency management, and versioning among many others. Enabling these capabilities facilitates the adoption of WCF in the enterprise in an agile and simple manner. This session presents a series of solutions and best practices for addressing important aspects such as configuration management, endpoint discovery, automated unit/load testing, service dependencies, etc. We illustrate these solutions using a series of practical demonstrations that will help developers to implement large WCF solutions in a more efficient and agile manner. Additionally, the session presents three case studies that highlight how customers are implementing some of these solutions to adopt WCF at a big scale in the enterprise.

    At 2:00pm to 3:30pm, Thursday 20th October

  • User interface architecture for distributed (cloud-based, web) applications

    by Allen Holub

    This class presents 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’s suboptimal. We’ll then move on to more appropriate architectures: Presentation-Abstraction-Control, Visual Proxy, and bifurcated objects.

    At 2:00pm to 3:30pm, Thursday 20th October