•  

Software Architect 2011 schedule

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

  • Patterns and principles that matter in .NET [workshop]

    by Dave Wheeler

    Patterns come in all shapes and sizes. From the GoF Design Patterns for structuring object-oriented code through to some of Martins Fowler’s Patterns of Enterprise Application Architecture, patterns are everywhere. And, to be frank, some are more important than others.
    In this fun (and heavily code-oriented day), we’ll work through numerous patterns and see how they impact your code and architecture. There’ll be a trip into the world of Inversion of Control (IoC) and Dependency Injection (DI), and how this helps support testing and maintainability.
    There’ll be Models, Views, Controllers and even ViewModels hanging out in the presentation tier.
    We’ll step into the world of the Repository Pattern, with a side order of Unit of Work, and how that helps isolate our domain model from our underlying database.
    And we’ll look at different approaches to constructing the business logic layer, analysing their pros and cons.
    This is a highly practical, code and best-practice focused day for developers and architects who want to ensure that they’re building solid, maintainable and testable code.

    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

  • Build your own technology radar

    by Neal Ford

    ThoughtWorks’ Technical Advisory Board creates a “technology radar” 3 or 4 times a year. It is a working document that helps the company as a whole make decisions about what technologies are interesting and where we should be spending our time. This is a useful exercise both for you and your company. This session describes the process we use and how to adapt it to both your company and, more importantly, yourself. For career risk mitigation, you must know what the next big thing is, or at least be able to narrow it to a reasonable list. Attendees will leave with tools that enhance your filtering mechanisms for new technology and help you (and your organisation) develop a cogent strategy to make good choices.

    At 11:30am to 1:00pm, 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

  • Getting started with modern mobile development

    by Dino Esposito

    So you see mobile development in the future of your company, and you’d like to make sense of the buzz around it – platforms, tools, deployment, devices, gestures. This talk gives you the foundation you need to start defining your strategy and projects. In a scenario-based fashion, we’ll discuss mainstream platforms to target, mobile sites versus native applications, deployment policies and common patterns. Writing a working mobile application is only the first step and often it is not even sufficient to have it run on your own device. Not every mobile platform allows you to deploy the executable to the actual device seamlessly. In this talk, we’ll also review in detail the publishing and deployment strategies (and costs) for the most popular platforms: iOS, Android, Windows Phone 7, and BlackBerry.

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

  • NoSQL solutions on the .NET platform: what’s all the fuss about?

    by Jesus Rodriguez

    Non-relational databases have recently emerged as one of the hottest areas in software development. While many people are under the impression that the .NET platform is behind the curve on this, in fact there are several open source initiatives that bring NoSQL databases to the .NET platform. As .NET developers, we can take full advantage of the benefits of several NoSQL technologies in our enterprise solutions. This session explores various open source non-relational database technologies available in the Microsoft.NET platform, and the techniques and interfaces that can be used to interact with NoSQL technologies such as MongoDB, CouchDB or MencacheDB. We’ll also emphasise the aspects of NoSQL solutions that complement traditional relational database models in areas such as unstructured data indexing, archiving, map reduce techniques, demoralisation, among many others.

    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

  • Mobile dilemma: native apps vs. web-based apps

    by Dino Esposito

    If you need to reach the widest possible mobile audience you need to target multiple mobile platforms. However this is likely to involve rewriting your software twice or more, with subsequent higher costs and longer schedules. For this reason, many are considering developing mobile sites or web-based local apps leveraging HTML5 and JavaScript. Today, it is a matter of trade-off and gut feeling. Let’s discuss.

    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

  • From opinion to knowledge: how to assess User Experience

    by Tobias Komischke

    “Errr, I don’t know… what do you think?” – People working in software development are frequently confronted with user interface concepts, prototypes or applications and then are asked for their feedback about the “user experience”. While everybody has a gut reaction it can be hard to give a well-founded and constructive answer. This talk provides a 360-degree view on what the different dimensions of user experience are, and what concrete things you want to look for when assessing these dimensions. Next time you’re in one of those UI review meetings, you’ll own the place!
    The audience will be involved in a live usability test demonstration as well as a five minute Q&A period right at the end of the presentation.

    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

  • Why parallel programs fail

    by Stephen Blair-Chappell

    Not every attempt at making a program parallel is successful. In this session we present five case studies where parallelism did not achieve the expected results. Where programs actually failed, we examine the main causes of failure and suggest ways of overcoming them. Where programs were successfully parallelised but did not perform as well as expected, we look at the underlying reasons and show how to tune for better performance. Where the return on investment was considered to be too low, we analyse the reasons along with suggested estimates on programming effort for different kinds of parallel models. The examples here are all based on real projects. Finally we look at ways of spotting likely failures early in the software development cycle in order to avoid costly mistakes and wasted development effort creeping into a project.
    This session assumes attendees have some experience in C programming.

    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

  • LINQ and the Reactive Framework – a powerful new way to write code

    by Richard Blewett

    Reactive Framework is a new library that uses the new IObservable interface and LINQ to create a compelling new programming model that allows you to build “event” based code with declarative LINQ statements. This talk introduces the Reactive Framework and shows how it can greatly simplify your code.

    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

Schedule incomplete?

Add a new session

Filter by Day

Filter by Topic