Your current filters are…
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.
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.
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).
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.
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.
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. :-)
Herb Sutter famously coined the phrase “the free lunch is over” back in 2005, when it became clear that processor clock speeds were no longer obeying Moore’s law. If developers wanted applications to go faster they could no longer rely on greater clock speeds, they would need to think differently and restructure their code to take advantage of multiple cores in order to get better and better performance. It turns out parallelising all but the most trivial piece of code is challenging. .NET 4 attempts to assist the developer by providing support in the framework to assist parallelising algorithms through the use of parallel constructs like Parallel.For, and Parallel LINQ and a variety of concurrent data structures. The framework vendors would like you to believe that the free lunch is now back, but whilst they can deliver a moderate free lunch, if you truly want a gut-busting free lunch you will have to deploy a range of tricks for your algorithm to take full advantage of those multiple cores.
.NET 4 comes with a version of Entity Framework that is fit for purpose. Entity Framework is Microsoft’s ORM, their version of NHibernate. Entity Framework version 1 forced developers to be tightly coupled to Entity Framework, this goes against traditional ORM technology and creates problems for unit testing. Entity Framework 4 fixes this problem via POCO support. However it is still up to developers to work out how to utilise the technology to truly loosely couple application logic from business logic. This talk will take you through these new features and show how the repository pattern can be deployed with Entity Framework to provide a testable and loosely coupled solution.
by Allen Holub
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.
18th–21st October 2011