by Oliver Sturm
This full-day workshop sets out to describe the choices and opportunities available to programmers and architects alike, from a technical viewpoint with a .NET background. There will be room for questions, discussions and your own ideas!
Asynchronous programming is moving further into the mainstream with the introduction of the new async and await keywords. It is therefore becoming more and more important that we write async libraries for our own application stacks.
During this intensive day we will do a deep dive into how these new features work, and into the mechanics of how best to deliver asynchronous functionality in your applications, focusing not only on asynchronous compute but also on asynchronous IO, and how you can adapt existing old-style APIs to work with the new coolness.
by Simon Brown
Agility is about moving fast and this requires good communication. A consistent, shared vision is essential in order for teams to push in the same direction, but it’s surprising that many agile teams struggle to effectively communicate the architecture of the software they are building. As an industry we do have the Unified Modeling Language (UML), yet many people favour informal “boxes and lines” sketches instead. The problem is that such diagrams rarely make any sense, usually need a narrative to accompany them and ultimately slow the team down. Although we can argue whether UML offers an effective way to communicate software architecture, that’s often irrelevant because many teams have already thrown out UML or simply don’t know it. Abandoning UML is one thing but, in the race for agility, many software development teams have lost the ability to communicate visually.
This hands-on workshop is aimed at everybody involved in the software development process and is about improving architectural communication. You’ll see some patterns and anti-patterns related to NoUML diagrams, and you’ll learn some simple techniques for communicating software architecture using informal sketches.
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 which 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.
by Kevin Jones
When you look for it there appears to be no shortage of technical wisdom on what makes for clear and robust code. The quantity and consistency of such wisdom can, however, often leave programmers swamped. This may, in part, help explain why so much of the advice is ignored in so much code. Ideally there should be common themes that can be found across the many different specific practices identified as great and good, principles and overarching guidelines that help to make sense of the details and contradictions.
This session offers a thirteen-point list of recommendations (zero through twelve) which can be applied out-of-the-box to reduce code size and complexity, acting as guidelines for new code, indicators for refactoring and opportunities for review and discussion. The short list has no ambition to be all that you needed to know about design but were afraid to ask, but it does offer an easily memorable and rewarding set of practices for anyone who wants to ask better questions of their code. This workshop will also allow plenty of opportunities for discussion.
by Juval Löwy
Wonder about architecture best practices, guidelines and pitfalls? Or you sense there is more to decomposing a system based merely on requirements? Wonder how to design world-class systems? You understand the concepts but not how to apply them?
In the first half of this fast-paced tutorial, Juval will explain his original approach to large system analysis design and his method. Then, he will present a comprehensive case study, outlining the architecture that addresses the requirements, discussing logical tiers, security, interoperability, scalability, transactions, and other aspects of a modern application. You will see how to approach rarely discussed topics such as allocation of services to assemblies, allocation of services to processes, transaction boundaries, identity management, authorization and authentication boundaries and more.
by Dave Wheeler
Increasingly, developers have to work with technologies that are created with designers in mind. WPF, Silverlight, Windows Phone and Windows 8 all benefit from having a designer on the team.
Which is a shame, as the majority of the teams don’t have a designer.
This highly interactive workshop will kick-start your inner designer. Covering everything from the Savannah Principle to A/B Testing, and a host of stuff in between, you will leave this workshop with some practical skills in the areas of UI and UX design.
You’ll need to bring a laptop or tablet, something portable that you can take pictures with, and pen and paper to get the most out of the exercises. Plus you’ll need to bring plenty of imagination and a willingness to step out from being a mere developer.
by Jeff Prosise
For Windows developers, Windows Store apps are the future. This compelling new model can be used to write apps that run on desktops, tablets, and devices with other form factors.
In this pre-conference seminar, learn the essentials of writing Windows Store apps in XAML and C#, including how to craft modern UIs, how to build great touch interfaces, how to make your app come alive with live tiles and background tasks, how to integrate with the charms bar by implementing contracts, and a whole lot more.
by Simon Brown
Software architecture and coding are often seen as mutually exclusive disciplines, despite us referring to higher level abstractions when we talk about our software. You’ve probably heard others on your team talking about components, services and layers rather than objects when they’re having discussions. Take a look at the codebase though. Can you clearly see these abstractions or does the code reflect some other structure? If so, why is there no clear mapping between the architecture and the code? Why do those architecture diagrams that you have on the wall say one thing whereas your code says another? In fact, why is it so hard to automatically generate a decent architecture diagram from an existing codebase? Join us to explore this topic further.
.NET 4 introduced the new task abstraction, and C#5 will take advantage of integrating this into the language via the async and await keywords. In addition, the task abstraction promotes a new way of architecting asynchronous behaviour; not only for the client side but also for the server side, whether it be WCF or MVC. We will complete the session by building various async/await-friendly data structures.
by Nathaniel T. Schutta
The word just came down from the VP – you need a mobile app and you need it yesterday. Wait, you’ve never built a mobile app… it’s pretty much the same thing as you’ve built before just smaller right? Wrong. The mobile experience is different and far less forgiving. How do you design an application for touch? How does that differ from a mouse? Should you build a mobile app or a mobile web site? This talk will get you started on designing for a new, and exciting, platform. Whether that means iPhone, Android, Windows Phone or something else, you need a plan. This talk will help.
by Brock Allen
This session provides an introduction to ASP.NET WebAPI, which is the de facto framework in .NET for building HTTP-based (and RESTful) services.
We will cover the motivation for HTTP-oriented services as an alternative to SOAP-based services. We’ll examine the major tenets of HTTP-based services including the importance of URIs, HTTP methods and status codes, content negotiation and hypermedia. We’ll conclude with the new client-side programming model for HTTP services with the HttpClient API.
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, visualizations, tests) approaches to discovering design, and discusses the use of custom attributes, DSLs, and other techniques for utilizing 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.
by Oliver Sturm
Agile is a word that accurately describes a philosophy and practice of development that has gained credibility and voice in recent years. The practice and motivation of what many companies, teams, managers and developers are calling Agile, however, often seems a long way from the everyday use of the word ‘agile’ or what was meant originally by those who championed the term and the movement. Scrum, for example, is often portrayed as a simple adjunct to classic project management practices, its empirical basis and self-directed team philosophy often lost in a blur of micromanagement. The technical practices of Extreme Programming are often ignored as inconvenient or not core to a management-centric view of Agile. The same oversimplification and cherry picking can be seen in the wave of Lean thinking adopted into Agile as approaches such as Kanban enter the mainstream and suffer their own dilution.
This talk rewinds the clock and explores the motivation and implications behind the original Manifesto for Agile Software Development, the role of technical practices, the importance of quality in code and architecture, the evolutionary and adaptive nature of Agile, and the psychological and social underpinnings for many of the practices and concepts to be found in the successful application of Agile thinking.
by Dave Wheeler
Don Box famously coined the phrase “COM is love”. Fifteen years on, we’re still feeling the love for COM as we embrace its latest incarnation with WinRT.
This is a deep dive talk into all things WinRT, from the way that Windows 8 Store Applications get launched through to the language projections and the type system.
by Nathaniel T. Schutta
Almost every example of an Agile project involves a single team and while many successful projects are delivered that way, most enterprise software requires the interaction of several teams. But how do we scale Agile beyond a single team? What practices translate and which ones don’t? In this talk we’ll discuss some of the issues you’ll encounter as you move Agile beyond a single group and how you can keep multiple stakeholders happy. While it isn’t as simple as having a “scrum of scrums” it isn’t as hard as replacing every line of COBOL.
Perhaps you’ve heard about the next generation of databases, roughly classified as NoSQL databases? These databases are generally much better than RDBMS at scaling, performance, and ease-of-development (e.g. in NoSQL the object-relational impedance mismatch usually disappears). Unfortunately, many talks on NoSQL are very academic and general. Not this one.
We’ll explore the NoSQL landscape and look at the various options out there. Then we’ll learn how to leverage MongoDB (a popular NoSQL DB) to build .NET applications using LINQ as the data access language. From there we will build out a .NET application using LINQ and MongoDB in a series of interactive demos using Visual Studio 2012 and C#.
by Tobias Komischke
User experience is far more than usability. This presentation covers two crucial topics that can boost (or wreck) the user experience of software products. Attractiveness is one goal that every stakeholder wants to have for a product, but what is attractiveness? How can it be designed? What are the dos and don’ts? Rich interaction capabilities allow modern development platforms like WPF and Silverlight to provide much nuanced user-application interactions. Yet, are those rich features always really useful, usable and desirable? The presentation shows good (i.e. beneficial) and bad (i.e. disruptive) uses of rich interactions.
by Hadi Hariri
In this talk we’re going to get back to basics and understand the HTTP protocol and appreciate it for what it is: an application protocol. We will see how to effectively use HTTP to create a robust API for our applications which serve not only as end-points for integration but for the UI as well. We’ll see the differences between REST and HTTP APIs, and the benefits which the latter adds.
This is a session of back-to-the-metal, learning the ins and outs of what makes the web today.
OWIN is a fairly new specification for modelling an HTTP server API for hosting web applications. The intent is to decouple the host from the application with the goal of providing a simpler programming model with potentially better performance than traditional web servers. While OWIN is a specification, Katana is Microsoft’s implementation of an OWIN host.
In this session we will further discuss OWIN, Katana and how to write applications and middleware that take advantage of this new and exciting hosting environment.
Apparently, everyone knows about patterns. Except for the ones that don’t. Which is basically all the people who’ve never come across patterns… plus most of the people who have.
Singleton is often treated as a must-know pattern. Patterns are sometimes considered to be the basis of blueprint-driven architecture. Patterns are also seen as something you don’t need to know any more because you’ve got frameworks, libraries and middleware by the download. Or that patterns are something you don’t need to know because you’re building on UML, legacy code or emergent design. There are all these misconceptions about patterns… and more.
In this talk, let’s take an alternative tour of patterns, one that is based on improving the habitability of code, communication, exploration, empiricism, reasoning, incremental development, sharing design and bridging rather than barricading different levels of expertise.
by Jeff Prosise
Tap two devices together and transfer data between them? You bet! Learn about the Near-Field Communication (NFC) API in Windows and Windows Phone and see how to put them to work to connect devices more easily than ever before. The future of networking is here, and it is spelled NFC!
by Howard Deiner
Long before the Agile revolution for software development began, industry had learned that efficient production of goods required intense attention to quality, teamwork, and continuous improvement. These themes of Lean Manufacturing (which was further refined into the Toyota Production System) were never part of the original formulation of the Agile Manifesto, and are rarely mentioned as part of the traditional Agile/Scrum recipe for teams transforming to the new “Agile” mindset.
The reality is that the traditional Agile/Scrum recipe is actually a “dumbed down” version of the Toyota Production System, and makes it easier for organisations to grasp and start from. However, if organisations really want to achieve the goal of producing the software they need in a fashion that leads to High Performance Teams and Sustainable Engineering, they will need to understand the principles of Lean so they can incorporate them into their unique process. This session teaches the basics of Lean, and demonstrates how they apply to Agile development.
“The free lunch was 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 that parallelizing anything but the most trivial piece of code is challenging.
.NET 4 attempts to assist the developer by providing support in the framework to assist parallelizing algorithms through the use of parallel constructs like Parallel.For, 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 meal you will have to deploy a range of tricks for your algorithm to take full advantage of those multiple cores.
If you want your services to be usable by arbitrary clients like browsers and mobile/desktop native apps, you need to model them as “web APIs”.
ASP.NET Web API is the framework from Microsoft to build such services and software systems with .NET. To effectively secure web APIs you need to understand the fundamental application types, HTTP security and a bunch of new technologies like OAuth2 and JSON Web Tokens.
We’ll walk you through typical web API architectures and their security requirements, and explain how you can implement these applications using the .NET stack on the server and any technology on the client.
19th–23rd May 2014