Tuesday & Wednesday — Workshop Day 1 & 2



Advanced BDD/TDD Masterclass (2 days)

WITH John Smart
TDD BDD Craftsmanship Clean coding
WHEN:
Tuesday+Wednesday 9:00 - 17:00
WHERE:
TBD

Experience the full BDD lifecycle with the author of BDD in Action!

Good BDD, TDD and Software Craftsmanship practices can reduce defects by 90% or more, promote better design, make the code easier to understand and to modify, and cheaper to maintain, and above all focus work on the features that really matter. But this skills are notoriously hard to master without help. This hands-on workshop will immerse students in a realistic project, using pair programming and BDD/TDD practices to implement a number of business features. Students will learn how to:

  • Capture requirements in the form of executable specifications
  • Use automated acceptance tests to focus work on the features that matter
  • Write unit tests in the form of executable specifications that help design and implement your software
  • Refine and evolve your software design using TDD and refactoring
  • Apply OO Design and SOLID principles to write clean, maintainable code
  • Write highly readable, highly maintainable code that is a fluent expression of the business domain
  • Write unit tests that can act as living technical documentation

Lab exercises use Java 8, Cucumber-JVM, Serenity, Spock and JUnit.


Tuesday — Workshop Day 1



Deep Dive Into Scala and Akka

Scala Akka Microservices Distributed Systems
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

Akka is a toolkit and runtime for building highly concurrent, distributed, and resilient message-driven applications on the JVM that follows Reactive Manifesto.

I’m going to give a short introduction to Scala programming language and follow with the fundamentals of Actor-based programming and Akka framework. We’ll finish with more advanced topics like Akka HTTP, Akka Clustering, Akka Persistence and Akka Streams.

Topics include

  • Scala basics
  • Functional programming in Scala
  • Scala Futures
  • Actor-based programming: theory, common patterns
  • Actors in Akka
  • Supervision
  • Solving practical problem with Actors and Akka
  • Akka HTTP
  • Akka Clustering: sharding and singleton
  • Akka Persistence with Cassandra
  • Akka Streams
  • Testing in Akka

Prerequisites & Requirements

No experience with Scala, Akka or Actor-based systems is necessary. Please make sure you have the latest Java 8, Scala and SBT (Scala build tool) installed.



Advanced Domain-Driven Design Workshop

WITH Nick Tune
Domain driven design Software architecture Business Strategic design Organisational alignment
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

During this workshop you will learn the most important, and misunderstood, parts of Domain-Driven Design - domain discovery and strategic design - through hands on facilitation patterns and design exercises, including the business model canvas and domain-driven architectural design.

After completing this workshop you will have a rich set of knowledge and tools for continually collaborating with business experts, understanding what is important to them, and constantly optimising the software systems you create around their needs.

Target Audience

These skills learned in this workshop are of tremendous value to any technical lead or software developer who aspires to positions of leadership and influence. But they are also highly practical to those who work with software developers, including: testers, BAs, product owners, scrum masters, project managers etc.

Introduction to Domain-Driven Design
  • Not just programming patterns
  • Discovering the domain
  • Strategic Design: Aligning Solution With Problem
Domain Discovery Exercises
  • Discovering the Business Model: Business Model Canvas
  • Discovering the Problem Domain: Subdomain Mapping
Strategic Design Exercises
  • Organisational & Alignment: Context Mapping
  • Domain-Driven Architectural Design: Diagramming



Docker Security Workshop

Docker Microservices Security
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

This course will explain how to secure a modern, microservice-based system. Attendees will start by running and hacking into a vulnerable system, before switching roles and using various Docker tools and features to protect the system. While the tutorial focuses on Docker, the patterns and information can help secure any production container system.

Topics covered will include

  • Creating and running a simple container-based service
  • Switching roles to attack and compromise the service
  • Looking at how to respond to an attack
  • Investigating various ways to improve the security of the system, including scanning images for vulnerabilities and limiting the privileges of running containers

Key takeaways
Understand the different ways in which a container can be compromised
Understand the various methods that can be employed to protect containers

Prerequisites
A WiFi-enabled laptop with access to SSH (You'll be provided with a login to a cloud VM and need to be able to SSH into this machine. It's not possible to follow along on a local instance due to the need to download large images.)



Building Great Teams: Culture and Core Protocols

Great teams Culture
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

Your team can be ten times better

What does that mean? That means your professional team can accomplish 10x more work, do it with 10x more quality, 10x faster, or with 10x less resources. Your family can be 10x happier. Your school can be 10x more effective at helping people learn. Your community group can be 10x better at making life better for the people it serves. Even you yourself can be 10x more effective at getting what you want.

In other words, you can be great. Your team can be great.

Greatness

Can you say these things about your teams?
  • My projects are completed effortlessly on schedule and in budget every time.
  • Every team I’ve ever been on has shared a vision.
  • In meetings, we only ever do what will get results.
  • No one blames “management," or anyone else, if they don’t get what they want.
  • Everybody shares their best ideas right away.
  • Ideas are immediately unanimously approved, improved, or rejected by the team.
  • Action on approved ideas begins immediately.
  • Conflict is always resolved swiftly and productively.
The Core Protocols are one way to make teams that have these characteristics.

Some of the things you’ll learn:
  • Results-oriented behaviors,
  • How to enter a state of shared vision with a team and stay there
  • How to create trust on a team
  • How to stay rational and healthy
  • How to make team decisions effectively, and
  • How to move quickly and with high quality towards the team’s goals



Making Agile Valuable

Agile Scrum Teamwork Retrospective Kanban Agility
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

Learn how to apply the agile mindset, principles and practices to increase the value delivered by your people, teams, and organization.

Agile looks simple, but becoming really agile can be hard. Many organizations that started with agile are not getting the expected business benefits. They don't know how to effectively apply agile practices in their specific situation.

In this workshop you will learn how to tailor and apply agile practices to serve your needs. You will practice how to effectively do daily stand-ups, use Scrum and Kanban boards, perform product reviews/demos and run agile retrospectives.

This workshop is intended for:

  • Technical (team) leaders and Scrum masters
  • (Senior) Developers and Tester
  • Product Owners and Project/Line Managers
  • Agile and Lean Coaches
  • Anybody involved in agile transformations

The practices in this workshop will help you to develop the right products for your business and customers, reduce delivery time, increase quality of your software products, and create happy high performing teams.

What will you get out of this workshop
  • Assure that agile teams stay focused and actually deliver
  • Deal with impediments or other things that impact daily work and performance
  • Adopt to internal or external changes and stay effective
  • Tips and tricks to increase agility and deliver more value



Presentation Aikido

Presentation skills Effective communication Visual design of slides Confidence on stage Designing a presentation
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

The best, most effective presentations capture the audience quickly, hold their interest effortlessly, educate and entertain them in equal measure, and sometimes even inspire them. This class explores simple and effective techniques for achieving those goals in any kind of presentation.

The first half of the course focuses on preparation, content selection, delivery techniques, and handling questions (or the lack thereof). The second half of the course is an in-depth tutorial on improving the "look and feel" of presentation materials--especially Powerpoint/Impress presentations. In particular, it demonstrates practical techniques for making your slides not suck.

The optional final day is a workshop, where each attendee has the opportunity to give a short presentation they have previously created, after which we work through it together to improve its design and delivery.

Who should attend?
Anyone who is required to present technical information in front of an audience.



Hypermedia Hacking with Mike Amundsen

Javascript Hypermedia REST API NodeJS
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

The Problem
With the explosion of data available on the Web, there has also been a marked increase in the number of "Web APIs" developers must deal with in order to access the data. These Web APIs almost always require consumers to write custom code in order to access the data. Some even invent their own authentication and authorization schemes that require additional development effort before the data is available for end users. The result is that every new set of data requires a new set of code; in effect, a custom client for each data set.

This is not how the Web was envisioned.

The Solution
Instead of publishing limited implementations that only support reading and writing raw data in simple formats such as XML and JSON, this workshop shows how you can craft rich payloads that include not just data, but also the application controls appropriate for the content; including the ability to search, sort, filter, and update data on the server. This hypermedia approach allows publishers to focus on returning the proper data and application controls to the client in each response and allows client applications to focus on understanding the hypermedia controls provided in the response instead of being required to map custom code to each service provider and data source.

The Workshop
In this workshop, attendees will learn how to implement an alternative to one-off Web APIs using Hypermedia Engines. Topics covered include:

  • Hypermedia Past and Present
  • Nine Essential Hypermedia Factors
  • Selecting the Proper Data Format
  • Adding Hypermedia Application Controls to your Responses
  • Binding Protocol Methods to your Hypermedia Controls
  • Serving Up your Hypermedia
  • Writing Clients that Understand your Hypermedia
  • Documenting your Hypermedia
  • and more...
The session includes a mix of presentation, discussion, and hands-on implementation. Attendees are encouraged to bring laptops and "code-along" with supplied examples throughout the day. Whether you want to focus on general Hypermedia design, server implementation details, or coding hypermedia clients, this workshop will provide lots of examples and food for thought.

If you are responsible for designing and/or implementing "Web APIs" this workshop is for you.





Swift Test Driven Development for iOS Apps

iOS Swift Tests Test Driven Development
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

Starting your adventure with testing is not an easy task. You know this if you ever started writing tests on your own - you wrote some, but they were more of a burden rather than salvation. Fragile to change, long and hard to understand.

Or perhaps you have written tests before, but you’re having problems with applying what you’ve learned so far to Swift.

Or maybe you’d just like to refresh your TDD skills.

If you thought ‘That’s me!’ for any one of these (or all of them!) then you’re a prefect match for our Swift TDD workshop!

During this workshop you’ll learn how you can write more testable code by incorporating Test Driven Development into your workflow. Moreover you’ll learn how to make existing code more testable and what are the best tools for TDD in Swift.

Prerequisites for attendance:

  • General Swift knowledge - you should be able to read and understand code in Swift
  • Latest Xcode installed
  • Although not required AppCode is recommended - we’ll be heavily relying on its refactoring capabilities
  • Humor and hunger for knowledge!



Testing, Faster

WITH Dan North
Testing Patterns Techniques Agile
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

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.

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



NoEstimates

Planning Estimating NoEstimates Waste
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

What You Will Learn

  • What is an estimate, why we use them.
  • The issues with estimates, and why we need a new approach.
  • How I've been working without estimates.
  • How others have been working without estimates.
  • How to start working without estimates, or to reduce your dependency on them.
  • Ways to explore possible alternatives to estimates.

Agenda - what we will cover
  • Introduction to the concept of estimates
  • Discussion about how we use estimates.
  • Exercises to demonstrate the nature of estimates.
  • Information gathering sessions to build a common understanding.
  • Exercises to demonstrate possible ways to work without estimates.

Who Should Attend
Managers, Product Owners, Developers, and anyone involved in Software Development

Course Level
Intermediate - Having some experience with planning and estimating software development will be useful.

The default use of an "estimate-driven" approach is pervasive in software development efforts. While estimates can be useful, it is worthwhile to scrutinize our use of estimates, and to seek better ways to manage the development of software when estimates are not appropriate. [NOTE: For this session, I am referring to the use of estimates of cost, time, or effort for software projects, features, or tasks.]

There are a number of things to explore. For example, do we really need estimates for everything we currently use them for? Are we getting a reasonable benefit from them? Is it possible to manage software development without them?

In this session we will start with an information gathering exercise to help us gain a shared idea of our current understanding of the purpose and use of estimates. From here we'll move on to examine the nature of software development projects and a few possible other ways to approach our work.



How to enable Continuous Learning at work

MobProgramming PairProgramming Katas CodingDojos TrainingFromTheBackOfTheRoom Retrospectives ContinousImprovement Koans LeanCoffee CyberDojo Polyglot GroupLearning
WHEN:
Tuesday 9:00 - 17:00
WHERE:
TBD

If you improve 1% each day, at the end of 1 year you will be 36 times better.

This is why one of the cornerstones of agile is continuous improvement. This means learning has to be an everyday occurrence for your teams. This is easy when we are in school, or when there is a mentor with a lot to share, but how do you bring learning to your team when don’t have a teacher?

How can you be expected to teach everything?

The answer, of course, is you can’t. However, you can learn to *facilitate* learning on your team. Facilitation looks like teaching, but without the burden of having to master the subjects beforehand.

We are going to look at a lot of variations of learning exercises and styles you can run with your teams tomorrow and for the rest of the year to keep creating a learning culture and a leading your team to new heights.

Note: The exercises we are going to do are going to be very centered around code, however this course is focused on the learning the facilitation and therefore open to anyone, regardless of programming skill, who wants to learn how to facilitate learning.

You will practice with

  • Styles
    • Pair learning
    • Group Learning (Mob Programming)
  • Debriefs
    • Lean Coffee
    • Lightning Talks
    • Sticky Note Retros
  • Exercises
    • Lightning Talks
    • Podcasts / Videos
    • CyberDojo
    • Koans
    • Katas
    • SparrowDecks
    • Code Retreat


Wednesday — Workshop Day 2



Steering agile architecture

Agile architecture Visualization Architecture testing Process
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

Description
The architecture of the system is important and it deserves special attention because it is too easy for it to go wrong in the long run, and it is too expensive when that happens. In this course, we take a systematic look at what architecture is, and we detail a method of approaching the challenge of steering it on a daily basis through:

  • making architectural concerns explicit,
  • crafting automated checkers,
  • agreeing on findings, and
  • distilling corrective actions.

This approach requires the team to build custom tools and use them to guide decisions actively. This requires new skills and an appropriate technical infrastructure. However, this is a technical detail. The critical benefit comes from making architectural decisions explicit, and from the daily actions of cleaning the state of the system.

Target audience
Steering agile architecture is a challenge regardless of the type of system or chosen architecture and it should concern everyone involved in building the system. That is why, this course is targeted to both engineers and managers. We cover the multiple facets of the process, and we accompany the conceptual descriptions with real life examples from multiple case studies.

Course outline - Approaching architecture
What is software architecture:
  • Paper architecture vs. real architecture
  • When is architecture important?
  • Who should care about architecture?
  • Architecture and architects
  • Architecture and testing
  • Architecture and pair programming
  • Architecture and code review
  • Architecture and agile development
Architecture as an emergent property
  • Emergent properties and complex (as different from complicated) games
  • Growing architecture
Architecture and technical debt
  • Architecture and quality
  • The benefits and limitations of the technical debt metaphor
  • Beyond technical debt: software habitability as a positive metaphor
Architecture as a collaboration
  • Architecture as a commons
  • Architecture as a work in progress
  • Architecture as a negotiation
  • Small fixes and long term goals
The daily assessment game
  • The roles: stakeholder and facilitator
  • Integrating daily assessment in the development process
  • Dealing with the queue of technical tasks
  • Examples of daily group decisions and actions
  • Exposing architecture
Detecting and testing architecture drifts
  • The limited impact of out-of-the-box detections
  • The need for contextual detection
  • Testing architecture
  • Hypothesizing and the humane assessment method of crafting custom tools during development
Introduction in software analysis
  • Overview of what software analysis is and how it helps software architecture
  • How developers already unknowingly know software analysis
  • Code as data
  • Beyond basic code structure: annotations, configurations, tests etc.
  • How to think of analyses: static vs. dynamic, history vs. one version, code vs. bytecode, metrics vs. queries vs. visualizations
  • Software in pictures
What is information and software visualization?
  • Principles of visualization
  • Visualizing software systems
  • Visualization as a transformation
  • Visualization as an opportunity
  • Combining queries and visualizations



Resilient Software Design in theory and practice

Resilience Distributed System Design Patterns Microservices
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

To make the complex, distributed and highly interconnected system landscapes of today robust, responsive and highly available, we need to implement resilience into them at application level.

Many patterns for implementing resilience into an application exist. The daunting questions are how to slice (design) an application and which patterns to pick and combine in order to match your specific needs best.

In the first part of this tutorial we will get an overview about the resilience pattern landscape, which patterns exist, how to organize and select them and how to design resilient applications.

In the second part of this tutorial you will have the opportunity to apply the just learned contents to a real-life case study and design and discuss your own resilient solution.

After this session, you will have a much deeper understanding how to design a solution that satisfies your specific robustness needs.



Sense & Respond: How to Build & Lead Successful Lean Practices in High Growth Companies

Leadership Agility Process Collaboration Innovation
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

This hands-on class focuses on managing teams and their activities in an effort to build and scale successful lean practices. We will work together as a group to identify what an ideal process looks like, what gets in the way of implementing it and design explicit tactics to overcome these obstacles. We’ll combine the ideas behind Lean Startup, Agile, Lean UX and modern management to create specific frameworks you can bring back to the office. It’s also a great opportunity to connect with, share experiences with, and learn from peers–leaders who are in a similar position as you.

This is the class for you if:

  • You’re managing multiple product teams and want to get better at coordinating their activities.
  • You’re a senior practitioner or team leader who has run at least one lean experiment, and you’re trying to get better at running experiments.
  • You’re currently working on an agile team, but it feels strangely “waterfall-ish.” You’d like to move to a more continuous and iterative feedback-based process.
  • You have product discovery activities and product delivery activities, but they’re not as well-integrated as you’d like.
  • You want to build your capability to lead the change on your team and at your company

What you’ll learn:
  • How to align your teams’ efforts to larger strategy and to the needs of your business
  • How to frame your teams’ work in a way that encourages exploration and innovation
  • How to structure your projects around risk and learning
  • How to ensure that risk and learning are considered in every iteration
  • How to build consistent product discovery practices into your product delivery cadences



Transactions and Concurrency Control Patterns

Transactions ACID Concurrency Control Databases
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

Transactions and Concurrency Control are very of paramount importance when it comes to enterprise systems data integrity. However, this topic is very tough since you have to understand the inner workings of the database system, its concurrency control design choices (e.g. 2PL, MVCC), transaction isolation levels and locking schemes.

In this presentation, I'm going to explain what data anomalies can happen depending on the transaction isolation level, with references to Oracle, SQL Server, PostgreSQL, and MySQL.

I will also demonstrate that database transactions are not enough, especially for multi-request web flows. For this reason, I'm going to present multiple application-level transaction patterns based on both optimistic and pessimistic locking mechanisms.

Last, I'm going to talk about Concurrency Control strategies used in the Hibernate second-level caching mechanism, which can boost performance without compromising strong consistency.



Scaling Technology and Organizations Together

Scalability Business Technology Strategy Agile DevOps Continuous Delivery
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

Successful Internet companies are built on a foundation of excellent culture, efficient organization, and solid technology. As a company needs to scale, all of these parts of the foundation need to grow and scale with it. This tutorial will provide a deep dive into modern best practices at innovative companies in Silicon Valley for scaling culture, organization, and technology.

Driven primarily by the presenter's experience ranging from small Valley startups to Google and eBay, we will learn about:

  • Organizing engineering teams for innovation and velocity
  • Maintaining a culture of learning and risk-taking
  • Attracting and retaining excellent engineering talent
  • Developing and sustaining effective engineering processes and methodologies
  • Architecting scalable, high-quality, resilient software systems
We will conclude with recommendations on how to start implementing changes to your own organizational team structure, processes, and development practices.



Microservices Lifecycle Explained Through Docker And Continuous Deployment

Docker Docker Swarm Cluster Orchestration Continuous Deployment
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

This workshop is based on the material published in The DevOps 2.1 Toolkit: Building, testing, deploying, and monitoring services inside Docker Swarm clusters.

The workshop will go through the whole microservices development lifecycle. We’ll start from the very beginning and define and design architecture. From there on we’ll move from requirements, technological choices and development environment setup, through coding and testing all the way until the final deployment to production. We won’t stop there. Once our new services are up and running we’ll see how to maintain them, scale them depending on resource utilization and response time, and recover them in case of failures. We’ll try to balance the need for creative manual work and the need to automate as much of the process as possible.

The goal will be to design a fully automated continuous deployment (CDP) pipeline. We’ll see how microservices fit into CDP and immutable containers concepts and why the best results are obtained when those three are combined into one unique framework.

During the workshop we’ll explore tools like Docker, Docker Swarm, Docker Compose, Jenkins, HAProxy, and a few others.

We'll explore the practices and tools required to run a Swarm cluster. We'll go beyond a simple deployment. We'll explore how to create a continuous deployment process. We'll set up multiple clusters. One will be dedicated to testing and the other for production. We'll see how to accomplish zero-downtime deployments, what to do in case of a failover, how to run services at scale, how to monitor the systems, and how to make it heal itself. We'll explore the processes that will allow us to run the clusters on a laptop as well as on different cloud providers.



High-Performance Messaging with Aeron

Concurrency Messaging Networking Protocols Microservices
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

In this workshop you will learn how to build microservices with Aeron and SBE in Java. Microservices capable of handling millions of messages per second with very low and predictable response times. We will cover some networking theory and the design of Aeron so you know how to use it with mechanical sympathy.

Topics covered will include:

  • Network Fundamentals
  • Aeron Design
  • Encoding & decoding messages with SBE for zero copy semantics
  • Handling large messages and streaming
  • Monitoring, debugging, and spying on streams
  • Basic tuning for performance and resource management
  • "Multicasting" in the cloud with multi-channel-cast
  • Configuring message delivery service levels: allow loss, reliable, durable, etc.
  • Flow control and congestion control strategies
  • When and how to use them.
  • Customising channel endpoints for extending Aeron, e.g. testing loss scenarios.

Delegates need a laptop with Java 8 installed and be comfortable with hands on coding.

Workshop is aimed at intermediate to advanced but I do plan to start with the fundamentals and build up.



Software, Faster

WITH Dan North
Patterns Techniques Delivery Advanced Effective
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

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



The Foundations of Continuous Delivery

Continuous Delivery DevOps Agile Automation Testing Development Process Extreme Programming TDD BDD
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

Continuous Delivery is widely regarded as “State of the Art” in software development process. This course explains why that is and the fundamental drivers that make this approach to software development so effective.

Continuous Delivery is a complex, holistic approach to software development and has a significant impact on the way in which organisations operate. This approach demands a broad range of skills and techniques.

This course is designed to introduce, and explore a deeper understanding of, these ideas and techniques. It is primarily aimed at “Change Agents” within organisations, Leaders, Lead Developers, Lead Architects and so on.

More specifically this course will give you the tools to help your company become a 'Learning Organisation'. Increase efficiency and quality, and reduce risk in your software development process.

We do this by teaching an approach that will allow your company to become more experimental and capable of reacting quickly and efficiently to change and allowing your software development process to become a tool that enables this flexibility rather than an impediment to it.

This one day version of the the course focuses on the fundamentals of Continuous Delivery.

You will learn:

  • Why CD is taking the software development industry by storm.
  • Why it works.
  • The Fundamental Importance of Cycle-Time and experimentation.
  • Anatomy of a Deployment Pipeline.
  • Working iteratively and maintaining flow.



Designing Microservices

WITH Sam Newman
Architecture Microservices Distributed systems
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

Sam Newman shares some framing for microservice architectures that explore the various forces that can drive the design and evolution of microservices before leading you through a series of interactive architectural kata exercises to put your newfound knowledge to the test. You'll gain valuable experience with a series of tools you can immediately put into practice in your own projects.

What you'll learn, and how you can apply it:

  • Understand what makes a good microservice
  • Learn how to use concepts from domain-driven design to define service boundaries
  • Understand how to plan and manage a migration from a monolith to the microservice architecture
  • Understand how technical choices can impact the architecture itself
  • Learn about managing change and governance in a microservice environment

Prerequisites
Prior knowledge of service-oriented architectures generally or microservices specifically (useful but not required)

Detail
There is lots of theory out there about microservice architecture, but how often do you get to put that knowledge into practice? In the real world, it’s not feasible to rearchitect your system often, and certainly not in a single day. . .or is it?

Sam Newman, the author of Building Microservices, leads a workshop that gives you a safe space to explore ideas behind microservice architectures with peers from other organizations. Sam shares some framing for microservice architectures that explore the various forces that can drive the design and evolution of microservices before leading you through a series of interactive architectural kata exercises to put your newfound knowledge to the test. You’ll gain valuable experience with a series of tools you can immediately put into practice in your own projects.

Level of the workshop: I'd suggest more experienced developers, dev managers, tech leads and CTOs. Definitely need a tech background, but not any specific experience with distributed systems/microservice architectures.



Mob Programming

Pair-programming Teamwork Collaboration
WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

Mob Programming: All the brilliant people working on the same thing, at the same time, in the same place, and on the same computer.

Mob Programming is a cost-effective, collaborative and fun way to get work done together. It's a whole-team approach to development, where coding, designing, testing, and working with the "customer" (partner, Product Owner, User, etc.) is all done as a team.

Participants in this workshop experience a day of learning and doing Mob Programming. We cover the mechanics of how to work together as a Mob as well as the techniques that make this form of development so effective.

We’ll learn how a Mob performs sample project work, including user stories, prioritization, test-driven development, refactoring, and retrospectives.

Designed and facilitated by Mob Programming pioneer Woody Zuill, this workshop provides a hands-on education in the art of mobbing and it's significant benefits for your teams.

Learning Goals

  • How 5+ people can be effective working on just one thing
  • Heuristics for team size
  • Guidelines for successful collaboration
  • Handling competing solutions and ideas to a coding problem
  • Encouraging politeness and kindness of team members
  • Reducing or eliminating harmful conflicts
  • Mobbing Mechanics
  • Tools for team coding
  • Workspace setup
  • How to "Amplify Learning" and take advantage of continual learning opportunities
  • "Real-time" and continuous Retrospectives to reflect, tune, adjust
  • The theory of why Mob Programming is effective.
  • Test-Driven Development (TDD) as a team
  • Working with Product Owners, Business Experts, Testers, Designers as part of the team
  • Refactoring as a team
  • Continuous feedback at all levels of granularity

Workshop Agenda
Hands-on Exercises, Presentation, Interactive Dialogues, Simulations, Videos
  • Introduction: Mob Programming Introduction, The basics of how it works
  • Activity: The nature of software development
  • Activity: Teamwork - a good thing
  • Driver/Navigator teamwork Roles and Techniques
  • Coding Dojo Demonstration: A simple demo of Mob Programming with volunteers from the participants.
  • Lunch
  • Advanced Mob Programming Concepts - Hands on coding
  • Coding Exercise: Working on a Sample Project, learning to work together using a few rules
  • Amplified Learning, How to take advantage of learning opportunities
  • Continuing the Coding Exercise: Removing the rules
  • Retrospective and review, group discussion of what we’ve learned



Kubernetes workshop

WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

Kubernetes is a powerful system, developed by Google, for managing containerized applications in a clustered environment. It aims to provide better ways of managing related, distributed components across varied infrastructure. Kubernetes brings the first real way of traffic docker container production.

Kubernetes is a system for managing containerized applications across a cluster of nodes. In many ways, Kubernetes was designed to address the disconnect between the way that modern, clustered infrastructure is designed, and some of the assumptions that most applications and services have about their environments.

The workshop covers architecture best practices, workflow and interaction of the components, which is the best preparation for solving real problems.

Audience
The workshop is recommended to Cloud Administrators, DevOps Engineers, Cloud Platform Engineers, Developers and IT Professional.

Goal The target of this workshop is introduce Kubernetes is an open-source system for automating deployment, operations, and scaling of containerized applications and discuss what can be solved by Kubernetes (i.e. high available container cluster, networking for containers, storage for containers and application lifecycle)

Agenda

  • Differences between Docker, Docker Compose and Kubernetes
  • Principle of docker virtualization and Kubernetes solution
  • Configuration of the docker containers
  • Running applications in docker
  • Possible ways of solving networking containers' solutions and their differences (Flannel, Calico, Contrail, Weave
  • Storage containers and possible integration with CEPH
  • Examples of using Kubernetes within the CI / CD system (rolling update, testing, validation, automation).
  • Advantages of container solution for development and testing
  • Kubernetes app orchestration by app controller



Serverless “Zombie" Microservices Workshop

WHEN:
Wednesday 9:00 - 17:00
WHERE:
TBD

Scenario: A widespread viral infection transmitted through bites that cause human corpses to reanimate has spread to every major metropolitan area around the world. In order to fight this battle, we invite you with great urgency to register and attend an AWS Zombie Microservices Workshop to rebuild what remains of our great civilization.

Mission Details: The AWS Lambda Signal Corps has built a serverless communications system using AWS Lambda, Amazon DynamoDB, and Amazon API Gateway to connect survivors. The Corps will be travelling across the globe to deliver workshops on building this communications system. After introducing the basics of building microservices with Lambda and API Gateway, we look to you to add additional life saving features - food caches, panic buttons, etc. - to the platform. The fate of our civilization is in your hands.

Most of the content that I’ll use for the workshop is in this repo: https://github.com/awslabs/aws-lambda-zombie-workshop

Agenda:

  • 08:00-09:00 - Registration and Breakfast
  • 09:00-10:30 - Introduction to Serverless Architectures
  • 10:30-11:00 - Coffee Break
  • 11:00-12:30 - Hands-on Part 1
  • 12:30-13:30 - Lunch
  • 13:30-15:00 - Hands-on Part 2
  • 15:00-15:30 - Coffee Break
  • 15:30-16:00 - Wrap Up and Discussion


GIVE US
FEEDBACK

Create account

You need an account to save events.

Already have an account? Sign in

Sign in

Sign in to save events.