Building Evolutionary Architectures
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 talk, based on our recent 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 how architectural dimensions interact; we describe how to achieve appropriate coupling between components and services. Incremental change is critical for the mechanics of evolution; we cover how to build engineering and DevOps practices to support continuous change. Uncontrolled evolution leads to undesirable side effects; we 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 talk illustrates how to achieve evolutionary architectures and how to retrofit existing systems to support better evolution.
Presentations
Build & Testing Environments as Code: Because Life's Too Short Not to
Charles Korn
Software Developer
ThoughtWorks
The value of defining our production infrastructure as code is unquestionable, but in 2018 we are still struggling with our local build and testing environments.
All too often, starting a new project is an incredibly painful process of working out which tools we need to install, which versions will happily coexist together, and configuring them to make them behave as we would like.
As the application evolves and changes over time, maintaining and updating this environment across all developer machines and CI agents is difficult enough, let alone thinking about integration and journey testing, where we'd like to quickly and reliably spin up external dependencies like databases and other services in a known state to test against.
Charles will share practical advice on running your builds and tests quickly, consistently, and completely automatically, on your machine, your colleagues' machines and on CI, as well as how to be up and running in just a few minutes without the overhead of virtual machines, thanks to the power of Docker.
'Good Enough' Software
Andrew Harcourt
Principal Consultant
ThoughtWorks
There exists a recent and disturbing trend in the software quality space for people to view themselves as "test automation engineers" or similar, and to focus on creating large automation suites post-hoc. These suites are normally generated verbatim from acceptance criteria and mapped directly to UI-automation tests. The guiding principle appears to be that no bug shall ever reach production. While this goal is noble in theory, it's destructive in practice. Worse, however, it also distracts us from the realisation that software quality is about much more than testing.
In this talk, we'll cover a number of other, often-overlooked elements of software quality such as code design itself, monitoring, logging, instrumentation, SRE, synthetic transactions and production verification tests. We'll look at production error rates and how to assess what an acceptable error rate is, and we'll cover measures such as mean time to detection (MTTD) and mean time to remediation (MTTR) as key metrics for the overall quality of a solution. Critically, we'll then put that into the context of what the system's purpose is and whether that system is Good Enough.
Pets ~> Cattle ~> Steak: A Story of the Commoditisation of Cloud Compute
Fernando Freire
Tech Lead
ThoughtWorks
James Gregory
Tech Lead
ThoughtWorks
They used to be pets, then we turned them into cattle, when all we ever wanted was a good steak.
Developers just want to run code reliably and repeatably. Instead, they spend their time with pet servers or caring for their herd. We’ve relegated hardware to a distant memory, and it is time to do the same for our idea of what a server is.
In this talk, James and Fernando will cover the landscape of cloud computing, and how the evolution from pets to cattle is moving fast towards 'just the steak'. They will contrast between serverless solutions and container orchestration, and the bright future for application developers in the cloud.
This is the age of computing steak, exactly how you like it done. Compute on demand, when you need it, for as long as you need it.
Designers + Developers: So Happy Together
Heather Wydeven
Experience Designer
ThoughtWorks
If you've ever worked on a cross-functional team comprised of designers and developers, you know that integrating the two successfully can be challenging. Heather will share learnings from her own experiences about how designers and developers can flourish together and deliver great software.
Attendees will walk away with an understanding of the following: 1) why cross-functional teams are necessary to build successful digital products; 2) the reasons cross-functional teams fail and the challenges between designers and developers; 3) the characteristics of a healthy cross-functional team; 4) how to create a successfully integrated team of designers and developers by fostering open communication, shared understanding, respect, and trust building; and 5) a better understanding of and appreciation for the differences and strengths each role brings to a team.
Evolving Web Applications Using Micro Frontends
Cam Jackson
Senior Developer
ThoughtWorks
In recent years, we've seen an explosion in the use of microservices to avoid the limitations of backend monoliths, but many organisations continue to struggle with large, monolithic frontend codebases.
In this talk, Cam will explore how to break up a web application into decoupled micro frontends, and how such an architecture can improve delivery quality and efficiency. In particular, he will share real-world examples to explore how this approach makes it easier to upgrade frontend code incrementally, enabling evolution of both the technology stack and the user experience of your applications.
The Building Blocks of Neural Networks
Mat Kelcey
Machine Learning Principal
ThoughtWorks
A key strength of neural networks is their composability which allows them to process different forms of input and output data. In this talk we'll describe the basic building blocks of neural networks and how they handle varying types of data (such as images & text) as well as varying datasets sizes. We'll review how a novel set of problems can be solved with interesting combinations of these pieces.
Mind Control in Javascript
Charlie Gerard
Software Developer
ThoughtWorks
A typical interaction with a device or interface involves touching it. Either you're pressing buttons on a controller, swiping on a touchscreen or clicking on your laptop's trackpad. But what if you could control things without the use of your hands? What if you could use your thoughts instead?
Charlie has evolved this interaction using a brain sensor and developed an open source JavaScript framework to allow users to control interfaces or devices using facial expressions and mental commands.
