| |
TRACK 1 |
TRACK 2 |
TRACK 3 |
TRACK 4 |
TRACK 5 |
08.30 |
Registration & Coffee |
09.30 |
Opening Keynote – The Skilled Architect
Kevlin Henney
What makes a skilled architect? Is it certification, or deep knowledge of a single technology, or the ability to police enterprise-level technical decisions, or prowess with UML? Or is it something broader and more substantial? All too often attempts to characterise architectural skill end up pigeon-holing or caricaturing a few of the traits needed, often to the exclusion of other traits.
Skilled architects tend to possess a combination of technical and non-technical skills that cut across simple categories. They need a wide-ranging toolbox of know-how to draw from, including a solid technical background, rapid appreciation of unfamiliar technologies, a facility for understanding the big picture, attention to detail, decision making, verbal and visual communication skills, an understanding of development process, the ability to prioritise, sociability and humility. |
11.00 |
Coffee Break |
11.30 |
Typed DataSets, LINQ to SQL, LINQ to Entities: Data Design Patterns Do Matter
Dino Esposito
Data access code has not changed significantly in the last 15 years. Most of the data access patterns introduced by ODBC in the early 1990s are still the foundation of OLE DB, JDBC, and ADO.NET. The query is expressed as a text string that is opaque to the programming language. Results are returned in untyped data records. Not to mention the intricacies of JOINs and grouping that often require developers to build a totally different skillset. There is a strong need for applications to manipulate data at the conceptual level so that data can be easily transformed into objects that are more natural for the application to work with. In the beginning it was the DataSet, better its typed version, with a little help from wizards in Visual Studio 2005. As weird as it may seem, such an approach is the implementation of a popular design pattern – the Table Data Gateway. We may not have the silver bullet, but we do have insights on data access at the time of Visual Studio 2008. |
Inside ASP.NET MVC
Dave Wheeler
ASP.NET is undergoing a radical change with the introduction of a new MVC framework. This will have significant impact on the way that you design and build ASP.NET applications. In this session you will learn how to make the most of the new MVC framework to write testable, scalable and maintainable ASP.NET applications. There will be some code presented during the session, but the focus will very much be on the architectural and design impacts of this new and exciting approach. |
10 Ways to Improve Your Code
Neal Ford
It is too easy to get into a coding slump and not realize it. This talk revitalizes your relationship to code, forcing you to rethink some of the things that you take for granted and showing new approaches to solving hard problems. It covers topics that range from improve the overall structure of your code to the way you write JavaBeans, with lots of examples. Everything in this talk may not be new to you, but I guarantee that you’ll see some things that will make you re-evaluate the way you think about your code. |
System-Level Modelling with UML
Eoin Woods
Many information systems environments are characterised by a large number of systems linked together in many varied ways. The difficulty with such environments is keeping track of the systems and connections and understanding the implications of proposed changes. One way to address this is to create a suitable model of the environment that captures systems, interfaces, connections and shared data types. This session explains an approach to creating such models using UML, by using a specific set of conventions and a number of extensions to the UML language via a custom profile. It also explains how to implement the approach in widely used UML modelling tools.
This session is aimed at architects, designers and analysts involved in complex system integration. Some experience with UML and modelling tools would be valuable but isn’t essential. |
When Good Architecture Goes Bad
Mark Dalgarno
As software evolves, its architecture ‘as-is’ deviates from its architecture ‘as-hoped-for’ – the architecture is said to decay. Architectural decay can be a problem because:
• The time, effort and risk in implementing further changes increases
• The effect of further changes becomes harder to predict
• Further changes typically cause the ‘as-is’ architecture to deviate further from the ‘as-hoped-for’ architecture – the situation becomes worse
This session looks at examples of architectural decay, and explores practices to prevent or slow such decay. No specific technical knowledge is assumed; any architect or experienced developer should be able to benefit from attendance and understand the concepts presented. |
13.00 |
Lunch |
14.00 |
Pattern Connections – Part 1
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 first 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 diagrams and code in various languages. |
Service Composition with WF and WCF
Richard Blewett
One of the promises of SOA is that you can create building block services and then compose them into higher order functionality – re-use at the service level. Due to the declarative model of WF it provides a powerful infrastructure for service composition. In this talk we look at the functionality introduced in Visual Studio 2008 to enable WF and WCF to integrate effectively, which is the cornerstone of service composition with WF. |
Code Metrics & Analysis for Agile Projects
Neal Ford
Agile projects focus on delivering code; responsibility for the quality of that code lies with developers. Yet most developers have a poor sense of how to gauge the quality of code, both during development and forensically. This talk lives on the boundary between what is important in agile projects and ways to verify code quality. It is both a survey of tools and metrics and strategies for proactively applying these techniques to ongoing projects. I talk about the Hawthorne effect, analysis tools, useful metrics, tools for generating metrics, and how to analyze raw data into actionable tasks. |
One Type Fits All – the (Web?) Applications of the Near Future
Dino Esposito
AJAX is much more than just a way to call a remote piece of code on some servers. After a decade in which we architected and built Web applications using HTTP, HTML, JavaScript over the postback model, AJAX showed us that remote calls are possible – bypassing the browser and the postback model. This brings up a brand new paradigm for applications – the same paradigm for desktop and Web. The great news is that we can now move part of the workload on the Web client up to make it become a sandboxed smart client. The bad news is that building Web applications using the new paradigm is definitely hard, although straightforward to make sense of. This means that we lack proper tools. But what’s a “proper” tool to architect such applications? In this talk, we’ll take a look at the emerging model and the main features of Google GWT and Microsoft Volta. |
Does Architecture Really Help?
Eric Nelson
Building an application is not simple. Building an application turns out to be actually rather hard. Which is odd – as each year we get better languages, better tools, better databases and better resources. Yet still applications are really hard to build. This session will explore the reasons behind this and examine such questions as “Is choice a good thing?”, “Is there a perfect architecture”, “Does architecture matter?” and “What are we trying to solve with architecture?”. To help make the discussion concrete and relevant, we will drill into the impact of specific Microsoft technology releases on the quest for a great application and a great architecture – by looking at technologies which span 10 years! From the arrival of MTS and ASP to the most recent releases of ADO.NET Data Services, ADO.NET Sync Services and Silverlight. It should be fun! |
15.30 |
Coffee Break |
16.00 |
Pattern Connections – Part 2
Kevlin Henney
This second session considers the ways in which patterns may be combined, presenting some of the current thinking on concepts such as pattern compounds, pattern stories, pattern sequences and pattern languages. Along with the concepts, illustrative examples are presented using code and diagrams, as appropriate. The two sessions encourage attendees to think beyond their conventional pattern vocabulary. |
WCF-based Messaging with the Internet Service Bus
Christian Weyer
New buzzwords all over: Software+Services, The Cloud, ISB et al. This session will introduce you in a practical fashion to Microsoft’s ‘Biztalk Services’ (this is NOT Biztalk Server!) offering, implementing an Internet Service Bus (ISB). See and learn how to design and implement composite applications that can leverage the power of the Internet cloud without leaving your well-known and beloved world of WCF programming. We’ll present use cases and solutions that build on top of the ISB’s Identity and Connectivity services to connect different shapes of services using appropriate messaging patterns. As an architect, you shouldn’t fear code and config. |
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. |
Pick a Client; Any Client
Dave Wheeler
The Presentation Layer should be simple, right? After all, it’s really just the “colouring-in layer” on top of the real application. Yet the vast array of client technologies now on offer makes choosing a presentation layer technology harder than ever before. This session will focus on the many different .NET client technologies: Windows Forms, Windows Presentation Foundation, ASP.NET (including ASP.NET AJAX) and Silverlight. You’ll get a good understanding of what each can do, where the different strengths and weaknesses lie, and hopefully be able to identify the sweet spot for each within your applications. |
Agile Architecture – How Much is Enough?
Eoin Woods
The agile movement values people over processes, working software over documentation, and most importantly the ability to react to change efficiently. Few software or enterprise architects would argue with these sentiments, as they are regularly judged on just these criteria. The challenge for software architects is to provide the co-ordination and common design needed to achieve a coherent enterprise IT environment, while working effectively with project teams to get systems delivered. This session will discuss a set of practices that have proven useful for architects working in agile environments, where the need for inter-project coordination must be balanced against the need for agility.
This session is aimed at software architects working with agile teams, and particularly those who work with a number of development teams simultaneously. |
17.30 |
Drinks Reception |
|
