| |
TRACK 1 |
TRACK 2 |
TRACK 3 |
TRACK 4 |
TRACK 5 |
09.00 |
Coffee |
09.30 |
Foundations of Enterprise Design Patterns in .NET
Dave Wheeler
Developers and designers are becoming increasingly familiar with the GoF Design Patterns, and will happily churn out Singletons and Factories to their hearts’ content. But is there a next level in the world of patterns? There certainly is, and in this session you will see be introduced to that next level: Enterprise Design Patterns. Specifically focusing on the origins, intents and thinking behind some of the most basic enterprise design patterns, this session will provide you with the foundation knowledge that you need to dive into using them within your own .NET application designs. |
Volta – A New Way of Writing Distributed Applications?
Richard Blewett
In December 2007, Microsoft announced an incubation project called Volta which promised to abstract the developer away from the plumbing of writing distributed applications. In this talk we will look at what Volta delivers, and assess how effective this infrastructure currently is and where it may be taking us. |
Lean Software Development
Kevlin Henney
Agile software development covers a broad range of practices and ideals, but is often characterised (and even caricatured) in terms of just being another term for Extreme Programming or having little concern for architecture. The truth is invariably more subtle, and it is worth examining agility from a different perspective to see where architecture and process variation play a role. Such a perspective is provided by Lean Software Development, which takes the lessons of Lean Product Development and Lean Production and applies them to software development.
This session presents the adaptation of Lean principles and tools for software development identified by Mary and Tom Poppendieck. The principles of Eliminate Waste, Amplify Learning, Decide as Late as Possible, Deliver as Fast as Possible, Empower the Team, Build Integrity In, and See the Whole are presented and applied to software architecture. |
Moving from Coding to Model-Driven Development
Steven Kelly
Everybody would like the productivity benefits of modelling with full code generation, but the upgrade path from coding to modelling seems a closely guarded secret. This session will demystify Domain-Specific Modelling, open the lid on the OMG’s MDA, and shine a light on Microsoft’s Software Factories. We will show which bits of Model-Driven Development (MDD) work, which might work, and which don’t, and explain where they can be applied – and where not. Most importantly, we will show the steps to define your own modelling languages and generators to start using models effectively, road-tested in dozens of projects over a decade.
Attendees should have some experience with using a modelling and/or code generation tool. |
Why Software Projects Fail
Simon Brown & Kevin Seal
The industry has a love/hate relationship with the Software Architect role, with many organisations dismissing it because of their negative experiences of architects that dictate from ivory towers and aren’t engaged with the actual task of building working software. This reputation is damaging the IT industry and inhibiting project success. Things need to change. This session looks at some of the reasons why software projects fail, and presents the view that a good, hands-on software architect can be invaluable in addressing these issues and driving the project to a successful conclusion. Software architects are here to help, not to hinder. |
11.00 |
Coffee Break |
11.30 |
More Enterprise Design Patterns in .NET
Dave Wheeler
90 minutes is barely enough time to scratch the surface of the Enterprise Design Pattern world, so this session will build on the previous one by introducing some of the more advanced patterns, picking apart their benefits (and their downsides) and making them easy to work with. We will also examine specific .NET technologies and how they help you to utilise, or in some cases obstruct, a number of the common EDPs. |
Visual Studio Team System for Project Managers
Kevin Jones
VSTS provides many tools for project managers to allow them to monitor the status and the health of a team project. This talk will examine how VSTS allows integration into Microsoft Project and Microsoft Excel. However the main bulk of the talk will be about the reports and reporting system used by VSTS. How do you use the build system to generate the reports? How do you interpret the reports? How do you use the reports to troubleshoot the health of the project, and how can you create your own reports? |
Software Transactional Memory – Making Multithreading Easier
Ralf Westphal
Concurrent programming is inevitable if we want to exploit future processor generations in our applications. But despite the technical ease with which we can start threads, wait on signals, and lock objects with the .NET Framework, concurrent programming is still conceptually difficult. Synchronizing multiple threads accessing share in-memory data structures is not for the faint of heart. But help is on its way! Software Transactional Memory (STM) promises to make parallel shared data access as easy as concurrent database programming. Instead of manually locking shared data, all access to it just needs to be wrapped in in-memory transactions. After a discussion of multithreading’s hurdles the session will demonstrate an Open Source C# implementation of the STM concept as a pragmatic solution. |
Meta-programming Ruby for Fun & Profit
Neal Ford
This session shows one of the reasons that JRuby is the most powerful mainstream language today: meta-programming. It shows tons of meta-programming techniques in Ruby, including open classes, the shadow meta-class, defining methods, method_ & const_missing, dynamically adding and removing mixins, and more. And each of these comes with an example that actually makes sense! Come see why all the cool kids love Ruby so much (no prior Ruby experience necessary, but open mind required). |
Creating Sustainable Architecture
Kevlin Henney
Many software systems have fragile architectures that are based on brittle assumptions or rigid architectures that reduce options and make change difficult. On the one hand, an architecture needs to be fit for the present day, suitable for immediate use, and on the other it needs to accommodate the future, absorbing reasonable uncertainty. However, an approach that is overly focused on today’s needs and nothing more can create an inflexible architecture. An approach that becomes obsessed with possible future changes creates an overly complex architecture that is unfit for both today’s and tomorrow’s needs. Both approaches encourage an early descent into legacy for a system.
The considerations presented in this session reflect an approach that is more about thinking in the continuous present tense than just the present or the future tense. This includes principles from lean thinking, practices common in agile processes and techniques for loosely coupled design. |
13.00 |
Lunch |
14.00 |
“Design Patterns” in Dynamic Languages
Neal Ford
The Gang of Four book was two books: a nomenclature describing common software problems and a recipe book for solutions. The vocabulary they defined is still useful. Dynamic languages have powerful meta-programming facilities far beyond statically typed languages. It turns out that many of the structural design patterns in the Gang of Four book and beyond are much easier to solve with meta-programming. This session compares and contrasts the “traditional” approach of design patterns with a more nuanced meta-programming approach. Using language features creates cleaner abstractions with fewer lines of code and little or no additional structure. |
Designing and Building Identity-aware Applications using Microsoft’s “System.IdentityModel”
Dominick Baier
The security scenarios of distributed applications get more and more complex. Role based security, which was the prevalent form of authorization for the last decade, simply can’t cope with these requirements any more. This is the reason Microsoft introduced a brand-new (starting with .NET 3.0) authorization framework into the .NET base class libraries, also known as “System.IdentityModel”. This API is based on tokens and claims, and integrates seamlessly into today’s emerging identity technologies like SAML and Security Token Services. This talk walks you through this new framework, and shows you how to streamline your authorization system using the above mentioned technologies. Furthermore you will learn how these APIs fit with other Microsoft technologies like ASP.NET, WCF, CardSpace and Active Directory Federation Services. |
Weaving Magic – Aspect Orientation for Muggles
Ralf Westphal
Every application contains code that does not really add to the application’s functionality, but is still necessary. Examples for such orthogonal aspects are caching, validation, persistence, tracing, or transactionality. In order to avoid cluttering the application-specific code, it would be nice to get this code out of the way of the main flow of control. That’s what Aspect Oriented Programming (AOP) is about. Unfortunately the AOP concept so far has suffered from technical hurdles, since it’s not a part of the .NET platform. But this session will demonstrate how mere mortals can now weave aspects into their applications. With the help of an Open Source post-compiler AOP and other feats of MSIL injection will no longer be magic tricks of a few, but tools at everybody’s disposal. |
20 Examples of Domain-Specific Modelling with Full Code Generation
Steven Kelly
This session reviews 20 industry cases using Domain-Specific Modeling with full code generation. The cases cover various fields of software development, including finance, telecom, automotive, home automation and business workflow applications, generating code ranging from assembly language and 3GLs to scripting languages and XML. Some cases have been in use for over 10 years, whereas others have recently been developed. We will look at the modeling languages, code generators, and examples of their use. From these cases we synthesize the most effective approaches to move towards model-based full code generation.
Attendees should have at least a basic degree of knowledge about modeling. |
The Evolution of Software and Services
Matt Deacon
Organisations have been using external IT services for many years. Recently, however, there have been some significant developments in the industry with regard to the options available, from off-shoring of consulting and development work to the maturing of offerings aimed at delivering software as a service, but in a manner that fits more seamlessly into enterprise IT landscapes. The Microsoft Architect Council have recently been engaged in a project to gain an understanding of the perceived challenges impacting UK organisations as they approach the definition and implementation of their sourcing strategies. This session will focus on the primary findings in the report. |
15.30 |
Coffee Break |
16.00 |
BI Architect
Mark Whitehorn
BI (Business Intelligence) is a term that describes the extraction of useful business information from data. It embraces data warehouse, OLAP, data mining, ETL and a host of other techniques, technologies, acronyms and buzzwords. One important lesson we have learnt over the years is that developing BI solutions piecemeal within a company is not simply inefficient; in can be catastrophic. BI systems have to be designed as a whole; hence the role of BI architect has appeared. This talk will discuss the job role as well as the skills and experience necessary. |
Digital Identity – the Best Example of SaaS?
Steve Plank
As architects, we love it when some aspect of computing can be abstracted away, placed behind a non-permeable border and only permit trusted access from our core applications. Software as a Service takes this to the next level by introducing the notion of generalised services that might be of use to all and many applications. Examples such as voice messaging, text messaging, calendaring, payments, mapping and so on come to mind. If there is one example of a service that every application needs – it has to be Digital Identity. Authentication and authorization do not need to be built in to the internal workings of applications any more. Web Service protocols, digital signatures and encryption allow for a rich digital-identity-SaaS model.
This session highlights the key things to consider when architecting digital identity systems, including digital identity definitions, profiles, passwords and user accounts, authentication and authorisation, multiple-source identities, and protection against MITM and replay attacks. We then go on to give some examples of Identity-SaaS that are being pursued by organisations today, and highlight the good, the bad and the ugly of these systems. |
How Virtualisation Can Assist With Architecture and Software Development
Robert Annett & Dean Smith
Virtualisation is increasingly used in systems architecture, and allows for easier maintenance of systems and more effective use of hardware. It’s tempting for the software architect to dismiss the underlying systems as ‘plumbing’, but knowledge of these tools can really assist the architect, developer and project manager. If you have issues with maintaining multiple environments, supporting unique customer builds, or the horrors of regression testing, then virtualisation can help.
In this session we will identify some common problems faced on the software side and demonstrate how virtualisation can assist.
Attendees are assumed to have at least a basic knowledge of development processes and practices and IT systems. This talk does not assume any knowledge of virtualisation, and will be accessible to any developer, architect or technical project manager. |
Raising the Bar for Mainframe SOA
Rob Morris
When it comes to integrating mainframe assets into today’s SOA applications, many organisations have proceeded with very low expectations and, as a result, have minimal results. Assuming that there were no tools to effectively bridge the gap between mainframe applications, data and knowledge, and the service-oriented demands of today’s customer-centric enterprises, they have been satisfied with a rudimentary approach. Typically, this consists of wrapping discrete chunks of mainframe functionality as Web services, and publishing them for non-mainframe service developers to do with what they can. In any other area of the corporate information infrastructure this would be unacceptable; but intimidated by its seeming intractability, SOA architects have settled for less when it comes to integrating the mainframe. In this session you’ll gain critical insight into the components of mainframe service integration, and discover how companies are more successfully leveraging the mainframe’s active participation in strategic SOA initiatives. |
Sharing Architectures
Simon Brown & Kevin Seal
The transition from architectural vision to production code is not always an easy one. Of course we plan for a certain amount of change and accept that some decisions will, on occasion, be wrong. However, without effective communication of the architecture and timely feedback mechanisms, can we really expect to see software that we recognise?
Whether we’re up to our elbows in an agile team or riding a barrel down a waterfall project, our choice of what we define and how we convey it can have an enormous bearing on how the architecture is reflected in the software. This session takes a look at some techniques for sharing the architecture and not just publishing it. |
17.30 |
Drinks Reception |
|
