Crafting Code (2 days)

About

This course is designed to help developers write well-crafted code—code that is clean, testable, maintainable, and an expression of the business domain. The course is entirely hands-on, designed to teach developers practical techniques they can immediately apply to real-world projects.

Why attend?

Software Craftsmanship is at the heart of this course. Throughout, you will learn about the Software Craftsmanship attitude to development and how to apply it to your workplace.

Writing Clean Code is difficult. Cleaning existing code, even more so. You should attend if you want to:

• Write clean code that is easy to understand and maintain
• Become more proficient in Test-Driven Development (TDD): using tests to design and build your code base
• Focus your tests and production code according to business requirements using Outside-In TDD (a.k.a. the London School of TDD)

• Understand design principles that lead to clean code
• Avoid over-engineering and large rewrites by incrementally evolving your design using tests

• TDD lifecycle and the Outside-In style of TDD
• Writing unit tests that express intent, not implementation
• Using unit tests as a tool to drive good design
• Expressive code
• Testing and refactoring Legacy Code

• are familiar with at least one Object-Oriented language
• are able to understand Java or C#
• legacy code exercise will be done in one of the following languages: Java, C#, PHP, Scala, or C++
• can write and execute unit tests using a framework (such as JUnit, NUnit, etc.)
• have a basic understanding of mock objects

• bring their own laptops
• have a development environment consisting of: their favourite Object-Oriented language, a unit test framework, a mocking library
• be able to create projects, build source code and run test cases in their development environment

Microservices

This tutorial goes into depth on the business need for speed that leads to microservices and the characteristics of existing microservice architectures. In addition, there will be a hands-on exercise to model your existing architecture, a future state, and the step by step migration to get there.

Audience
The audience is developers, architects, technical leaders, operations engineers, and anybody interested in the design and architecture of services and components. As part of this training, attendees get hands-on in simulating their own microservice architectures, using the open source spigo/simianviz tool.

Prerequisites
While no experience of microservices or SOA is necessary, it would be useful. Moreover, some awareness of cloud architectures, web services, and DevOps practices would also help.

Computer prerequisites
A laptop where you have admin rights to install software and the ability to sync to Github to get the code and contribute changes. We will use the Go language runtime (currently version 1.4.2). Windows, MacOSX, and Linux are supported.

Modern Infrastructure With Terraform & Consul

Terraform is a fantastic tool for provisioning infrastructure, but with such a broad range of responsibilities, it is easy to become overwhelmed with the API, terminology, and workflow. This workshop will cover the basics of Terraform. Beginning with a quick lecture-style introduction to Terraform, we will quickly dive deep into the tool, following the fictitious evolution of a startup as our guide. Not only will this workshop discuss various components of Terraform, but attendees will also understand why and how they might make infrastructure changes with Terraform. Now that our infrastructure is provisioned, how can we connect the various components? With one or two machines, it is easy to point IP addresses, but what happens when we have thousands? We will use Terraform to create a Consul cluster and explore service discovery and health monitoring with Consul. Depending on the time remaining, we will explore the complex problems of secret management using Vault.

Key takeaways:

• Provision and manage infrastructure with Terraform
• Understand the evolution of applications as they relate to scale and operations
• Explore service discovery and service discovery techniques

• Participants should have an active AWS account with permissions to create and manage resources
• Participants should have the latest version of Terraform installed locally
• Participants should have administrator privileges on their laptop or the ability to escalate privilege easily
• Participants should have a modern Internet browser such as Firefox, Chrome, or Safari (not Internet Explorer)
• Participants should have some familiarity with running infrastructure

Java 8 Lambda Expressions & Streams

Java 8 is the largest update to Java in its history. Some of the best ideas from functional programming are migrating their way into Java 8. This intense one day workshop is a hands-on lab session comprising slides, quizzes, live coding and unit test exercises which covers important Java 8 topics.

Why take this tutorial?
Java 8 encourages a different style of programming that: - lets you cope for requirement changes (less engineering efforts!) - lets you take advantages of multi-core architecture easily (faster code!) - lets you process large collections with SQL-like operations (do more in less time!) - lets you write more concise code (better readability & maintainability!)

At the end of the workshop you will be able to use the most important Java 8 features to write easier to read, more flexible code that scales to multicore.

Topics covered include:
Lambdas & Streams

• Behaviour Parameterisation
• What is a lambda?
• Method references
• Collection Processing
• Stream operations and patterns
• Stream Optimisation

• Grouping and partitioning
• Collection Operations
• Arithmetic collectors
• Advanced Queries
• What is Data Parallelism?
• Parallelising your streams
• Decomposition performance

Lean Poker

Lean Poker is this: you and a small group of strangers are going to develop a bot in a language of your choice, that plays poker against other bots. (Don't worry if you don't know poker, we will teach you.) All you need to do is write a function that takes a data structure containing cards and bets your bot sees during the game, and return a single number: the amount you are willing to bet at that point.

Now here is the catch: even before you start coding the bots play a round in a matter of seconds, and if your bot wins you get points. If it comes second, you get less points. Otherwise you get nothing. The next minute another game plays, and another one, and another one… that goes on all day long, while you and your friends are desperately hacking away on the code, and keep deploying, deploying, and deploying. Don’t worry about the deployment pipeline, that’s already set up for you.

During this pretty intense day you will sometimes be cheering for your bot to take over, you will be deploying desperately to change the course of events when your bot keeps losing, but even more importantly you will learn how to create as much value as you can in a short period of time, while you are mostly just having fun.

Please check out leanpoker.org for more information.

Stop Herding, Start Leading

When you lead a software team, everyone benefits from setting firm foundations. You will find that developers on your team work better together with a clear vision and sense of purpose. With a firm foundation, you will be able to strike a balance between innovation and consistency on technical architecture. All this is underpinned by a streamlined approach to daily work, where the team can see progress and improve practical skills on the way.

When you build firm foundations, your team will be able to handle the changes that a fast-paced business throws down. When you have the key to individual developer motivation, conflicts become easier to resolve and you will find team discussion inspires improvement. In order to inspire confidence from others, you need a solid approach, trust springs from your skills so you need to keep them sharp.

In this workshop, you will acquire a new framework that helps set up a team for success maintaining momentum on delivering business value. The skills we will cover can be useful at any point in the life of a project. Come to this workshop if you aspire to lead software teams to deliver great products while finding satisfaction in their craft.

We will cover a range of topics through presentation and practical exercises, you will have the opportunity to try all the techniques explained in the workshop. We will talk about real scenarios that you are likely to face and ways that you can lead your team through them. As you will learn, the secret is to build firm foundations for your technical leadership.

Prerequisites: The only prerequisite for this workshop is some experience working in software development and a desire to lead teams to success. This workshop is suitable for most conference attendees whether they are senior developers, technical managers, and architects.

Friction Lab

Friction. Starts fires. Stops airplanes. Gives traction. Saps energy. A small bit of friction is unavoidable to gain traction and overcome inertia. A large dose of friction slows everything down, annoying customers and eating away at profits. This lab looks at the four most common sources of friction in digital systems and what to do about them:

• Friction in the Journey
• Friction in the Process
• Friction in the Code
• Friction in the Flow

• The main causes of friction in the consumer journey
• How cognitive biases affect our teams as well as our customers
• A reference process for modern digital systems
• How to make and keep reliable promises
• How savvy governments deliver digital services
• Critical attributes of successful large-scale systems
• The best way to keep complex systems stable and reliable
• Why flow efficiency trumps resource efficiency
• Six ways to increase flow efficiency

Code Smells - Developing Design Sense for your Code

\"In order to make delicious food, you must eat delicious food...you need to develop a palate capable of discerning good and bad. Without good taste, you can't make good food.\" - Jiro Ono (World’s Best Sushi Chef)

The same is true for great code. If we want to make great code we need a refined palate for what great code looks like. We need to look at code and develop a sense for it’s properties and smells. Sadly this is rarely ever done. Programmers are expected to just “know” what is good and what is bad with ever getting a chance to develop and curate an aesthetic sense. Worse, code is rarely looked at unless it is causing us problems so we are expected to be gourmets while spending our time eating at McDonalds.

Come work on your sense of code. We will look at many snippets to compare and contrast different aspects of what good code is.

Building highly scalable web apps with Go

During this workshop you will build a web application from scratch using Go to build the backend and some HTML, CSS, JS on the frontend, of course.

You will gets a hands on experience implementing REST APIs with and without any frameworks. We will also use the built-in concurrency features of Go to make the app faster.

We will also add features to the app using some of the services available on App Engine:

• List text here- datastore to store data in a non relational database.
• Memcache to cache and access data faster.
• Task queues to schedule tasks to be executed later.
• Mail to send and receive emails.

Awesome Postmortems

Failure is inevitable. Success is unpredictable. Both failure and success are also tremendous learning opportunities. A postmortem, conducted in an skillful way, is one of the best ways to learn from both failures and successes. Postmortems help us identify and address areas of fragility within systems and organizations, making both more resilient.

In this highly-rated, practical, hands-on session, you’ll learn the theory and, most important, get to practice conducting awesome postmortems, including:

• How to set the context, and go beyond blame
• What data to collect before the postmortem and how to present it in the most useful way
• How to facilitate charged conversations during high-stakes postmortems
• Finding the real root cause of any failure or success (yes, there is such a thing!)
• Learning in complex, adaptive systems
• The new view of “human error”
• How to recognize and mitigate the effects of cognitive biases
• Writing up postmortem results (for internal and external audiences)
• Harnessing prospective hindsight to identify risks and reduce the possibility of future failures

Testing, Faster

After completing the class, participants will be better able to:

• Identify and apply a number of testing techniques and methods.
• Make design choices that promote testability.
• Understand and implement non-functional testing strategies for e.g. performance and resilience testing.
• Make suitable cost benefit trade-offs for testing throughout the application lifecycle.
• Recognise the diminishing return of different testing techniques and avoiding over-testing.
• Apply consistent testing techniques within and across applications.
• Understand and develop the role of test analysts.
• Introduce instrumentation, analytics and telemetry into their development approach.
• Classify testing techniques by various characteristics and describe their respective merits and trade-offs.
• Apply a risk-based approach to recognising missing or inadequate testing.
• Apply feature management techniques like semantic versioning and feature hiding.

• Test Strategy
• Test Design
• BDD
• Designing for Testability

Software, Faster

Formerly Accelerated Agile

Great software professionals build better software faster. Agile methods, continuous delivery and software craftsmanship helped speed up delivery from years to months or even weeks, but then what?

Some teams are able to deliver software at a speed of change like you have never seen before, delivering quality software in days or even hours, again and again. So what is keeping the rest of us from doing so? Now is the time to go from months to minutes, to rethink the way we organize and improve our software development and delivery process.

Software, Faster is for people who believe it can be done. People who feel themselves limited by current Agile, CD and Craftsmanship thinking. People who want to go back to basics and uncover new, simpler ways to deliver great software.

Are you a seasoned agile developer who is frustrated at how slow your “hyper-performing” process feels? Are you suffering with an unwieldy feature backlog, the pantomime of estimation, the card wall where cards go to die, the efforts to automate where it obviously isn’t adding anything? Are you fed up with the artificial commitment of sprints and the unwelcome surprises that still seem to derail your projects?

Software, Faster brings agile principles into the 21st century. You will learn new techniques that both enhance and replace existing agile practices, some of which are counter-intuitive and many which are completely counter to current “agile” doctrine. Using a mixture of discussion, instruction and exploration you will start to think differently about design, architecture, development and testing, operations, automation and team dynamics, as well as working with legacy systems and integrating with third parties.

What you will learn:

• How to challenge the received wisdom of established Agile methods
• How to design and architect for rapid and sustainable delivery
• Why understanding risk and embracing uncertainty are at the heart of faster delivery
• How to manage build, release and operations
• How systems thinking can help you plan effectively and estimate accurately
• How to identify and reduce gaps in your testing strategy
• How to engage with legacy systems and integrating with third parties
• How to manage different levels of skill and experience within a team

Specification by Example

Specification by Example (SBE) is the corner-stone of a successful software quality strategy in agile and lean processes. In this workshop we explore the process patterns that successful teams use to implement SBE, and give you practical experience of how to apply the technique to bridge the communication gap between stakeholders and implementation teams. You will be learning the tips and tricks that successful teams use to build quality into software from the start, as well as collaborative techniques to help design, develop and deliver systems fit for business purpose.

The workshop is aimed at product owners, testers, developers and business analysts. Through a series of facilitated exercises and group discussion, you will learn:

• How to overcome problems of incomplete, unclear or ambiguous requirements
• How to illustrate specifications with concrete examples to create a single source of truth for testing and development
• Tips for how to run specification workshops to maximise collaboration and efficiency
• Identifying the characteristics of good specifications and examples
• How to create a living documentation system to add value to your process long-term

Creative Collaboration: Tools for Teams

Even high functioning teams occasionally have a hard time making decisions or coming up with creative ideas. There are times when the conversation seems to drag on long after a decision is reached. There are times when we have too many people involved in the discussion or the wrong people involved. There are times when we're not sure who's the actual decision maker. And there are those times when we just seem to be out of synch with each other. This creative collaboration workshop provides tools that help resolve all of these issues.

Advanced Docker concepts and container orchestration

You have installed Docker, you know how to run containers, and have written Dockerfiles to build container images for your applications (or parts of your applications). Now comes the next part: connecting multiple containers together and deploying them on a cluster of Docker hosts instead of your single development machine.

This is what we will cover, along with some production-related questions: How to manage logs? Backups? Remote access? Security upgrades?

In this workshop, we will present the networking model of containers and cover how to run containerized applications spanning multiple Docker hosts. We will give recipes to implement cleanly various ops tasks including logging, backups, and more. Finally, we will discuss orchestration and scheduling. We will present solutions like Swarm and Mesos, and see some of them in action on an actual microservices architecture.

Who should attend:
Developers and system administrators who are familiar with basic Docker concepts and want to learn how to deploy Docker for real-world applications.

Take back to work:
You will know how to deploy Docker \"for real,\" and how to perform common operational tasks with containers. You will learn about patterns and best practices to scale applications with Docker and containers.

Topics include:

• Pre-requirements
• VM environment
• Our sample application
• Running the whole app on a single node
• Finding bottlenecks
• Scaling workers on a single node
• Scaling HTTP on a single node
• Connecting to containers on other hosts
• Abstracting connection details
• Backups
• Logs
• Security upgrades
• Network traffic analysis
• Introducing Swarm
• Setting up our Swarm cluster
• Running on Swarm
• Network plumbing on Swarm
• Last words
  
  Additional Materials:
  You won't need to pre-install Docker before the course; each student will be given credentials to connect to an individual virtual machine. All you need is a computer with an SSH client.

High performance organizations

Large organizations often struggle to leverage software to create innovative products. A number of organizational factors conspire to create obstacles to moving fast at scale, including culture, governance, and financial management, and the application of portfolio and program management strategies that do not take advantage of the unique characteristics of software.

What you will learn:
In this training we’ll discuss how to take a lean approach to developing new products and running large scale programs of work, and how to grow a culture that enables organizations to turn software into a competitive advantage.

Audience:

• Executives interested in strategy, leadership, organization culture, and good governance
• Directors of IT, both for applications and for infrastructure and operations
• Anyone working in program or project management, including members of the PMO
• People in finance and accounting or in governance, regulation, and compliance who are involved in delivery.

Dealing with 'self-organisation'

Self-organisation is one of the most misunderstood concepts used in agile practice. If people really understood the dynamics of self-organising systems, they most probably would avoid trying to use it. Instead, they (mis-)apply some ideas, close their eyes, wish real hard, hope that magic happens, and then use the term “unintended consequences” to describe the result.

In spite of this fact, the ideal of the “self-organising team” is fundamental to Agile methods. Agile coaches are constantly challenged with how to motivate / persuade / trick their teams into self-organising and doing things, without telling them what to do, but there is very little information or training on this topic. Allowing a team to self-organise along the lines of \"oh well, they're all adults, they'll figure it out\" is just as irresponsible as reverting to the command-and control school of management. So, how should one go about it?

The goal of this workshop is to provide you with both the answers to that question, and with the tools you need to do the job. In this workshop, we’ll explore what self-organisation actually is and why teams don’t self-organise, and we’ll discuss what self-organisation will do to and for your teams. You’ll then learn practical techniques from social complexity science and social psychology that will help you achieve the benefits of self-organisation without suffering the unintended consequences of it.

Taming microservices with Kubernetes

Materials or downloads needed in advance
Google Compute Engine account, a laptop, working SSH client, and GitHub account.

Description
Linux containers are only part of the puzzle when designing large scale infrastructure for microservices. First you’ll need a host to run your containers, as the OS is still a requirement. Next you’ll need to configure your containers and deploy them in a way that utilizes your resources efficiently. When that’s all done, you’ll need a way for the services running inside your containers to announce and discover each other. Oh and you need to do all of that fast; manual processes don’t work at scale. A tall order no doubt, but Kubernetes has you covered.

After attending this tutorial you’ll know how to:

• Provision a small Kubernetes cluster
• Package your applications as Linux containers
• Manage application configurations with etcd
• Implement service discovery and keep your sanity
• Deploy and manage Linux containers with Kubernetes

Product Discovery Workshop: How To Create Products Customers Love

Who is this for?
This is a session for people responsible for leading products - product owners and product designers, startup co-founders, product managers and product architects.

What will be workshop cover?
This workshop is specifically designed for the leaders of technology-powered product organizations that want to dive deep into the Product Owner role and learn the leading edge practices from Lean Startups, Lean UX, Agile, Customer Development, Product Discovery, and Design Thinking, as well as techniques and practices from the very best technology-enabled product companies in the world. The course is designed to teach you everything you need to know to be a confident and competent product owner/product leader for products that make a difference. It will be an intense day, but my intention is to provide the single best learning opportunity in the world for aspiring product leaders.

Who will be teaching this workshop?
The workshop will be delivered personally by Marty Cagan, the founder of the Silicon Valley Product Group. Before founding the Silicon Valley Product Group to pursue his interests in helping others create successful products through his writing, speaking, investing and advising, Marty was most recently senior vice-president of product and design for eBay, where he was responsible for defining products and services for the company’s global e-commerce trading site. Prior to that Marty was an engineer for 10 years at HP Labs, and the VP Platform and Tools at Netscape Communications. Marty is the author of the book Inspired: How To Create Products Customers Love.

How to build microservices

Microservices Architecture is a concept that aims to decouple a solution by decomposing functionality into discrete services. Microservice architectures can lead to easily changeable, maintainable systems that can be more secure, performant and stable.

In this workshop, you will discover a consistent and reinforcing set of tools and practices rooted in the philosophy of small and simple; this can help you move towards a microservice architecture. Microservices are typically small systems, with single responsibilities, communicating via the web's uniform interface, installed as well-behaved operating system services. However, with these finer-grained systems come new sources of complexity.

What you will learn
During this workshop, you will understand in depth what the benefits are of finer-grained architectures, how to break apart your existing monolithic applications, and the practical concerns of managing these systems. We will discuss how to ensure your systems can be more stable, how to handle security and the additional complexity of monitoring and deployment.

We will cover the following topics:
• Principle-driven evolutionary architecture
• Capability modelling and the “town planning” metaphor
• RESTful Web integration and event-driven systems of systems
• What microservices are (and aren't)
• Integration techniques including cross-microservice use cases like search and reporting
• How to handle interface version changes
• Deployment techniques and supporting technology
• The importance of matching your organisational structure and your architecture
• Continuous Integration and testing of microservices