Sessions at Software Architect 2011 on Friday 21st October

Git is a version control system which you may have been hearing a bit about lately. But simply hearing more about it may not be enough to convince you of its value. Getting hands-on experience is what really counts. In this workshop, you’ll bring your Windows, Mac or Linux laptop and walk through downloading, installing, and using Git in a collaborative fashion.
The workshop style of this class will allow you to observe and discover the value of this new version control tool first hand. You’ll be cloning, creating, committing, and pushing repositories by the conclusion of this session.
In this Git course, we’ll cover the full gamut of using Git effectively, including the syntax and the refactored thinking and capabilities that Git brings to the table. Once the new mindset of Git and DVCS’s has been established, the power of Git’s staging area and content tracking (not just file tracking) is fully revealed. The performance characteristics of Git versus Subversion are explored and put into perspective.
The outline, which dynamically adapts to questions, is as follows:
• Setting Up Git
• Configuring Git
• Three Stage Thinking
• The Git File Workflow
• Speed
• Cloning Repositories
• Command Composition
• Storage
• Hashes
• Branches
• Remotes
• Tagging
• Merging
• Rebasing
• Undo
• Git-SVN
Attendees should have at least some familiarity with any version control system such as TFS, SourceSafe, Subversion, ClearCase, CVS or Perforce.

The web is fast becoming a serious competitor to traditional enterprise architecture approaches. This tutorial will provide an introduction to RESTful web service techniques, both from a theoretical and practical perspective.
The tutorial is broken down as follows:
• Introduction and motivation
• The web architecture
• Simple web integration including POX and URI tunnelling
• CRUD services using URI templates and HTTP
• Semantics using Microformats and RDF
• Hypermedia and the REST architectural style
• Scalability and how a text-based client-server polling protocol outperforms everything else!
• ATOM and ATOMPub for event-driven and pub/sub applications security
• Conclusions and further thoughts
Participants should be comfortable with distributed computing concepts, but won’t need any particular integration or middleware experience.

.NET 4.0 introduced a number of technologies into the .NET world. This workshop looks not only at these technologies but, more importantly, how they can be combined into compelling applications.
We will cover ASP.NET MVC3, WCF 4.0, Workflow 4.0 and Entity Framework 4.0 along the way, and show you not only the benefits of these technologies but also where they can cause problems.
During the workshop we will build a functional n-tier application that demonstrates the technologies “in-situ” and shows patterns that you can use to keep your architecture clean.

Designing software given a vague set of requirements and a blank sheet of paper is a good skill to have, although not many people get to do this on a daily basis. However, with agile methods encouraging collective ownership of the code, it’s really important that everybody on the team understands the big picture. And in order to do this, you need to understand why you’ve arrived at the design that you have. In a nutshell, everybody on the team needs to be a software architect.
This tutorial will show you what “just enough” up front design is, how it can be applied to your software projects, and how to communicate the big picture through a collection of simple lightweight diagrams.
Join us for a mixture of presentation, discussion and deliberate practice.

If you’re architecting and building big WPF or Silverlight applications, then it’s a fair bet that you should be considering using either (or both) of MEF or Prism.
The Managed Extensibility Framework (MEF) makes it easy to build pluggable, flexible applications. Prism provides rich guidance and sample (reference) implementations to help you build large, modular applications.
This workshop provides an intensive day working with these two complementary technologies. We’ll begin by building a modular application comparing and contrasting approaches that we can take using MEF and Prism. We’ll examine shells, catalogues and containers. We’ll drill down into building region-based UIs, and we’ll power through commands and loose pub/sub event architectures.
Throughout the day, you’ll see how to combine MEF and Prism, and how you might go it alone with just MEF or Prism. Plus you’ll see how to handle issues such as deployment and versioning.
The session assumes no prior knowledge of MEF or Prism (although we will go deep quickly!), but you should already have a basic knowledge of Silverlight or WPF.

Without good OO structure, Agile development, which mandates constant refactoring, fails. Design Patterns help by providing classes of solutions to common programming problems. Patterns, however, are usually presented in a catalogue format that gives you no feeling for how the patterns are actually applied in the real world, where the patterns interact in complex ways.
This class discusses both good object oriented structure and the most commonly used design patterns, using an in-depth analysis of real code that demonstrates how the patterns work in context. We’ll also cover interface-based design and the make up of a well-structured object and class hierarchy.
The extensive code examples are in Java, but they should present no problem to C++ or C# programmers.