by Dan North
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.
Accelerated Agile 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?
Accelerated Agile 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
Most web technologies developed in the past had only one purpose: to offer the users a great experience, mimicking the one you normally get from desktop applications. One way of developing those kind of applications that emerged last year is Single Page Application where everything fits in more or less on one single web page. In this workshop we will develop a SPA from scratch using technologies like ASP.NET Web.Api, Breeze.js, Angular.js. The resulting application will be yours to take home and to continue work with it, and learn from it. For best experience I recommend that you bring your own device with Visual Studio 2012+ installed on it, although any text editor(vi included) will do.
by Gojko Adzic
Impact Mapping is a strategic planning technique that prevents organisations from getting lost while building products and delivering projects, by clearly communicating assumptions, helping teams align their activities with overall business objectives and make better roadmap decisions. Impact mapping can help you build products and deliver projects that make an impact, not just ship software.
The participants of this interactive workshop learn about the basics of Impact Mapping, and try it out in practice on several realistic examples to understand the key facilitation techniques and learn how to run and apply Impact Mapping sessions in their organisations.
Key learning points:
* how to create good user stories
* how to ensure that you're building the right product
* how to align the activities of delivery teams and the organisation around them
* how to make an impact with software products and projects
* how to communicate overall goals and vision to delivery teams
* how to facilitate impact mapping sessions
* how to build a delivery roadmap and backlog with impact maps
The workshop is aimed at product owners, business analysts, developers and testers working primarily in an agile or lean environment. It is based on Gojko Adzic's books Impact Mapping, Specification by Example and Bridging the Communication Gap. In order to attend the workshop, you should already have a basic knowledge of iterative delivery methods and a at least some experience of working in a Scrum, XP or Kanban-like delivery. To get the most out of this workshop, you should have a relatively senior role, from a technical or business perspective, in software delivery.
This one-day course, by one of the authors of SonarQube In Action, is the ideal hands-on workshop to learn the core concepts of source code quality and how to eventually adopt continuous inspection in any software development lifecycle, using SonarQube. It is intended to teach developers, testers and software architects how to use this open-source tool to continuously track and improve the quality of their source code.
Here’s a short outline of what we’re going to deal with during this workshop:
* Understanding the importance of Technical debt
* The 7 axes of quality
* Picking a metric to improve
* Implementing with Continuous Inspection & code reviews
by Ricardo Fontes
In an evolving business world, organisations are focused on delivering fast time-to-value while ensuring an exceptional customer experience. Smartphones, tablets, and multiple browsers, coupled with native mobile applications, cloud computing and virtualisation, are amongst the disruptive technologies making it increasingly difficult to manage web and enterprise application performance. These evolving dynamics are creating a new challenge for both enterprises and service providers as their applications are now being delivered across an ecosystem that relies on many supporting business partners. Compuware will discuss the best practises and approaches for application performance delivery from the customer perspective, from the first to last mile.
By taking part this workshop you will:
* Understand why Application Performance is becoming a strategy initiative in leading organizations in the world.
* Understand the paradigm change of the new Application-Centric IT Model.
* Learn how to close the visibility gap, between applications complexity and Control.
* Learn how to fully understand end user experience and gain full control of end user journey within complex infrastructures.
* Learn how to eliminate the guesswork when resolving problems.
* Learn in what way DepOps approach increases application performance.
* Learn how to gain full insight into method performance inside .Net and Java infrastructures.
by Simon Brown
On one hand the software development industry is pushing forward, reinventing the way that we build software, striving for agility and craftsmanship at every turn. On the other though, we're continually forgetting the good of the past and software teams are still failing on an alarmingly regular basis. Software architecture plays a pivotal role in the delivery of successful software yet it’s often neglected. Whether performed by one person or shared amongst the team, the software architecture role exists on even the most agile of teams yet the balance of up front and evolutionary thinking often reflects aspiration rather than reality. By steering away from big up front design and ivory tower architects, many teams now struggle to create a consistent, shared technical vision to work from. This can result in chaos, big balls of mud or software that still fails to meet its goals, despite continuous user involvement.
This talk will explore the importance of software architecture and the consequences of not thinking about it, before introducing some lightweight techniques to bring the essence of software architecture back into an agile environment. We'll look at creating a shared vision within the development team, effectively communicating that vision and managing technical risk. I'll also share the strategies that I've used to introduce these techniques into agile teams, even those that didn't think that they needed them. Expect collaboration, sketching and plenty of gamestorming.
Constraints are relations between objects that we want to hold. This could be that all parts in an electrical circuit simulation obey the laws of physics, that the rows in a Sudoku add up to 9, or that a streamed video play smoothly in the presence of changing CPU or network load.
by Daniel Posch
Your company has servers distributed around the world and you need to process data in a centralised location. The data is produced by applications using different technology stacks and comes from various sources, from web servers to sensors. How could you solve this problem? Enter RabbitMQ.
In this talk we are going to show how to build a system that can ingest data produced at separate geo located areas (think AWS and it's many regions) and replicate it to a central cluster where it can be further processed and analysed.
We will present an example of how to build a system like this one by using RabbitMQ Federation to replicate data across AWS Regions and RabbitMQ support for many protocols to produce/consume data.
To help with scalability we are going to show an interesting way to implement sharded queues with RabbitMQ by using the Consistent Hash Exchange.
If you want to learn what else has RabbitMQ to offer beyond simple messaging and queueing, then this is the talk for you.
Talk objective: Our goal is to show that over the years RabbitMQ has gone way beyond a "simple" AMQP server to be able to have federated brokers, HA queues and support for many protocols and languages.
* Developers interested in building a data ingestion platform that span many locations across the world.
* Developers that have built these kind of solutions already but are interested in learning about alternatives.
* Developers interested in RabbitMQ and Messaging in general.
Science has finally approved it: Forecasting complex projects is a deception. Moreover, forecasts hinder innovations. Daniel Kahneman, Nobel Prize Winner in Economic Sciences and psychologist verified in many cases, that forecasting of complex projects is impossible. Yet still, we keep losing time trying to do exactly that. Beyond Budgeting came empirically to the same findings and offers a concept for controlling corporations without budgets. Additionally Beyond Budgeting provides advice for controlling even long-term complex projects. Agile methodologies generally recommend developing a long-term plan on a coarse-grained level only and coming up with detailed short-term plans iteratively. In this talk I want to provide insights in the latest scientific research and show as well how Beyond Budgeting and Agile principles can be combined so that even complex projects remain controllable.
* Understand why forecasting complex projects is impossible
* Become acquainted with the core ideas of Beyond Budgeting
* Understand how Beyond Budgeting can be applied on Agile projects
by Stas Zvinyatskovsky
In today’s world commit to production latency is measured in minutes. Companies have to implement Continuous Delivery to stay competitive. As we implemented Continuous Delivery at Yahoo, we have tried many approaches. In this talk I will share some of the best practices covering such topics as:
Continuous integration is the practice of merging code from individual working copies with a shared mainline on every commit. It's main aim is to prevent integration problems from many people working on the same codebase and it is now common practices amongst high performing software teams.
Continuous integration maps well to infrastructure practices too, where you generally have only one production infrastructure but many people working on it. But what does unit testing or integration testing mean in the context of infrastructure as code? And do other common software checks like linting, code coverage or static analysis have equivalents for infrastructure pipelines?
This talk will explore what is possible when you treat your infrastructure as code, looking across Infrastructure as a Service, Platform as a Service and container based deployments to identify useful patterns and practices.
Over the last few years the Guardian has built up a set of tools (commercial and in house) that allows developers to build fully integrated continuous delivery pipelines in minutes rather than hours or even days. This reflects a change on the ground where developers have geared up to take on far more operational responsibility whilst operations have taken on a consultancy role to the developers.
At the heart of this has been the creation of an in house deployment tool that streamlines what was previously a set of manual steps (with too many opportunities for humans to type “yes↵”) into a self service web application with an API and easy integration with the build system.
This talk will go through the tools and processes that have been created to make continuous delivery easy and show that:
* By providing tools that let developers deploy whilst keeping operations in the loop we reduce time to deploy, can deploy more frequently and allow operations to spend their time more usefully
* By providing tools that are easy to chain together in different ways, users are able to experiment and try new things
by Jeff Hodges
In the field, distributed systems are the new norm. This talk discusses tactics and strategy for productionizing distributed systems with a little bit about what the future will hold.
by Eric Evans
In this talk we will present a number of common patterns from Erlang systems and how these patterns relates to business needs.
Most of the patterns revolve around the notion of how failure is handled and we will discuss how active treatment of failure leads to better options for the product owner when it comes to prioritising fixes and new features.
By modelling the patterns using OPM (Object-Process Methodology) we get a new way of talking about Erlang systems and architectures, which will make our thoughts and insights easier to share.
For automated tests to provide true return on investment, they must do more than verify that the desired behavior has been achieved; they must also provide a clear and concise human-readable description of that behaviour. Furthermore, they must be reliable and robust in the face of constantly evolving system functionality. Achieving all of these goals requires close attention to the craftsmanship of our test code as well as finding the right vocabulary (and therefore abstraction level) for describing the functionality. Gerard will demonstrate how to apply these ideas to both unit tests and component or even system-level tests using a variety of test automation tools.
by Alissa Pajer
Many concepts from Category Theory appear in functional programming languages, for example the functor, monoid, monad, and natural transformation. Although each of these concepts carries with it a distinct structure, each provides us with a way to unite the similarities in a piece of code, or even across and entire project, while still maintaining the crucial differences. Category Theory gives us the means to abstract over concepts such as types, type constructors, and operations, to name a few. In other words, Category Theory is the programmer's library of abstractions.
Functional languages, by their very nature, often direct the programmer to think abstractly in terms of categories. From a meta perspective, learning Category Theory helps us to become aware of the types of thoughts we have when we program in a functional language, versus say an imperative one. Programming in a different language inherently changes how we approach a problem, given the tools available in that language. By becoming aware of those differences in approach, we can make more informed choices in our programs.
In this talk we will discuss via example how we can understand various functional programs using a categorical approach. Additionally, we will discuss how we can use Category Theory to write cleaner and more maintainable code.
by Jonas Bonér
The demands and expectations for applications have changed dramatically in recent years. Applications today are deployed on a wide range of infrastructure; from mobile devices up to thousands of nodes running in the cloud—all powered by multi-core processors. They need to be rich and collaborative, have a real-time feel with millisecond response time and should never stop running. Additionally, modern applications are a mashup of external services that need to be consumed and composed to provide the features at hand.
We are seeing a new type of applications emerging to address these new challenges—these are being called Reactive Applications. In this talk we will discuss four key traits of Reactive; Event-Driven, Scalable, Resilient and Responsive—how they impact application design, how they interact, their supporting technologies and techniques, how to think when designing and building them—all to make it easier for you and your team to Go Reactive.
by Ashe Dryden
The state of diversity in open source contributions is abysmal. With the number of female OSS contributors at a shockingly low 1.5% and other groups not even documented, we need to ask what we can be doing better as a community. We’ll discuss the barriers that people face contributing to our open source projects and what we can do to increase participation.
In the past year, Facebook for Android has moved from a primarily webview based app to an almost entirely native experience. It has transitioned from being built by a small team to a distributed development model where product teams are responsible for their features. And it has grown to be used by well over a hundred million users a day, distributed across devices with orders of magnitude differences in capabilities.
This talk describes the technical and cultural challenges associated with making these transitions while continuing to ship a fast and lightweight app. We will describe changes we made to each step of the process of committing code, building, testing and releasing our apps to make sure we avoided regressions and measured improvements. We will describe an analytics framework that lets us measure and optimize various performance metrics, and make the costs of features visible to product teams. And we will talk about how we applied these lessons to write a set of core libraries and abstractions that make it easier to distribute development without hurting overall performance of the app. The talk will draw on real examples from a broad set of performance metrics such as startup time, data usage, disk usage, app size, battery consumption etc.
by John Hughes
Even the best test suites can't entirely prevent nasty surprises: race conditions, unexpected interactions, faults in distributed protocols and so on, still slip past them into production. Yet writing even more tests of the same kind quickly runs into diminishing returns. I'll talk about new automated techniques that can dramatically improve your testing, letting you focus on what your code should do, rather than which cases should be tested--with plenty of war stories from the likes of Ericsson, Klarna and Volvo Cars, to show how these new techniques really enable us to nail the hard stuff.
Developing software often requires using a number of tools and languages. In embedded software, for example, it is common to use C and its IDE, Matlab/Simulink, a number of custom XML files, a requirements management tool such as DOORS and possibly a UML tool and a variant management tool. The integration of such a zoo of tools is often a major source of (accidental) complexity in development projects.
Contrast that with the "good old days" when everything was text files and command line executables running on the unix shell. This approach had two important properties: the infrastructure was extremely generic (unix shell, pipes, text editors) and the actual contents were easily extensible and composable (new text file formats/languages and new command line tools); a productive environment for a given project or domain could easily be built from the generic infrastructure plus a few custom extensions.
In this talk I want to propose that creating (domain-specific) development environments based on language workbenches results in many of the same advantages that we all valued in the unix shell-world. A language workbench is an extremely generic infrastructure that is easily extensible with new languages. It is easy to create domain-specific development tools that can address different aspects of the system with suitable abstractions, but are nonetheless very well integrated in terms of syntax, semantics and tooling.
In the talk, I illustrate the approach with examples from two domains. One is mbeddr, an open source environment optimized for embedded software development. A second example is taken from the business/insurance domain.
"Mobile web is dead" - We have seen this sensational title on tech articles and blogs numerous times. And we, web developers have been trying to defend the web for past years without much success.
by Dominic Tarr
by Diego Ongaro
WebRTC changes everything! For the first time, we can do peer-to-peer, or client-to-client, communication in the browser without plugins, extensions, or a software installation. This enables an entirely new class of applications to be built for the web! This talk will look at WebTorrent, a BitTorrent client for the browser that fully-interoperates with the regular BitTorrent network. WebTorrent uses WebRTC Data Channels and special "hybrid clients" to connect to the wider BitTorrent network. By making BitTorrent easier, we're making it accessible to new swathes of users who were previously intimidated, confused, or unwilling to install a program on their computer to participate.
by Wim Godden
Tools like Varnish can improve scalability for static sites, but when user-specific content is needed, a hit to the backend is still needed, causing scalability issues. We'll look at a new Nginx module which implements a fast and scalable solution to this problem, changing the way developers think about designing sites with user-specific content. We'll go into how the module works and we'll put the old and new setups head-to-head to showcase the performance and scalability differences.
With the rise of distributed databases, cluster management tools, consensus servers in our daily use developers needs to face an alien world radically different from previous experiences. While there is a wide collection of solutions to hide the complexity of dealing with the distributed nature of these systems, at the end there is no magic. Under the veil of abstractions exists a world of puzzles and fundamental limitations.
In this presentation I will try to lift the veil to offer a peek at the underlying concepts and demonstrate them through classical examples -- while trying to keep the sanity of the audience.
by John Willis
Around 6 years ago I started working with some tools that focused on software engineering collaboration and automation for operations. At the time products like CFEngine and Puppet were the two main tools promoting this new way of doing operations and sharing within operations and software development. A year later Chef was born and I was fortunate enough to join Opscode as the 9th employee as an evangelist preaching this disruptive form of collaboration and automation. At the time a majority of IT infrastructure was managed by what I called the “Bob’s” of the world. Bob’s scripts, Bob’s directories and Bob to death do us part. Trying to explain to Bob the benefits of collaboration and software engineering principles was a hard fought battle over the years. One of the compelling events that helped propel these ideas (what we now call Devops) was cloud computing. Fast forward to 2013 and these infrastructure automation and collaboration battles still exist but the battles are far less bloody. Now a new war is emerging in the Network operations and engineering space. The same argument for network operations adopting these principles has always been the same as system ops; however, now the new compelling event is the virtualization of the network. Software Defined Networks is a lot of buzz, but the reality is that many network operations and engineering groups are dealing with an influx of highly virtualized tooling like OpenVswitch, Openflow, OpenDaylight and NSX. Configuration tools are starting to get more sophisticated on these virtualized systems doing things like automated VLAN to Port mapping and basic system hardening. Chef and Puppet both have introduced primitives supporting platforms like Arista, Juniper and Cumulus Networks. Help me start the discussion of what Devops and the Network really mean.
23rd–25th April 2014