Advanced BDD/TDD Masterclass (2 days)

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

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

NoEstimates

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.

• 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.

Swift Test Driven Development for iOS Apps

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!

How to enable Continuous Learning at work

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

Hypermedia Hacking with Mike Amundsen

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...

Presentation Aikido

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.

Making Agile Valuable

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

• 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

Building Great Teams: Culture and Core Protocols

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.

• 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.

• 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

Docker Security Workshop

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

Advanced Domain-Driven Design Workshop

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

Deep Dive Into Scala and Akka

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

Serverless “Zombie" Microservices Workshop

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

Agile Psychology 101

One positive aspect of Agile methods is that they place people at the centre of the development process. One negative aspect of this is that there is little to no serious training available to Agile enthusiasts on working with people and teams. As a result, pop psychology myths are passed around and followed, leading many ScrumMasters, Agile coaches, and others, to do more harm than good, despite their best intentions.

This workshop is a first step to counter this lack of knowledge and training. Under the tutelage of two trained psychologists, you will learn how teams are formed, why they behave the way they do, and how you can help them perform better. You will also learn about the social and cognitive psychological research supporting these theories. You will experience this knowledge in a series of exercises, and you will be able to start using it as soon as you get back to the office.

Kubernetes workshop

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

Mob Programming

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

• 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

Designing Microservices

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

Eclipse/ToolMakers’ Day 2017

Eclipse/Toolmakers’ Day is an event created for the tool developer community. This is a workshop that highlights how the most successful engineering companies build in-house software tools to stay ahead of the competition. Our workshop features a selection of Hungarian and international speakers from a wide spectrum of software-intensive engineering domains including automotive, telecommunication, energy, avionics, and Internet-of-Things. The main technological theme of the workshop is centered around the Eclipse open source ecosystem, which is currently at the forefront of tool development innovation. Eclipse is now far more than just a Java IDE. It is a rich software platform that encompasses programming languages, tools, protocols and frameworks from an exceptionally wide range of domains.

This open event features several speakers with 45 minute presentations. There is no special target audience, we just ask for you to come, listen and ask any questions you may have on the subject matter. Our workshop is meant to benefit anyone who is developing software engineering tools, either as part of an open source or in-house project. We believe that these talks will be of tremendous value to any technical lead or software developer working within engineering companies in critical embedded systems domains.

Topics and key takeaways: 

• Learn about how custom tools can enhance not only software, but complete systems engineering processes
• Boost developer productivity via software modeling and code generation 
• Improve documentation and stakeholder communication
• Shorten time-to-market, even within extreme domains such as high-risk R&D

The workshop will feature two sessions:

• The morning session will focus on tool development innovations in Hungary, with a special concentration on the automotive and telecommunication domains. 
• The afternoon session will feature key members of the international Eclipse community and cover a wide range of topics including systems engineering tools, collaborative technologies, and domain-specific languages.

Agenda:

• 8:30-9:00 Registration
• 9:00-12:00 Morning section
• 9:15-9:30 Introduction – István Ráth, managing director of IncQuery Labs Ltd.
• 9:30-10:30 Keynote: „Software is Eating the World - What to do?” – Ralph Müller, European leader of Eclipse Foundation (Germany)
• 10:30-11:00 Coffee break
• 11:00-12:00 „The Capella open sourcing story: stakes, challenges, opportunities” –Stéphane Bonnet, Head of Thales Corporate MBSE Coaching and Design Authority (France)
• 12:00-13:00 „Graphical DSL with Sirius: how to simplify the creation of custom modeling tools” – Étienne Juliot, co-founder and vice-president of Obeo (France)
• 13:00-14:00 Lunch
• 14:00-17:00 Afternoon section
• 14:00-15:00 „Model Based Development and Code Generation for Automotive Embedded Systems” – Gergely Pintér, department leader of ThyssenKrupp Presta Hungary and Máté Kovács, software engineer
• 15:00-15:30 Coffee break
• 15:30-16:30 „The ascent of Titan” – Elemér Lelik, software engineer of Ericsson Hungary
• 16:30-17:00 „Multi-disciplinary simulation of smart and safe systems” – Ákos Horváth, managing director of IncQuery Labs Ltd., leader of the OpenCPS project’s Hungarian consortium

The Foundations of Continuous Delivery

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.

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

High-Performance Messaging with Aeron

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.

Microservices Lifecycle Explained Through Docker And Continuous Deployment

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.

Scaling Technology and Organizations Together

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

Transactions and Concurrency Control Patterns

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.

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

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

• 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

Resilient Software Design in theory and practice

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.

Steering agile architecture

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.

• 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

• Emergent properties and complex (as different from complicated) games
• Growing architecture

• Architecture and quality
• The benefits and limitations of the technical debt metaphor
• Beyond technical debt: software habitability as a positive metaphor

• Architecture as a commons
• Architecture as a work in progress
• Architecture as a negotiation
• Small fixes and long term goals

• 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

• 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

• 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

• Principles of visualization
• Visualizing software systems
• Visualization as a transformation
• Visualization as an opportunity
• Combining queries and visualizations