| |
TRACK 1 |
TRACK 2 |
TRACK 3 |
TRACK 4 |
TRACK 5 |
09.00 |
Coffee |
09.30 |
What’s new in Windows Workflow Foundation 4.0
Richard Blewett
Windows Workflow Foundation is having a major overhaul in the next version of .NET. This session looks at the drivers that pushed the team to take radical action, what the new features are, and what it means for your WF 3.5 applications today. |
Pattern connections
Kevlin Henney
Patterns are often considered and presented in isolation or as part of a loosely themed catalogue. However, much of their power comes from connecting them together to describe whole systems or frameworks and how to build them. This session revisits core pattern concepts, using examples to illustrate trade-offs involved in favouring one design over another and how the appropriateness of a pattern is sensitive to the context in which it is applied. Examples are presented using UML and code in various languages. |
High performance SOAs
Jesus Rodriguez
Achieving sustainable levels of performance is one of the biggest challenges of Service Oriented (SOA) solutions nowadays. Are you wondering how to scale your SOA to tens of thousands of applications? How to prioritize the messages from the different applications? How to correctly handle downtimes and failures? How to implement resource intensive capabilities such as transactions or stateful messaging without sacrificing my performance? How to monitor your SOA infrastructure and control the service level agreements (SLA)? Correctly addressing those questions can very well dictate the success or failure of your initiatives towards SOA.
This session summarizes the lessons learned in the implementation of a number of large scale, high performance service oriented solutions. The session will illustrate a set of architecture patterns and techniques to enhance important SOA aspects such as performance, scalability and reliability also encompassing other features such as long running transactions, security, federation or stateful messaging. Additionally, we will provide practical implementation techniques for these patterns using technologies such as Windows Communication Foundation 3.5/4.0, Windows Workflow Foundation 3.5/4.0 and the Windows Application Server (Dublin). |
Architecting for multi core
Andy Clymer
The free lunch is over, applications don’t get a massive performance boost as new CPUs arrive. In order to take advantage of the increased power, applications need to be architected to take advantage of the multiple cores, this requires a shift in the algorithms and techniques we employ. This talk will introduce a variety of parallel processing patterns utilising Microsoft’s Parallel Framework Extensions, soon to be included as part of .NET 4.0. |
“ConFront” — multi-solution (“sharded”) .NET development using Authenticating Front Controller Rewriting Proxy at Confused.com
Phil Murphy
When developing large, complex, multi-feature websites, the prescribed ASP.NET approach has been either to develop one all-encompassing .NET deployable (which can lead to problems of managing source branches, results in big-bang deployments, and requires pan-site regression testing), or by subfolders in IIS (which couples the url structure too tightly to the folder structure, and cannot share authentication/session information).
This talk details a Third Way, devised by Phil and Kevin while consulting at Confused.com (dubbed “ConFront”), and currently underpinning Confused.com’s very busy web site. We feel the technique could usefully be applied to other large, multi-area web applications, with many benefits. |
11.00 |
Coffee Break |
11.30 |
What impact will Entity Framework and Entity Data Model have on application architecture
Eric Nelson
The Entity Framework is a strategic technology from Microsoft. In version 1 the focus was on helping developers use an ORM within their application and to expose data as RESTful Web Services, but version 2 extends this to include scenarios such as reporting. In this session we will look at what is the impact, both good and bad, of embracing an ORM technology and specifically, the impact when that technology is the ADO.NET Entity Framework. |
Objects of desire
Kevlin Henney
Given that object orientation underpins modern programming languages, it would be expected that anyone using languages such as C# or Java would also know about OO and that, for the architect, application of OO techniques should be a minor issue. Although object orientation is far from being a new approach (think Sergeant Pepper), and it’s also far from being obscure, its mainstream adoption by programmers and programming languages alike is not always as effective as it could be, and sometimes the results can be less than desirable (to put it politely).
Good programming and design practice has architectural implications, as does poor practice. This session aims to put a number of concepts practitioners may be unsure of on a firmer footing, highlighting common pitfalls in OO practice — such as abuse of inheritance, simplistic getter/setter interfaces, patternitis, use of singleton objects — and emphasising techniques that promote an easier life and reduce architectural friction, such as loose coupling, unit testability, pattern-based design thinking, incremental and sufficient design. |
How good are you at .NET software design?
Dino Esposito
Dino Esposito
Just as an architect wouldn’t design a house ignoring the laws of gravity, a software architect shouldn’t design a piece of software ignoring basic principles of software design such as low coupling, high cohesion, separation of concerns, information hiding.
In this session, we’ll first reconsider the fundamentals of software design, and then move on to review the basic principles of object-oriented design including an analysis of the pros and cons of inheritance and composition. Finally, we touch on a few more advanced principles of OOD such as dependency inversion and the substitution principle. If you’re really a good software architect nothing in this session should come as a surprise. But you can only find out if you come! |
Great-looking models, and how to make them work for you
Steven Kelly
We’ve all had bad experiences with models: you work with them for hours but get no concrete results, or you have an early spurt of enthusiasm but tire quickly. In many cases, it’s a problem of communication. In this session we’ll look at how to get everybody speaking the same language — the practical, repeatable steps to create your own domain-specific modeling language or DSL. The steps are incremental, solving what is for many the hardest part: starting from a blank screen to come up with something that isn’t just a variant of UML, but will actually raise abstraction and productivity. |
Rich Internet Applications for architects
Dave Wheeler
Rich Internet Applications, or RIAs for short, have seemingly become the latest and greatest form of application. With two major contenders, Microsoft Silverlight and Adobe Flex, currently fighting it out for top spot, it can be tough to decide which one you should choose. The story gets even more convoluted when you factor in runtimes such as AIR that enable RIAs to run outside of the browser.
This session will help you to understand what you can, and cannot, do with a RIA; what the main differences (and similarities) are between Silverlight and Flex; what the impacts are to your overall system architecture; the challenges that your developers are likely to face; and what specific security issues you need to consider. |
13.00 |
Lunch |
14.00 |
Contract first design with WCF
Richard Blewett
In WCF the contract that a service exposes is defined by code. However, is that the best starting point? If you start with the code and annotate your types, how do you know if you haven’t inadvertently exposed your type system internals to service consumers? Design by contract is a different way of approaching service design. This starts by stating what functionality will be exposed at the service and expected by the client. This model means you have an implementation independent form of the contract: perhaps WSDL or a Domain Specific Language and then you generate the client proxy and the service skeleton from this abstract definition. This approach is more robust, particularly in interop scenarios. In this talk we will look at how far the WCF tooling can take you down this path and what we have to fix up any shortcomings. We will also look at other tools that start from a design by contract premise. |
Modelling in the age of agility
Kevlin Henney
The practice is of modelling is often associated with heavyweight UML diagrams that are drawn up with the best intentions, but often either leave their readers confounded or are simply left to one side while the other activities in development proceed apace. Modelling has been associated with plan-driven approaches and big up-front analysis and design, at odds with the emphasis of agile approaches. There is, however, another side to modelling that deserves the attention of anyone involved in development, whether they adopt an agile mindset or not.
Modelling is not the preserve of plan-driven methods, and the problem often lies not with modeling per se but with overdosing on models and failing to use modelling as an opportunity for communication. Models that are drawn up by individuals in isolation from one another are often the culprit. Often the secret to effective modelling is more in the -ing than the model. |
Reconstructing software architectures
Mark Dalgarno
‘Inheriting’ software you don’t really understand can be a painful experience. Whether it’s a big ball of mud, spaghetti or just plain weird we all will typically have to work with such software at some point in our careers.
This session describes some practices for systematically approaching the task of reverse engineering such software to reconstruct its architecture and so help reduce the pain of working with it.
Along the way we’ll pick the brains of audience members by way of group exercises looking at different aspects of the reverse engineering problem. |
From SOA to WOA: introducing Web Oriented Architectures
Jesus Rodriguez
Despite being one of the latest acronyms in the never-ending distributed programming dictionary, Web Oriented Architectures (WOA) represents one of the most important architecture styles in service orientation. In a nutshell, WOA incorporates the principles of the Web and Representational State Transfer (REST) into Service Oriented Architectures (SOA) to achieve high levels of performance, availability and scalability.
This session explores the fundamental principles and patterns of Web Oriented Architectures (WOA) and how they can enhance the way we build SOA solutions today. Specifically, we will demonstrate how REST enables a new set of patterns around key SOA principles such as service composition, message brokering, routing, publish-subscribe messaging, load distribution and long running transactions. Finally, we will compare and contrast WOA with the traditional patterns we use to build services today in order to help architects and developers to select the right architecture style for the right scenario. |
Communication skills for geeks
Neal Ford
Software is fundamentally a communications game, and good communication skills differentiate between good and great developers. This session describes communication techniques and skills to people who skipped English 102 to hack some code. I talk about effective communication techniques for presentations, documentation, memos, and how to sell your technical ideas to a non-technical crowd. |
15.30 |
Coffee Break |
16.00 |
Designing UIs with the Composite Application Guidance
Dave Wheeler
The Composite Application Guidance, AKA “Prism”, offers a significant breakthrough in how you design and build user interfaces for Windows Presentation Foundation and Silverlight. In this session, you will gain a solid understanding of the core features of Prism along with its main benefits and weaknesses. You will also get a detailed understanding of the impacts that using Prism will have in your overall application architecture, such as exposing data-bound commands from your ViewModels, its intrinsic support for TDD, the role of DI within the UI, and the use of Prism’s pub-sub event architecture.
This is a “must see” technology for any serious WPF or Silverlight architect/developer. |
Test-driven design
Neal Ford
Most developers think that Test-driven Development (TDD) is about testing, but testing is only a small benefit from using TDD techniques. This session demonstrates how stringent TDD improves the structure of your code. I discuss TDD as a technique for vetting consumer calls, using mock objects to understand complex interactions between collaborators, and some discussions of improved code metrics yielded by TDD. This session shows that TDD is much more than testing: it fundamentally makes your code better at multiple levels. |
ASP.NET MVC vs. ASP.NET Web Forms
Dino Esposisto & Dean Smith
It risks becoming an endless debate: should you use ASP.NET Web Forms or the newest ASP.NET MVC to build your next application? The simple answer is that there’s no winner and no loser. The frameworks are functionally equivalent and just bring two different philosophies into ASP.NET development. So it is mostly a matter of preference, but it is also an architectural decision not to be made lightly. In this session, we’ll compare and contrast the two frameworks from a number of different perspectives including reporting capabilities, data entry, AJAX, data binding, HTML, styling, and more. |
REST in the real world
Jesus Rodriguez
Are you wondering how other companies are leveraging Representational State Transfer (REST) in their Service Oriented (SOA) solutions? What are the lessons they are learning and the challenges they are facing? This session illustrates how a large airline is taking advantage of REST in order to enable their next generation solutions. The session explores in detail a large number of scenarios and challenges faced in key areas like service modeling, caching, error handling, resource categorization, security, management and governance, among many others. Additionally, we demonstrate how the capabilities and extensibility model of Windows Communication Foundation (WCF) and the REST Starter Kit helped to address those challenges and enable a true RESTful distributed environment. Finally, we will emphasize the best practices, techniques and lessons learned that developers can follow in order to take advantage of RESTful services in their organizations. |
Documenting your software architecture — why and how?
Simon Brown
A description of your software architecture is essential for any project of any size, explaining the rationale behind the design decisions and how the software will work in the real world. Such descriptions should include an explanation of the software structure, the architectural principles adopted, the constraints in force, the platforms on which the system is deployed and an explicit justification of how the architecture satisfies the requirements. A good software architecture document should describe what the code itself doesn’t. This session will tell you how to do this.
This session is aimed at anyone with software development experience. |
17.30 |
End of Conference |
|
