SDD 2018 Schedule

The course is designed to take experienced developers who are new to .NET and/or the C# language and give them all the fundamentals, best practices, and advanced knowledge required to be a productive and happy developer with the C# language. We’ll demonstrate all the capabilities and features of the language, and see how to apply it in different contexts. During the day we’ll solve specific, everyday problems in application development using techniques like functional programming and test-driven development.

The Cloud has fundamentally changed the way apps are written and architected, and building great Cloud-based applications starts with a knowledge of the features and services offered by the host Cloud platform. This hands-on workshop introduces software developers to key features, services, and APIs offered by Microsoft Azure. You will learn how to host applications in the Cloud, how to store data in the Cloud, how to deploy containerised workloads, how to create “serverless” applications, and more. You will also work through a series of hands-on labs designed to reinforce the concepts introduced during the day, allowing you to get some practical experience of building Cloud-based applications.

This workshop provides a comfortable learning path to ASP.NET Core that covers all the key topics that a developer needs to know in order to use the framework and build and publish web applications. Although completely new under the covers, ASP.NET Core still looks pretty familiar to many because of the close similarity with the ASP.NET MVC programming model. The workshop focuses on the parts that have been redesigned (runtime, middleware, configuration, DI) and the new peaks of potential performance it enables you to reach. During the course of the day, there will be a balanced mix of architectural descriptions and demos of how to tackle the common elements when building a web application in ASP.NET Core: configuration, authentication, error handling, rendering views, and so on.

Microservices is one of the latest software architecture styles that promises to deliver benefits such as ease of testing, fast and easy deployments, fine­-grained scalability, architectural modularity, and overall agility. It is undeniably one of the latest trends in the software industry, and everyone seems to be jumping on the bandwagon to quickly embrace and adopt this new architectural style. Unfortunately, as many companies are painfully experiencing, Microservices is a complex architectural approach that isn’t appropriate for all applications and environments. In this highly pragmatic product and platform agnostic workshop, you will gain a full understanding of the Microservices architecture style and what hybrids and alternatives exist, which will help guide you in making the right architecture and design decisions for your organisation. You’ll learn the core concepts of the Microservices approach, the primary benefits and drawbacks, and how it differs from service­-oriented architecture. We’ll also cover hybrid approaches such as the popular service­-based architecture. We will then take a deeper dive into some of the design considerations with Microservices, including techniques in service identification and design, service communication, distributed transactions, distributed logging, data domains, Microservices reporting, and remote access error handling techniques.

Building the future today means adding intelligence to your apps. In the modern world that means taking advantage of the cloud and the huge power it brings to bear. In this workshop, Brian will show you how to put a UI on artificial intelligence by teaching you how to build multi-channel bots using the Microsoft Bot Framework and Cognitive Services. Bots built with the Microsoft Bot Framework can easily be integrated with multiple channels like a web site, Skype, Slack, Facebook, and even Cortana. By optionally adding Cognitive Services to your apps, you can add powerful algorithms to see, hear, speak, understand, and interpret our needs using natural methods of communication, with just a few lines of code. You’ll learn about the various services and how you use the smarts behind them to make your apps even better. In particular, the Language Understanding Intelligent Service, LUIS, lets you add conversational intelligence to give your bot a natural flow. All of this can be built on top of ASP.NET, or Node.js if you’re so inclined. We’ll focus on ASP.NET and C# in the workshop. In addition, like all apps, you’ll want to wrap your app in a solid DevOps practice, so you’ll see how you can host your code in Visual Studio Team Services, have full traceability with work item tracking, use Team Build for quality with unit tests, and use the Release Management tools to control updates to your bot via a full CI/CI pipeline. By the end of the day you’ll have all the code and notes to add intelligence to your solutions.

For the beginner architect, there are many options for doing pretty much anything. But for the master architect, there are only a few. In this dense workshop Juval Lowy will explain his approach to system analysis and design, using volatility to decompose a system into its comprising services. Juval will contrast it with the most common mistake made in software architecture – using functionality to identify services. These are universal design principles, and Juval will use examples from software and non-software systems alike. You will also see how to overcome the real hurdles that architects face when pursuing volatility-based decomposing, simple and practical techniques for identifying areas of volatility, common tell-tale signs or “smells” when your design is still functional when using the Method, IDesign’s approach for system architecture. You will learn how to literally mechanise software system design, and how to do it quickly and effectively. Juval will also discuss logical tiers, security, interoperability, scalability, transactions, and other aspects of a modern application. The workshop concludes with discussion of how modern architecture fits into development processes such as Agile, and how to design the development process for maximum productivity.

There’s an assumption that just because people throw buzzwords like “TDD” and “software craft” around, everyone knows what’s involved and how to do them well. As with most assumptions, this often isn’t the case. This hands-on session offers an opportunity to get comfortable with test-driven development, good unit tests, pair programming, software craft, and deliberate practice – and also to ask questions and have some fun. Bring a laptop! We’ll be using C#, but don’t worry if your coding skills are not as sharp as the language – rocket-surgery C# is not required, and we’ll be levelling the playing field and learning through pairing. And no need to install Visual Studio or Mono: we’ll be using the online cyber-dojo environment.

The job software architect places in the top ten of most annual surveys of best jobs, yet no clear path exists from developer to architect. Why aren’t there more books and training materials to fill this demand? First, software architecture is a massive multi-disciplinary subject, covering many roles and responsibilities, making it difficult to teach because so much context is required for the interesting subjects. Second, it’s a fast-moving discipline, where entire suites of best practices become obsolete overnight. This workshop provides a foundation to build upon to start the journey towards software architect status. We’ll focus on the many elements required to make the transition from developer to architect, covering process topics like the impact of Continuous Delivery on architecture, technical subjects like application, integration, and enterprise architecture, architectural patterns, and soft skills. The workshop also covers: understanding requirements, architecture anti-patterns, translating requirements into architecture, evolutionary architectures, refactoring techniques, and establishing architectural boundaries. To fully leverage knowledge, you need application. The workshop uses hands-on exercises and architectural katas to apply learnings from the workshop. While we can’t make you a software architect overnight, we can start you on the journey with a detailed map and a good compass.

Asynchronous programming is being pushed further into the mainstream with the introduction of the C# async and await keywords. It is therefore becoming more and more important that when we write libraries for our own application stack, we pay attention to which functionality should be async in nature. During this intensive workshop we will do a deep dive into how these new features work, and into the mechanics of how best to deliver asynchronous functionality into your applications. We’ll focus 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. The two speakers co-authored the Apress book Pro Asynchronous Programming with .NET.

The data revolution that is currently taking place is just as profound as the PC revolution that transformed the way we work more than 30 years ago. Skilling up on data science should be priority #1 for software developers, because developers are uniquely positioned to take advantage of the latest advancements in AI and machine learning. Learn why data science is the oil that will lubricate tomorrow’s technology, and see numerous code samples demonstrating how to build intelligent apps and why those apps will change the world.

You are effective with the imperative, object-oriented core of Java or .NET but you look longingly at the winsome smile of functional languages. If you play with your language’s functional features, you’re never quite sure if you’re getting it right or taking full advantage of them. This talk is for you. You’ll learn which code to attack with functional ideas and how to do it. You’ll look at code similar to what you write every day, and see it transform from long, difficult-to-follow code to short code that’s easy to understand, hard to mess up, and straightforward to debug. Better yet, functional approaches help you apply patterns in a clear and consistent way. Apply these techniques while leveraging delegates, lambda expressions, base classes and generics.

Open your mind to the wonderful world of Object Oriented design patterns. Every OO developer should carry this virtual toolbox around in their head. In this talk you will perhaps discover new patterns, or re-discover existing techniques and learn the pattern vocabulary associated with it so you can effectively communicate with other developers. This will be a fast action talk, with a lot of code, and an immersive deep dive into the world of design patterns.

Microsoft .NET Core lets us quickly spin up services, websites, and create applications that run on a variety of platforms. In this session, we’ll see how to create a self-hosted service and then consume that service in a simple application. We’ll use Visual Studio Code and the command-line interface (CLI) to do all of this on macOS, and we’ll also see the exact same projects run on Windows.

Three ground-breaking shifts are occurring in the world of JavaScript: package management, starter kits, and reusable components. These innovations are fuelling a revolution in the way we write JavaScript code. We’ll explore how your team can make the shift to join the reusable revolution.

If you want to build scalable and resilient applications and services in the Cloud, you need a range of knowledge from distributed systems theory to an in-depth understanding of platform features from a Cloud provider. In this session, we’ll cover the concepts of load balancing and partitioning, and also look at infrastructure and platform solutions for achieving the performance and availability goals of a Cloud system.

Seems like everyone’s talking about DevOps these days. But is it just another marketing term? A way to sell tools? An extension of Agile development? Well… yes, it’s all of those things, but also none of them. Brian will take you on a short journey that provides a unique look at the IT management philosophy that’s uniting Development and Operations, and changing the way we think about application quality, delivery, and lifecycle. Learn what DevOps actually means, and what you and your organisation will need to change if you’re going to embrace the approach. Learn about the advantages, the potential pitfalls, and the definite stress points that are all wrapped up in the DevOps world.

The software industry is in a deep crisis. Projects suffer from low quality; schedule slips and cost over-runs are common. But this is hardly ordained, since there are plenty of examples of projects done on schedule, on budget, on quality in a repeatable manner. The key for solving the crisis is to practice software development as an engineering discipline, just like it is done in mechanical or electrical engineering. That is exactly the responsibility of the modern software architect, who must address software systems from an engineering standpoint, applying age-old engineering practices to software development. Armed with that crucial observation, Juval will share his perspective on the key set of skills required of the architect, the role architects need to play for the project to succeed, what it implies both to companies and to individual architects, and how architects should navigate and manage their own career path and personal growth.

The progress of programming languages, systems and frameworks has been to push ever higher, away from machine-level concerns of memory models, bitwise representation, binary formats and assumptions specific to hardware and operating system platforms. On the whole this is a good thing. But sometimes you need to touch the metal, or at least know what it feels like. This talk will take a tour of some of the representational concerns that are still a concern in many high-level languages and demystify some of what goes on behind the scenes, as well as explore a few tips and tricks for working with modern C.

C# 8 is still far from finalised, but many of the ideas are publicly available. In this session we’ll see where the language may be headed, and how everyone can experiment with the latest builds as well as contributing their feedback to the team.

Ask programmers what comes to mind when you say “concurrency”, and most of them are likely to say “threads”. Ask what comes to mind when you say “threads”, and most are likely to say “locks” or “synchronisation”. These assumptions are so deeply held that they define and constrain how programmers are taught and think about concurrency: thread safety is almost synonymous with the avoidance of race conditions and the guarded protection of mutable state. But this is only one quadrant of four possibilities, a quadrant diagram partitioned by mutable–immutable along one axis and shared–unshared along another. Whether Java, C# or C++, many mainstream languages support programmers in all four quadrants, not just the synchronisation quadrant. From immutability to actors, this talk will take a look at patterns and practices that encourage thinking and coding outside the locked box.

Microsoft is moving to an open source and cross-platform world, and they’ve created .NET Standard as a super-highway to get you there. With the .NET Standard 2.0 release, the specification includes most of the APIs you depend on in the .NET full framework (.NET 4.n). Because .NET Standard, .NET Core, Xamarin and UWP are all embracing this standard, your class libraries can be easily cross-platform. In this talk, you’ll learn more about the goals of .NET Standard and how it differs from PCLs (Portable Class Libraries). You’ll also see how to use the .NET Portability Analyzer to find any changes your app needs. To show that .NET Standard is not actual magic, you’ll learn a little about how redirects support binary compatibility. And finally, you’ll learn what happens when an API just doesn’t make sense on a particular platform, alongside some other potential pitfalls. You’ll leave this talk understanding why you should care about .NET Standard and the path to move your applications to it.

Porting an existing application to ASP.NET Core just because it is a cool new web framework isn't a good enough reason to do so, even if you're a true fan of the Microsoft web stack. ASP.NET Core is optimised for building highly scalable web applications, running on a variety of server platforms, but it still requires some non-trivial adaptation work. This session will try to help you make a decision about which version of the .NET Framework to target, and will discuss the tools available to measure the level of compatibility between your current code and .NET Core/.NET Standard. The session will also outline a few adoption strategies for brownfield and greenfield development scenarios, and even for a sort of yellow-field midway when your application needs a re-write but you want to re-use as much code as possible. Finally, we'll examine the problem of the missing frameworks not available on .NET Core.

Microservices (small, self-contained modules, often remote, to which an application delegates work) solve many common problems, from multi-threading to demand-based scaling. They also provide an almost ideal architecture not only for web-based applications, but also for all systems developed using Agile principles. Though a Microservice architecture is often associated with distributed applications, this is approach is equally suitable for use with systems that will never see a network, and they are very robust in the face of change. However, you don’t make Microservices by breaking up a monolith into little chunks and dubbing them “services”. You need to program them in completely different ways than you might be used to. Building a service is not a simple matter of putting an HTTP-based REST interface in front of a chunk of code. The service interface needs to be carefully crafted, and the service itself must be lightweight, decentralised, secure, fault tolerant, transactional, and vendor and language neutral. This session shows you how to build a service that does all that. You’ll learn what a Microservice is, how it has to be structured, and how it communicates with other services and the outside world. You’ll also learn about service architectures and how they do (and don’t) integrate with various technologies such as Docker.

One of the expectations of any software architect is to analyse the current technology environment and recommend solutions for improvement. This is otherwise known as continually assessing architecture vitality. Too many times software architects fail to regularly perform this task, leading to emergency refactoring efforts to save a troubled system from failure. The question is, what does it mean to assess an application architecture? In this session we will explore both macro and micro techniques for analysis, including static analysis metrics and tools, and techniques for detecting structural decay, regardless of your platform (e.g. Java or .NET)

If your dev team has taken a wrong turn somewhere – trying to meet wacky requirements, always 90% done on that huge project, shipping without testing – there are things you can do today to help, regardless of what your experience level or job title is. You don’t need an MBA, a Scrum certificate, or “CTO” on your business card to take action; your engineering training has given you all the problem-solving skills you need. I’ll share tech-friendly techniques like “TDD for People”, “Joint Design”, and “Coherence Busting” that you can apply immediately, and illustrate with examples from a fintech start-up who used them to go from the doldrums to dynamic in three months.

Azure Machine Learning Studio enables developers to build sophisticated machine-learning models, deploy them to the Cloud, and leverage them to build highly intelligent apps. Real-time fraud detection? Image analysis that identifies faulty parts coming off an assembly line? All of this and much more is possible with Azure Machine Learning Studio. See for yourself how it works and how to leverage it to build super-intelligent apps.

When developing multi-threaded .NET applications that share state, we need to consider thread safety when sharing state across multiple threads. These techniques require the developer to understand the possible race conditions and select the cheapest synchronisation technique to satisfy thread safety. But, while essential, they can often become tedious and make the simplest of algorithms seemingly overly complicated and hard to maintain. In this session, we’ll explore the use of built-in concurrent data structures shipped with TPL that will simplify multi-threaded code while maximising concurrency and efficiency.

It has been said that immutability changes everything. But what does that mean in practice? What does it mean for existing code that looks more like the mutant apocalypse than an elegant application of mathematical thinking? Immutability can be an ideal that is hard to reach. Refactoring, on the other hand, is all about the art of the possible. In this talk we’ll be clarifying motivation and exploring some approaches to help reducing state mutability in code.

In this introduction to ASP.NET Core, you’ll learn everything you need to work with the new ASP.NET framework and build your first application. We’ll look at how to work with the new project system, how to install and configure middleware components, how to work with controllers and Razor views to build HTML pages, and how to work with controllers to build HTTP-based APIs. Along the way we’ll learn about all the new features of ASP.NET Core, including how to leverage dependency injection and new features for Razor views, Razor pages, and model binding.

This session shares the unique approach we utilise at Cox Automotive to scale our JavaScript development practices. We use custom npm packages to create a highly opinionated development environment that contains reusable components with generated documentation, reusable themes, and an opinionated starter kit that includes a robust, centralised development and build process.

Back in the early days of service-oriented architecture, everyone got excited about creating enterprise services such as customer, issuer, policy, account, you name it. It was truly an exciting time, and services were all the hype. Sound familiar? It should, because today that same hype exists, only now it’s called Microservices. Unfortunately, back in the day we forgot one important aspect – the data. The same is true in today’s world. We get all excited about services, and we tend to forget about the underlying data until it is way too late. In this session we’ll take a hard look at the data issues surrounding Microservices. You’ll learn how data plays a key role in identifying services, how to partition data and locate domain seams, and how to migrate data from a monolithic database to distributed databases and schemas. As Jorge Santayana said, “Those who cannot remember the past are condemned to repeat it.” Come to this session so that you don’t repeat the same mistakes we made 12 years ago with respect to data and services.

Over many years, the software development industry has carved out a massive core body of knowledge of software architecture and design patterns. And yet, fundamentally, our industry is not better off because of it, as it falls behind trying to cope quickly with ever-changing requirements and increased complexity, coupled with dwindling budgets and outsourcing constraints. A dissonance exists between the ivory tower theoretical world of best practices, and the grim reality in the trenches. In this visionary session, Juval Lowy will articulate the root causes of the problem, and propose contemporary solutions comprising of tools, processes, and a new profession, literally a missing piece in the puzzle he calls the business architect. Finally, Juval will predicate the impact and infliction adopting his approach will have on the livelihood and prosperity of every software architect and developer.

Test-Driven Development (TDD) gives us a ton of advantages. It helps us think in small pieces. It helps us build provable code. And it helps reduce the amount of unneeded code that creeps into our applications. You’ve seen the simple examples of TDD such as building FizzBuzz or Conway’s Game of Life. Those are great for getting started, but the real world is more complicated. We have to break down complex problems into workable solutions. We have to deal with services, libraries, and dependencies. And we have to deal with strange bugs that crop up. In this session, we’ll go beyond the simple examples and see how we can use TDD effectively with real-world code. Along the way, we’ll learn how to break down complexity, isolate dependencies with mocking, and capture expected exceptions.

This class shows you how to develop an effective and coherent architecture incrementally. Modern development practices rarely use large up-front design phases any more, and even if you do, you’ll find problems with that design as you implement. Developing a coherent architecture can be challenging in that environment. The solution is to build around a domain-focused metaphor that allows for incremental changes while maintaining coherence throughout. This class will present a complete process for designing incrementally in this way, starting with user stories and ending up with code.

Most developers use LINQ on a daily basis, but do you really understand how it works? In this session we will re-implement LINQ to Objects from the ground up. We’ll show how the underlying mechanics of LINQ work, and expose the many gotchas that developers encounter when using LINQ. Having established how LINQ to Objects works we will then move on to understanding how LINQ works with non-object stores such as relational databases. Again, with a solid knowledge of how LINQ works with these kinds of stores we can eliminate much of the head scratching that occurs when things go wrong.

Working with people. API design. Diagnostics. Versioning. Dates and times (and time zones). Language features. Testing. These are all areas I can ramble about for hours… but what are the most important messages? I’ll distil my experience (good and bad) into the bare essentials, and pick out common threads and themes. This session will be opinion/experience based. I’m not claiming truth or authority, simply my current state of mind. If you disagree with some or all of it, that’s great! Think about what you’d say instead, and the process will enrich you, as well as anyone you communicate it to.

Improve the architecture, design, and code inside your ASP.NET Core applications with an opinionated approach to ASP.NET Core. In this talk, we’ll look at strategies for organising projects, solutions, files and folders. We’ll also look at data access alternatives, see some tips for writing unit and integration tests, and think differently about the MVC design pattern.

React is a UI library that allows you to build slick and responsive web applications, especially Single Page Applications. By introducing a new declarative language, JSX, and a new ‘virtual DOM’ technology, it takes a different approach to other UI frameworks. Together, they make the UI much quicker to render. This session will take you through the process of building and unit testing React components, and composing them together into a well-structured and predictable web application.

Continuous delivery and continuous deployment are in vogue. They are being hailed as a revolutionary way to build software faster. But converting to CD is not without its risks, and it requires some new ways to think about what development is. It’s not merely moving from six-monthly releases to six-weekly – when you’re releasing thirty times a day, the nature of development itself is different. Over the years, Jules has been involved in some very high-frequency continuous delivery developments. In this talk, he’ll discuss some of them – what worked and what didn’t; what you gain from CD, and what you’ll have to give up in order to make it work.

The software development industry has made huge leaps in recent years; with Agile, Lean, software craftsmanship, evolutionary design and Microservices being just a few of the buzzwords we throw around. Despite this, software development teams are often more chaotic than they are self-organising, with the resulting code being more of a mess than was perhaps anticipated. Successful software projects aren’t just about good code though, and sometimes you need to step away from the IDE for a few moments to see the bigger picture. This session is about that bigger picture and is aimed at software developers who want to learn more about software architecture, technical leadership and the balance with agility. This talk will debunk some of the common myths as we look at five things every developer should know about software architecture; a guide to software architecture on modern software projects that’s pragmatic rather than academic, and lightweight rather than “enterprisey”.

End-to-end tests are usually brittle, slow, and hard to work with, but unit and integration tests often inspire a false sense of confidence. This tension between industry best practice (test automation pyramid) and business demand for high confidence results in testing the same functionality multiple times, with a negative effect on costs and speed of feedback.

To write unit and integration tests we need test doubles (fakes, stubs, mocks etc.) to simulate a component’s dependencies. Contract testing is a technique that gives us confidence that our test doubles accurately simulate the dependencies that they replace.

Contract testing has been known about for a long time, but the extra investment in creating and maintaining (yet another) suite of tests has restricted their uptake. With the growth of microservices, there is an urgent need for a renaissance in contract testing, with a specific focus on consumer driven contracts. This has led to the creation of the PACT open source tool, which is designed to facilitate the adoption of contract testing for HTTP based microservices.

In this session, we’ll examine the motivation for contract testing, look at how you can incorporate contract testing in your development practices, and explore how PACT can help streamline contract testing for HTTP based services (including REST & microservices).

Azure Cognitive Services is a set of 30 cloud-based APIs and services that help developers build smarter apps. With them, you can generate search metadata from images and videos, identify and recognise faces, identify emotions in photos, authenticate users via voice, analyse sentiment in text streams, translate speech from one language to another in real time, build sophisticated image-classification models backed by neural networks, and much more. In this fast-moving session, Jeff surveys the Cognitive Services APIs and presents working examples of their use. The source code for the demos will be shared via GitHub.

There’s a lot of confusion about async/await, Task/TPL, and asynchronous and parallel programming in general. So, let’s start with the basics and look at how we can consume asynchronous methods using Task and then see how the “await” operator can makes things easier for us. Along the way, we’ll look at continuations, cancellation, and exception handling.

It’s just a detail. Have you ever said that or been told that? Whether it’s about implementation or requirements, we often use the word detail to suggest that something is not important enough to worry about. There are so many things to worry about in software development that we need to prioritise – too much detail, not enough focus. The problem is that in software, the details matter because that is what software is: lots of details brought together in combination. If we don’t focus on the details, we get debt, defects and delays.

We live in a global economy, and the internet allows you to reach customers everywhere around the globe! Creating a multilingual website with ASP.NET Core will allow your site to reach a wider audience. ASP.NET Core provides services and middleware for targeting an international audience of different languages and cultures. Internationalisation involves globalisation and localisation. Globalisation adds support for input, display, and output of a defined set of language scripts that relate to specific geographic areas. In this session, you’ll learn the key facets of how to build global-reaching software with ASP.NET Core.

Ever had to build a UI when the API doesn’t exist yet? Annoyed by slow or unreliable APIs? The solution is surprisingly simple: create a realistic mock API. By weaving together a few powerful open source projects, we can simulate a real API with create, read, update and delete. No DB required!

It seemed like an easy feature to implement – a checkout page to place an order. But this payment gateway has a simple API, so we added that. And this email service provider makes it possible to send an email with one line of code! Finally, we can notify downstream systems via a message queue. The code looks simple – six little lines of distributed systems code. But those lines hid a dark secret that we only found after launching. Customers complained they didn’t get their email. The back-end system wasn’t getting updated from our messages. And by far the worst of all, customers complained that they saw an error page but still got charged! Clearly it wasn’t as easy as calling a few APIs and shipping – we actually need to worry about those other systems. In this session, we’ll look at taking our six lines of distributed systems fail, examining the inevitable failures that arise, and possible mitigating scenarios. We’ll also look at the coupling our code contains, and the ways we can address it. Finally, we’ll refactor towards a truly resilient checkout process that embraces, instead of ignoring, the fallacies of distributed computing.

Microservice architectures are popular, described as “SOA done correctly”. But what are the real differences between ESB-flavoured Service Oriented, Service Based, and Microservice architectural styles? And what about the middle ground between the shared everything of SOA versus shared nothing of Microservices? This talk explores the similarities and differences between various service-oriented architectural styles. I describe the characteristics of SOA, Microservices, and hybrid service-based architectures, along with decision criteria to help choose between them. I also discuss specific engineering practices, orchestration styles, reuse strategies, and migrating between architectural styles (e.g., from monolithic applications to service-based or Microservices). No one architecture can solve every problem, and many projects take on more complexity than necessary by choosing the wrong architectural pattern. This talk equips attendees with the knowledge and context to choose the architecture that best fits their needs.

The Agile Manifesto starts with “we are uncovering better ways of developing software”, not “we have uncovered”. Agile is a fluid and evolving thing, and two of the most exciting practices that we’ve uncovered in the past few years are Mob Programming and #NoEstimates.

With Mob Programming, “the whole team [literally] works on the same thing, at the same time, in the same space, at the same computer”. Mobbing is a startlingly effective way to work, with teams typically accomplishing way more than they do working separately. Mobbing leverages group intelligence and extreme collaboration, to accomplish amazing things. Once you’ve done it, there’s no going back.

#NoEstimates is a new way to plan. Rather than guessing (and all estimates, especially story points, are guesses), you use continuous value-based projections and hard measurments. It’s a proven technique, much more effective and much less time consuming than traditional or story-point estimation (which is, after all, based on waterfall thinking), and much more valuable to the business.

This session looks at both of these practices. You’ll learn what mob programming is, how to be successful at it; at how to create the conditions where mobbing is possible. You’ll learn how to plan without traditional estimation in a way that’s both more effective and more useful to the business than the traditional approach.

One of the great things about being a programmer is that you never stop learning. Even after having programmed for almost 35 years, I still try to improve how I write my code. Recently the way I write code changed once again when I started to apply monads, and especially the Try class. During a recent project, my team created a small library that ports the behaviour of the Scala Try monad. Although at first this new monad didn’t appeal to me, I soon really started to appreciate this style of programming, where we concatenate series of Map() and FlatMap() methods, using lambdas, and avoiding abundant try-catch blocks, and many “if” statements and null checks. In the meantime, I have contaminated many programmers with this style. Developers make it a sport to always start every method with a return statement. During this talk I’ll demonstrate the power of this simple monad, using many code examples (in Java, C# and TypeScript). Don’t hesitate to join in!

Do you spend most of your day working in Visual Studio? Do you feel that you know all there is to know about it? This session is all about unlocking the hidden features in order to boost your productivity and help you code more efficiently. Visual Studio 2017 comes packed with new functionality, but this is about old and new alike, and you’ll be surprised how many features you don’t use but you should. Join me in this session as I walk you through Visual Studio 2017 and unravel feature after feature to help you become a Visual Studio Jedi master.

There’s no such thing as a write-once application. The world is constantly changing, and our code needs to change with it. To keep code readable and maintainable, we’ll use techniques such as intentional naming and method trees. Think about the next developer to maintain the code. Now, imagine he’s a homicidal maniac who knows where you live.

The most relevant piece of code that was still missing in ASP.NET Core 2.0 was SignalR. Now it’s back, and with the same common patterns and the same usual range of uses that only creativity can limit. You can use SignalR not just for chats but also to make the user interface much more interactive, sharing updates with selected groups of users. For example, SignalR makes it possible to add social features a la Facebook to applications, and to refresh the user interface in a very quick way both performance-wise and coding-wise. This talk offers a 90-minute walk-through of the new SignalR framework for ASP.NET Core.

Agile is maturing in delivering incremental change. We innovate through data-driven experiments, enabled through continuous delivery and evolutionary architectures. Delivering small and fast means we are more frequently introducing new vulnerabilities. We are also facing new threats that come from increased integration through cloud computing and the internet of things. Traditional cycles of penetration tests and code reviews are not keeping up with the accelerated delivery pace unless these processes are also automated. DevSecOps focuses on integrating security in our processes and teams. Automate security first and fail fast will help build security in, but will also support the growth of awareness in the teams. Kim will show the lessons learned from her journey to continuous security at ANVA, securing their open SaaS cloud platform for insurance software. Get an overview of the current continuous security landscape and the practical insights and pitfalls. And learn how security can be fun.

In this session you will learn about various patterns for communication between services in a Microservices ecosystem. First, we’ll take a look at inter-services communication and some of the issues associated with it, and how to resolve those issues, while at the same time creating micro-level scalability within your Microservices. We’ll then look at three other common communication issues associated with aggregation requests, orchestration requests, and integration of third-party and custom applications, and how to address those communication issues without expensive and intrusive ESBs, integration hubs, and API gateways.

This is not a rant. Nor will you be chastised by the Agile manifesto. Instead, we’ll look at how Agile approaches have actually been adopted in the real world, why these are often problematic, and what you can do to improve them. Throughout this session, we’ll anchor our discussion by reference to the pragmatic underpinnings of Lean and Agile approaches (notably XP, Scrum, and Kanban).

Design by Coding (DbC) is a way to develop an architecture incrementally as you code. It builds on Test- and Behaviour-Driven-Development techniques, but adds a focus on the ‘story’ that’s central to all Agile processes. The process answers the question of how you can build a coherent Agile system incrementally, without a formal up-front design process. DbC provides a way to both design and develop systems that model the story very closely, resulting in a system that can handle volatility with ease. Since your code is effectively your design artefact, it also eliminates the need for a separate design phase in the development process. We’ll do a live demo of the process in class.

DevOps is hot, but all too often the database is the missing link. How do you manage the necessary changes need to support your applications? How do you track these changes and follow a change from development to test to production? You need an effective database lifecycle management plan. In this session, you’ll learn where the SQL Server database fits in to DevOps, and how you can use tools to extend your infrastructure to make the database a first-class citizen, just like your source code. You’ll see how to track changes with version control, create update packages, and with complete automation, deploy to multiple environments like development, test, UAT, and production, and basically bring things under control with Database Lifecycle Management. To do all this, you’ll learn the process as well as see examples using the Visual Studio SQL Server Database Tools, Team Foundation Server Team Build, Release Management, as well as custom tools from Redgate.

TPL Dataflow is a downloadable addition to the Task Parallel Library (TPL) that ships with the .NET framework. It provides an alternative approach to defining concurrency. Instead of just simply throwing threads at a synchronously structured program and having to deal with all the thread safety and race conditions that are introduced as a result, we have the concept of many autonomous objects each with its own thread of execution. These autonomous objects cooperate with other such objects through asynchronous message passing. In this talk we will see how TPL Dataflow can greatly reduce the complexity normally associated with asynchronous programming.

You don’t need any prior knowledge of TPL Dataflow, and there will be plenty of code.

The world is changing fast. More precisely, the world is changing at increasing speed. This means things that were not possible five years ago come into reach. Incumbent organisations need to adapt fast to keep up with new competitors that use emerging technologies earlier and more effectively than they do. As a result, every aspect of software changes towards smaller. Smaller teams, less management, flatter organisations, shorter cycles, and smaller components. During this energising and fast-paced talk, Sander discusses the Cynefin model, shows why software development goes so terribly wrong, how to move beyond Scrum and enterprise Agile, why self-organisation is not as easy as it looks like, why continuous delivery leads to not doing projects or estimates anymore and why Microservices are hard, but essential as an underlying foundation.

The Open Web Application Security Project (OWASP) curates a list of the top ten security risks for web applications and how to mitigate them. The ever-changing world of web development created a challenge for the 2017 list, which needs to combine both existing approaches and modern trends in web development. We will have a look at each item in the list, see what can go wrong, and make sure that this won’t happen in our web sites.

TypeScript is a typed superset of JavaScript that compiles to JavaScript. It’s a free, cross-platform, cross-browser, open source language that enables developers to build large-scale enterprise applications with JavaScript. TypeScript is built so that developers can easily learn the language, and so that tools can easily work with it as well. If you’re writing mission-critical or large-scale web apps, and need JavaScript, then TypeScript can work for you. In this session, you’ll learn the basics of organising and writing a web app using TypeScript and Visual Studio code, so you can get started building large web apps today.

There’s a huge amount of buzz around the use of Docker containers, and this session aims to demystify how they can be used to enhance your day-to-day development even – if you’re not ready to adopt them in the Cloud.

All applications have configuration parameters. Most of the time these configuration parameters are stored in external configuration files, or worse, hard-coded in the source code. This has been the norm for too long. Imagine applications being able to automatically adjust their configuration parameters real-time if a value changes, or even better, creating the ability for applications to automatically (without human intervention) study and learn about their environment and self-adjust their configuration to adapt to changes in their environment or conditions. Sounds futuristic? It’s not. In this session you will learn about the patterns for self-configuring systems that you can deploy today, regardless of the platform you are using.

Modern software development exhibits a curious trend: Yesterday’s Best Practice Becomes Tomorrow’s Anti-pattern. EJB and SOA were once best practices, but are now shunned as anti-patterns. Why? This session investigates why this trend continues, including increased tech stack complexity, primordial abstraction ooze, code reuse abuse, strangling dependency management, and the fundamental dynamic equilibrium of the software development ecosystem. I also investigate How to Avoid Yesterday’s Best Practice from Becoming Tomorrow’s Anti-pattern, including domain-centric architectures, immutable infrastructure, evolutionary architecture, incremental architectural change, and how to favour evolvability over predictability. Also includes figurative and literal dumpster fires.

An interface needs to be much more than a collection of isolated interactions. In order for people to be able to use something easily – and well – our minds need to perceive that smaller interactions are related to each other, and that they work together to complete a larger task. If users are not able to perceive this, the disconnect leaves a great deal of room for confusion. People get stuck, or enter the wrong information. Tasks take twice as long as they should, or users abandon the screen altogether. These scenarios have significant consequences for the organisations that create these products. Far too many developers tell me they’re unsure where to start in evaluating UX issues; they’re hoping to get off the starting block with some common, universal things that are easy to spot (and quick to fix). That’s not only possible, it’s necessary. The first pass at improving an existing product should be running down a checklist of things that you can spot easily – provided you know what you’re looking for. In this crash-course style session, I’ll show you what to look for across 9 specific types of product attributes: Content, Labelling, Presentation, Navigation, Interaction, Feedback, Visual Hierarchy, Forms, Accessibility. Whether you’re developing a new product, starting a comprehensive redesign or just looking to improve product quality your organisation, these tried-and-tested rules will help you work smarter. And what’s more, you’ll have a method for building a solid body of UX and UI design knowledge that you and your team can leverage time and time again.

Although Git has rapidly become almost a de-facto standard in recent years, it can be intimidating or confusing for those transitioning from other systems or those new to using source control. Learn how to use Git effectively, navigate your way around a repository and how to work as part of a team. This session will take you from your first commit to rebasing like the professional you are.

For too long we’ve lived under the tyranny of n-tier architectures. Building systems with complicated abstractions, needless indirection and more mocks in our tests than a comedy special. But there is a better way – thinking in terms of architectures of vertical slices instead of horizontal layers. Once we embrace slices over layers, we open ourselves to a new, simpler architecture, changing how we build, organise and deploy systems.

You’ve expended plenty of time and effort to build software, and because you want it to be high quality, you must verify that it works correctly. You might be tired of manually testing code, which is an error-prone process in itself. Have you ever asked yourself if there must be an easier way? Would you like to learn how to unit test all facets of an ASP.NET Core Web Application? In this session, you’ll learn everything you need to know about how to properly test ASP.NET Core MVC applications with xUnit (though much of the content will also apply to other testing frameworks). We’ll review how to install and configure xUnit, getting started testing in ASP.NET Core, writing unit tests, and what makes a good test. Additionally, we’ll discuss unit testing strategies to apply to the entire app. You’ll learn how to test the entire server-side part of your application with xUnit.

Every web developer should know about typical attacks such as SQL Injection, Cross-Site Request Forgery, or Cross-Site Scripting. And even though those risks still exist, the bad guys are always working on finding new twists to old attacks, or new kinds of vulnerabilities on a web site. In this session, we will show and discuss several of those new vectors, including attacks against Angular applications, Clickjacking, abusing external links, XSS via file uploads, and a few more. Technology never stops evolving, so it’s crucial to stay on top of the latest developments.

Microservice swarming is a technique for Microservices to scale and balance load directly, with no need for centralised discovery or other heavyweight single points of failure in the system. A Swarm architecture is a server-side architecture based on small, independent Microservices that use a set of simple rules to automatically scale based on actual load. The services are highly decoupled, there is no need for a single-point-of-failure discovery service or external load balancing, the systems are extremely robust, adaptive, and maintainable. This session looks in depth at the architecture of a Swarming system, focusing in implementation. We’ll cover lightweight messaging, Microservice structure, and look in depth at how the system scales and adapts to actual use as it runs.

Making the right decisions for a mobile project can be a very involved process of trial and error before you find a good fit. Wouldn’t it be nice if you had a map? In this session we will compare frameworks and approaches based on the kind of mobile project you are doing, and walk through what the actual code looks like to accomplish basic tasks for each one. We will cover native, hybrid and mobile web approaches for enterprise-level solutions.

For the beginner software architect, there are many options for doing pretty much anything. But for the master architect, there are only a few. In this dense session Juval Löwy will explain his approach to system analysis and design, using volatility to decompose a system into its comprising services. He’ll contrast it with the most common mistake made in software architecture: using functionality to identify services. These are universal design principles, and Juval will use examples from software and non-software systems alike. You will also see how to overcome the real hurdles that software architects face when pursuing volatility-based decomposing, simple and practical techniques for identifying areas of volatility, common tell-tale signs or "smells" when your design is still functional when using the Method, IDesign's approach for system architecture.

GDPR (General Data Protection Regulation) is a new regulation from the EU that strengthens data protection for all citizens of the European Union. The regulation comes into effect on 25th May and impacts any company that in whatever form stores and manages data about individuals. Any developers working on software that – regardless of the legal residence of the customer and software house – deals with user data (as a controller or as a processor) is potentially affected by GDPR. GDPR enforces a strict data protection compliance regime that includes the right for the user to be erased from a system, on-demand export of personal data, as well as continuous application of best security practices to fend off data breaches and data leaks. It may seem mostly a subject for lawyers and management to deal with but, in the end, it also boils down to how software is written. In this session, we’ll first consider concrete actions to take as far as encryption and databases are concerned (unfortunately, even a GDPR-compliant Cloud platform won’t be enough, though immensely helpful). Next, we’ll try to identify a few scenarios (monolithic apps using data for their own use only, Microservices sharing data, SaaS) and detail a to-do list for each. Finally, we’ll look into more invasive practices to build GDPR-compliant systems from the ground up. In this regard, we’ll talk about designing a threat model to have security right in the architecture.

The garbage collector has been part of .NET since its inception. However, exactly how the GC works is often shrouded in mystery. Also, the fact that memory management is automated doesn’t free the developer from caring about memory issues – it’s just that those memory issues appear in a different guise. In this session we take the lid of the GC, look at how it works and is optimised, and then assess what this means for you when you are writing your code: things you do that can help the GC and things that cause it problems.

Abstraction is awesome. And abstraction is awful. Too little, and our applications are difficult to extend and maintain. Too much, and our applications are difficult to extend and maintain. Finding the balance is the key to success. The first step is to identify your natural tendency as an under-abstractor or an over-abstractor. Once we know that, we can work on real-world techniques (including DRY, SOC, KISS and YAGNI) to dial in the level of abstraction that is “just right” for our applications.

ASP.NET Core 2 features a “from the ground up” re-designed authentication system that finally gets rid of many legacy problems and feels “ready” for modern security scenarios. In addition, there are many small and big security features in ASP.NET Core that are worth knowing about, like the new authorisation system, data protection, and hosting.

This class provides an integrated look at the architecture of an entire “vertical slice” of a contemporary (active front end, Microservice back end) web-application stack, from the UI at the top to the database at the bottom, and all of the interior plumbing (messaging, caching, etc.) in the middle. We’ll discuss various trade-offs and alternatives (several UI architectures are available, for example), as well as specific technologies which you can use to implement various components, and you’ll see how all the pieces work together. The focus is on good structure throughout.

Microservices have been around for a few years, and many organisations are starting to benefit from these autonomous, independently deployable and easy maintainable small blocks of code. However, if you examine some of the popular definitions of Microservices, we are still building a single application as a suite of small services. During this talk Sander will explain and demonstrate how front-end development can also benefit from building in small, autonomous, independently deployable blocks of code, instead of implementing a single monolithic web application. He’ll use many code examples in Java, Angular and Typescript (and probably some live coding) to illustrate even better how to build micro-applications similar to your Microservices.

“Those who cannot remember the past are condemned to repeat it” (George Santayana). “The past is never dead. It’s not even past” (William Faulkner). Most developers pursue the latest and greatest with intense fervour, yet the history of engineering, including software projects, contains rich lessons that we risk repeating ad nauseam. This session recounts a variety of stories of projects that failed… and why. Ranging from the Vasa in 1628 to Knight Capital in 2012, each story tells of a mistaken interpretation of a fundamental architectural principle and the consequences – some good, some less so. I also look at the common threads for these stories, which resonate with problems many companies have but don’t realise. Examples: Pets.com, San Francisco project, the Vasa, F16, Sagrada Familia, Tacoma Narrows Bridge, null, Ada, Serialization, Knight Capital, Ariane 5, Webvan, Chandler project.

In 1968, CACM published a letter from Edsger Dijkstra, called “The GOTO Statement considered harmful”. In it, he explained why most bugs in a program were caused by GoTos, and he appealed for GoTo to be expunged from programming languages. But GoTo has a twin bother, which is responsible for nearly every bug that appears in programs today. In this session, Jules will revisit Dijkstra’s original explanations, and show why If and GoTo have the same pathology. He will then go on to explain how to avoid this pathology altogether.

All those Azure demos look great – get up and running in seconds, never leaving the comfort of your IDE! But real life is more complicated. We have a mix of VMs, databases, websites, and of course someone is playing around with Microservices and App Fabric. Deploying from Visual Studio was easy at first, but now carpal tunnel is setting in. There are better ways! In this session, we’ll take a complex Azure deployment and introduce automated builds, packaging, deployments, an entire continuous delivery pipeline. We’ll also look at Azure Resource Manager, converting our topology to infrastructure-as-code, providing even greater insight and control over our deployments. Finally, we’ll look at more exotic deployment scenarios such as blue-green deployments and feature flags for a first-class deployment experience.

Session details to be confirmed.

If we look ahead to 2048, what will the world be like? How will we run our personal lives and businesses? Here’s a software fiction story. Back in 2008 a guy created Bitcoin. To run Bitcoin, a general ledger was necessary – Blockchain. Blockchain is a public ledger for transactions – potentially, any type of transaction. Now stop and try to imagine taking this a stage or two further. Blockchain will rock the world as we know it to its foundations. Banks, notaries, public authorities, institutions – any 3rd party trust authority – could feasibly be on the brink of disaster. Or on the brink of a new and exciting world. As a disruptive technology, Blockchain could potentially be as significant as the emergence of eCommerce – a dazzling new world evolving before our eyes. It’s impossible to know exactly how it will develop and what its impact will be, but time flies and applications and frameworks are coming out such as the Microsoft Coco Framework. This session aims to provide an introduction to Blockchain, so that you can start making sense of how it might change your business. Unchain your heart. Let it set you free.

If you’ve ever wanted to build a highly responsive app that leverages a real-time communications library, then this session is for you! Real-time web functionality is the ability to have the server push messaging aggressively to the client, rather than relying on the client to make multiple and frequent requests. Both SignalR and WebSockets are sets of libraries available in ASP.NET that you can use to build scalable real-time websites and apps. You can use them in both enterprise and consumer apps, and across platforms. This session covers what you need to know to build a SignalR app that connects multiple clients instantaneously.

Using our Gloucester History Festival companion app as a case study, Emma and Chris from Rock Solid Knowledge explain how we used a Content Management System to generate data for both the events website, and our supporting cross-platform companion app. We will explain the power of a solid API specification and the advantages of data modelling in advance, using the Umbraco CMS to demonstrate. We’ll then cover how we built our C# Web API, and how the cross-platform Xamarin Forms app utilises this data. You’ll learn how a combination of device data and CMS data was used to generate distance and time calculations, and other ways a headless CMS can be used.

Azure Functions and LogicApps are the backbone of Microsoft’s Serverless Framework. Azure Functions introduce an event-driven, compute-on-demand experience that provides a radical new approach to how you set up and run tasks, create APIs and Microservices. Where they truly shine is in the great interoperability they provide with lots of Azure services, SaaS products, and on-premises systems. Join Christos and learn how you can create and run scalable performant APIs and Microservices using Azure Functions, your favourite language, and open-source tools like Visual Studio Code or the Azure CLI. The new kid on the block is all about disrupting the traditional model for developers and enterprises, and this session will show you why.

Most organisations find it hard to prioritise and repay their technical debt. The main reason is the scale of modern systems, with millions of lines of code and multiple development teams, where no-one has a holistic overview. But what if we could mine the collective intelligence of all contributing programmers, and start to make decisions based on data from how the organisation actually works with the code? Adam offers a combination of software evolution and psychology that lets you prioritise the parts of your system that benefit the most from improvements, detect organisational issues, and make practical decisions guided by data. He’ll illustrate each point with a case study from a real-world codebase. This new perspective on software development will change how you work with legacy systems.

The Actor Model is the latest fad to storm the software industry. But is there any substance behind it and why should you care? What are the drivers of the Actor Model and why have the large Cloud vendors started offering Actor-based solutions? Juval puts it all together first by outlining the long-term trend in software methodologies that brought this 50-years old computational model to the fore, and how the demise of Moore’s Law coupled with the rise of the IoT will force us to abandon sequential programming. He’ll examine the origin of the Actor Model, demonstrate Actors using conceptual examples, outline emerging design patterns, point out common misconceptions, and conclude with his views on the future of the Actor Model.

Why choose? Support them all! This code-centric talk demonstrates the approach you need to centralise your app logic and handle multiple voice interface ecosystems at once. We will walk through code examples for Alexa and Google Assistant integration, discovering the pros and cons of each in detail.

What is Dependency Injection? And why would we want to use it? That’s what we’re here to answer. We’ll start by looking at the problems caused by tight coupling. Then we’ll use some DI patterns such as constructor injection and property injection to break that tight coupling. We’ll see how loosely-coupled applications are easier to extend and test. With a better understanding of the basic patterns, we’ll remove the magic behind DI containers so that we can use the tools appropriately in our code.

In the 1950s Fortran released a great innovation into the world of software development: procedures. Suddenly, we could write programs that were orders of magnitude larger and more accurate than before. Then again, in the 1980s, Smalltalk and C++ introduced us to objects, and development took another great leap forwards. Now, at the start of the 21st century, another great leap forward is taking shape, and almost every language is adopting closures. Closures really do introduce a whole new way of thinking about what programming is, and how to organise our code. In this talk, Jules will describe their beginning in Algol and functional languages, show how they work in modern languages, and demonstrate a few patterns and idioms that demonstrate their extraordinary power.

After you solve the authentication and identity problem, you inevitably need to think about authorisation. This is where things become a bit more complicated. Roles, permissions, resources, rules etc. are all different ways to model authorisation – and you typically end up building something very application-specific (and then have to do the same again for the next application). We sat down and brainstormed different ways to make that process easier and provide a common solution to authorisation. This talk is about patterns, anti-patterns and what we ultimately came up with.

The makers of all relevant search engines have long stated that website performance impacts search ranking. Therefore, a lot of work is done on the server to make the page load faster. However especially with modern Single-Page Applications (SPAs), front-end performance is equally important. This session shows you techniques to measure front-end performance, both statically and with real user management (RUM). Then we will discuss ways to improve perceived and real performance to create a web application that works smoothly. In the end, users should be as happy as search engines.

With so many developers and organisations embracing containerisation, it’s important to have the right support from your infrastructure. Microsoft Azure has a growing number of options and services to choose from, when it comes to deploying and running containers on the Cloud – from having full control over the orchestration of your containers with Azure Container Service and Kubernetes, to a fully managed container service with Azure Web Apps. Knowing your options can help you avoid unnecessary costs and complexity. Join Christos for a quick demo-driven tour around these services and find out how Azure can help you run your applications and containers on the Cloud.

Agile development claims to abhor “Big Design Up Front” – yet what is that giant backlog building session but BDUF in other clothing? Back in the olden days of software development, we were forced to speculate on what users wanted, and then build it. We were basically running a buffet. But what if we could switch to à la carte? With modern engineering practices like Continuous Delivery, we can shift our perspective and start building by hypothesis rather than speculation. This talk shows the full spectrum of software development, from ideation through execution and deployment, through the lens of modern software engineering practices. I discuss building a platform using feature toggles, canary releases, A/B testing, and other modern DevOps tools to allow you to run experiments to see what your users really want. By building a platform for experimentation, product development shifts from up-front guessing to market-driven. This talk unifies the practices of modern architecture, DevOps, and Continuous Delivery to provide a new approach to feature development. I’ll also demonstrate how to undertake major architectural restructuring with zero regression failures by relying on data and the scientific method.

“We value working software over comprehensive documentation” is what the manifesto for Agile software development says, with the typical misinterpretation of these few words being “don’t write documentation”. Of course, that’s not what the manifesto says and “no documentation” certainly wasn’t the intention. It seems that many software teams have lost the ability to communicate what it is that they are building, and it’s no surprise that these same teams often seem to lack technical leadership, direction and consistency. Join us for a journey, as we navigate through maps, travel guides and source code to visualise, document and explore our software.

Enterprise design and development teams know all too well the challenges of working in an environment where the urgent trumps the important. Speed and task completion are easily mistaken for value and success. Whether you’re a programmer or product owner, you’re doubtless under tremendous pressure to deliver meaningful improvement – without spending the time or money you know it really takes to do that. You’re likely staring down a seemingly impossible requirements list and coding workload – and now you’re saddled with the responsibility of designing a better user experience, too. From UI design to information architecture and interaction design, you and your team are essentially expected to work miracles. Never mind that you may have no training in these areas, or that some of these skills are in direct opposition to what you do best. For far too many product teams, this is familiar territory. We’re all living in a world where burnout factor is high, tempers are short, and the question of how to truly improve product quality and user experience often seems rhetorical. But it doesn’t have to be that way. I think there’s an answer, and it’s successfully put into practice every day – at start-ups. From front-end developers to mid-tier programmers to database architects and UI designers, I’ve seen teams rise far above what anyone thought was possible within the constraints of time, budget, and personnel. They were able to make quantum leaps in product improvement simply by changing the way they thought about their work. By redefining what it means to design. By adopting and applying practices and principles that are an inherent part of start-up life. I’ve done it and they did it, which means you can do it, too. Let’s dive into what it means to design like a start-up, along with the mechanics of adapting these principles over the course of an enterprise project.

Modern application design has changed quite a bit in recent years. “Mobile-first” and “Cloud-ready” are the types of applications you are expected to develop. To keep pace with these developments, Microsoft has revamped their complete web stack with ASP.NET Core to meet these architectural demands. Needless to say, you also have to secure these apps. This one-day workshop is a whirlwind tour through the authentication, authorisation and data protection system of ASP.NET Core 2. You will learn how to authenticate users and machines, how to secure APIs, and how to connect various front-ends to these secured APIs.

User stories have become almost universal, but they’re often misunderstood and problematic. In this workshop you’ll get a chance to work on a realistic domain, shepherding a user story from discovery, through implementation, delivery, and support. We’ll cover user story lifecycles, estimation and decomposition, forecasting, Agile requirements, traceability and documentation. As might be expected, we’ll talk about quality practices, such as TDD, BDD, and exploratory testing. You’ll leave with concrete, actionable insights that will allow you to help your organisation use user stories more effectively throughout the software development lifecycle.

This day will take you through the process of building an application form scratch. You will create angular components services directives and more using TypeScript. You will see how to data bind components to pages, and understand how to compose components together to have them communicate with each other. We also show how to create directives. You will create services that can be injected into Components and have those services interact with HTTP REST servers and get data to display in the component. You will understand how to set up routes in Angular, how to create nested routes, how routing allows modules to be lazily loaded, and how to use the router from code. You will also wee how to set up ‘guards’ around routes. Finally, we’ll cover testing, looking at Jasmine and Karma and seeing how these can be used along with the Angular APIs to test Angular applications

You’re an intermediate to advanced C# programmer excited about attending a conference filled with cutting-edge talks from amazing speakers. It’s important to stay up to date, but you keep thinking of your existing code assets and how much time you spend on that code. Sometimes you feel that by the time you finish a new application, the code is already out of date.

This workshop aims to build your capacity as a keeper of code – caring for and evolving existing code assets. First, you’ll take a step back to learn how to assess your assets and whether it will be easy or hard to evolve them. You’ll consider long-range planning to maintain the value of your code assets – especially where to apply gradual change to reduce disruption and minimise risk. A step-wise process offers benefit at every point along the way.

You need to keep code safe, and that means tests to ensure your code continues to work as expected. You’ll gain insight and learn techniques for creating tests for existing code assets and improving the effectiveness and the ease of maintaining your tests.

You need to keep code predictable. You’ll learn the most common pitfalls in .NET types that can affect accuracy and performance.

You need to keep code understandable. That means shrinking it, organising it and clarifying intent. You’ll learn techniques to minimise boring redundant code so that special case, interesting and error-prone code stands out. These techniques will include generic hierarchies and higher-order functions. You’ll also get better at refactoring and isolating technology dependent code.

You need to prepare code for the future. The .NET Standard is the declaration of a set of APIs that current and future frameworks will implement, and you’ll learn how to evaluate your code’s compatibility with .NET Standard. This compatibility also lets you move parts of your app to other platforms and operating systems. Your code will be ready for Xamarin, UWP, and .NET Core and to run on Windows, Linux and macOS.

You’ll see an application evolve from a mess to a well-structured application ready to support additional platforms. Moving your application isn’t just about code, so you’ll also get tips for inspiring your co-workers and building management buy-in. During this workshop, you’ll learn a lot about code and you’ll also understand how to apply these ideas to the ongoing evolution of your most important code assets. You’ll leave ready to take the right sized steps for each set of code assets.

More and more, we need to design systems incrementally as the system evolves rather than in one giant up-front phase, and our designs must still be coherent and able to easily stand up to the stress of changing requirements. We have to design effectively while we’re building. These facts are particularly true in the microservice and Agile worlds.

Design by Coding (DbC) is a way to design incrementally literally while you’re coding, and doing that in such a way that you get an optimal design and architecture, with solid APIs and well organized services and subsystems. DbC is an evolutionary approach based on TDD and BDD techniques mixed with Domain-based architecture, and is particularly effective in a collaborative environment.

This workshop takes you through the entire process. Starting with user stories and domain analysis, we’ll create a system metaphor to ensure architectural coherence, identify key abstractions and bounded contexts, and then construct a system incrementally, coding and designing in parallel. The result is a coherent and highly maintainable system and architecture that can easily accommodate changing requirements.

This workshop involves a minimum of lecture and a lot of doing. We’ll construct a system incrementally using code-focused techniques based on TDD principles and merciless refactoring. We’ll also use (and you’ll learn about) mob programming and other contemporary Agile practices that will greatly improve both your effectiveness as a programmer and the quality of your code.

An evolutionary architecture supports incremental, guided change across multiple dimensions. For many years, software architecture was described as the “parts that are hard to change later”. But then Microservices showed that if architects build evolvability into the architecture, change becomes easier. This workshop, based on my upcoming book, investigates the family of software architectures that support evolutionary change, along with how to build evolvable systems. Understanding how to evolve architecture requires understanding of how different parts of the system interact; I describe how to achieve appropriate coupling between components and services. Incremental change is critical for the mechanics of evolution; I cover how to build engineering and DevOps practices to support continuous change. Uncontrolled evolution leads to undesirable side effects; I cover how fitness functions build protective, testable scaffolding around critical parts to guide the architecture as it evolves. The software development ecosystem exists in a state of dynamic equilibrium, where any new tool, framework, or technique leads to disruption and the establishment of a new equilibrium. Predictability is impossible when the foundation architects plan against changes constantly in unexpected ways. Instead, prefer evolvability over predictability. This hands-on workshop provides a high-level overview of a different way to think about software architecture. Topics that will be covered include: architecture dimensions, engineering incremental change, architectural characteristics, identifying components, identifying architectural patterns, identifying fitness functions, retrofitting existing architectures, and building evolvable architectures.

Most organisations find it hard to prioritise and repay their technical debt. The main reason is the scale of modern systems with million lines of code and multiple development teams, where no-one has a holistic overview. So, what if we could mine the collective intelligence of all contributing programmers and start to make decisions based on data from how the organisation actually works with the code? In this workshop you’ll learn novel analysis techniques based on data from the most underused informational source that we have in our industry: our version-control system. You get to analyse version-control data to:

• Identify the code that’s most expensive to maintain amongst millions lines of code
• Detect architectural decay and learn to control it
• Analyse different architectures such as layers and Microservices
• Measure how multiple developers influence code quality and what you can do about it

During the workshop you’ll get access to CodeScene – a project analysis tool that automates the analyses – which we use for the practical exercises, and we also discuss open source alternatives where suitable. Participants are encouraged to take this opportunity to analyse their own codebase and get specific take-away information around their system. Workshop style: hands-on, bring your own laptop. The practical exercises use Git and CodeScene. Preparations will be sent out in advance.

Architects always strive for modularity to achieve extensibility, maintainability and reuse. The technology for the modules, these Microservices, changes over time, and yet the very use of smaller blocks introduces inherent complexity. When you design a highly modular system, it would be naive of you to expect that the only things you will do differently will be limited to design and technology. The development process itself needs to be modular, accommodating the complexity of the Microservices as a system. In this intense workshop, Juval will share his original techniques, metrics and ideas, all practiced in real life, allowing for a Microservices-oriented development process. He will present a battle-hardened approach that you can immediately apply to achieve robust applications, manage requirements, and ensure faster time to market. You will also see how the various team members – the architect, the project manager and the developers – should work in concert, and their respective tasks and responsibilities towards the system and the Microservices.