Tuesday & Wednesday — Workshop Day 1 & 2



Test Driven Development (2 days)

TDD unit tests refactoring BDD specification by example extreme programming java python c++ c# .net javascript
WHEN:
Tuesday+Wednesday 9:00 - 17:00
WHERE:

Test Driven development is a combination for many microskills and a fluency that allows you to solve problems while focusing on the problem instead of the microskills.
This workshop will endeavor to learn the individual skills as well as build the fuency to use these skills with the additional burden of everyday work.

Prerequisites:
general coding knowledge in either: java, c#, c++, javascript or python (examples will be in all languages). 
a laptop with language & editor. (list at the bottom)
note: this is a very active hands on workshop. Please be well rested the night before

Microskills:

  • Writing scenarios
  • Transforming scenarios to steps
  • Consume 1st programming
  • Using your Editor effectively
  • Verify results
  • Using Coverage
  • Seperating code
  • Removing Duplication
  • Fake it till you make it.
Editors:
Consume First style TDD requires editor support. Here are the list of editor for the class. All are available for free or for a free 1 month trial.
  • java -> eclipse or intellij
  • c# -> visual studio with resharper
  • javascript -> webstorm
  • python -> pycharm 
  • c++ -> clion or visual studio with resharper





Tuesday — Workshop Day 1



Testing, Faster

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

Testing Faster explores the principles and practises of agile testing. The class is taught in a dynamic, interactive and engaging style. There are no slides or handouts. Instead participants work together in small groups to reinforce the training and make it relevant to their own context.

Outline
  • Test Strategy—reasoning about what, where and when to test
  • Test Design—reasoning about how to test
  • BDD—understanding its relationship to testing and automation
  • Automation—when, where to automate, and where not to
  • Designing for Testability—how test thinking can inform design, development and deployment

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.



Delivering value early and often in practice

continuous delivery continuous deployment lean startup agile lean dark launch automated testing
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Our goal as software developers is to sustainably deliver value for our organizations. Conferences are a great opportunity to learn about the challenges other teams faced (challenges you might also be facing right now) and how those challenges can be solved. However, putting even the best of advice’s into practice is hard. This exciting day-long coding challenge will provide you with an opportunity to practice continuous delivery and related agile and lean principles. You and your team will compete with other teams in delivering the most value to your product. Along the way, our mentor will spend time with you and your team and give you advice personalized to your needs.

Please make sure to bring your laptop along, and that you have your development environment set up for at least one of the supported languages: Clojure, C#, Elixir, Go, Groovy, Haskell, Java, JavaScript, Perl, PHP, Python, Ruby, Scala, TypeScript. 

What you will learn:

  • How to use a continuous deployment pipeline to your advantage
  • How to cut your feedback loop down to hours or even minutes by deploying early and often
  • How to release new versions safely using feature toggles, dark launches, and shadow features in practice
  • How to make pragmatic decisions about when and how to test your software
  • How to split responsibilities within a team for maximum effectiveness 
  • How to sustainably react to a rapidly changing market and requirements
  • How to measure the success of your product and the effects of changes you deployed



Systems and Service Monitoring with Prometheus

prometheus metrics time series monitoring alerts alerting tsdb time series database query language
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Prometheus is a popular open-source monitoring system and time series database. It features a multi-dimensional data model, a flexible query language, and integrates monitoring aspects all the way from client-side instrumentation to alerting.

In this introductory workshop, the co-creator of Prometheus will explain the architecture and concepts behind Prometheus. Participants will set up core Prometheus components (Prometheus server, Alertmanager, Grafana, Node Exporter, and more) and monitor an example service setup. Based on the example setup, we will explore the data model, query language, alerting, and dashboarding functionalities of Prometheus.



Living Documentation, Step by Step

Living Documentation Agile Continuous Delivery Design Architecture Domain-Driven Design
WHEN:
Tuesday 9:00 - 17:00
WHERE:

If you prefer coding over writing documentation, then you’ll love Living Documentation! A Living Documentation changes at the same pace as software design and development, from establishment of business goals to capturing domain knowledge, creating architecture, designing software and coding. It builds on top of BDD and DDD, but it also has its own key principles and novels ways to dramatically improve your documentation at minimal extra cost by using well-crafted artifacts and judicious automation.

This workshop from Cyrille Martraire, the author of the book "Living Documentation" (Addison-Wesley Professional), will guide you on how to implement the approach in your projects. Even if you haven't read the book, this workshop is the right place to learn the main elements of a Living Documentation, step by step through a provided sample Java code base.

You will learn:

  • How most knowledge is already there somewhere in your artifacts, even in an implicit form
  • How just talking and working together may be enough documentation, and when it does not
  • How to augment the code to make it fully explicit for further use by people and tools
  • How to differentiate between stable and volatile knowledge, and how this informs the way to deal with it
  • How to create zero-maintainance Evergreen Documents
  • How to recognize Shameful Comments and improve your code from there
  • How a word cloud can tell if you're doing your domain model wrong
  • How to generate a Living Glossary straight out of the code
  • How Architectural Decisions Records can help make better decisions
  • How Design Patterns help document a design decision very efficiently
  • How to visualize a design structure by generating a Living Diagram from the code itself
  • How to use plenty of other techniques to improve your particular needs, and the main traps to avoid
  • How failing to do any of the above is in itself a valuable feedback
  • How to introduce the topic in your project and with your colleagues

What you will need

  • A working Java 8 environment with Maven for two attendees
  • The sample project (only using basic Java) will be available from github or from a USB key



Docker production: Swarm orchestration, security, and beyond

docker containers orchestration docker swarm swarm
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Description

Need to take your containers into production and operate Docker clusters like a pro? This workshop skips Docker basics and CI/CD topics. Rather, it focuses squarely on the tools and techniques of building and operating container clusters using Docker. Starting where previous Docker 101 workshops leave off, you'll dive into Swarm Mode clustering (Docker Services), rolling updates, monitoring, logging, troubleshooting, Swarm recovery, and Docker security features. This workshop covers the latest built-in Docker features and common third-party tools, and Bret will walk you through installing them on your own five-node cloud Swarm cluster in AWS.

What you'll learn

  • Walk through building a multi-node, secure Docker Swarm cluster in AWS.
  • Learn how to deploy and manage a multi-container, highly available microservice app inside that cluster.
  • Gain hands-on experience with daily and intermediate-level tasks a container cluster operator deals with.
  • Improve your security posture with optional Docker features.
  • Learn how Docker compose files can be used in production clusters.
  • Test rolling updates, failed update rollbacks, and implement healthchecks into your Dockerfiles.
  • Deploy centralized logging, monitoring, and data management options for Docker Swarm.

Prerequisite knowledge

  • A working knowledge of Docker (You are familiar with Docker images and containers, have used Dockerfile and docker-compose.yml in some fashion and understand the basic commands and purpose behind them.)
  • Shell and SSH basics for Linux. (We'll guide you through all commands.)
  • General understanding of microservice and distributed computing concepts. 

Materials needed in advance

  • A laptop with an SSH program installed

Outline

Docker Swarm

  • SSH into your five nodes and create a Swarm
  • Spin up a sample multicontainer microservice app
  • Use built-in commands to validate it’s working and logging; use troubleshooting techniques on the overlay networks and to jump into containers
  • Deploy redundant containers and test high availability
  • Use rolling updates to update apps without downtime, including rollback
  • Add healthchecks to Dockerfiles and Swarm Services
  • Deal with failed containers and failed cluster nodes

Common third-party tools for logging, monitoring, and troubleshooting

  • Set up and test ELK (Elasticsearch, Logstash, and Kibana)
  • Set up and test cAdvisor
  • Set up and test Prometheus

Key features of production systems

  • Docker security features - user namespace setup, storing secrets, network isolation
  • Failed Raft consensus scenarios and options to recover
  • Persistent data options for Docker clusters

Other things you’ll learn along the way

  • Troubleshooting and sysadmin tools you may have forgotten
  • New tools for the container admin
  • Staying up to date on Docker tool releases
  • Command aliases for quicker day-to-day container management
  • Shell scripts for common processes



Code As A Crime Scene: Fix Technical Debt with Behavioural Code Analysis

Technical Debt Legacy Code People Organizations
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Most organizations find it hard to prioritize and repay their technical debt. The main reason is the scale of modern systems with million lines of code and multiple development teams where no one has a holistic overview. So what if we could mine the collective intelligence of all contributing programmers and start to make decisions based on data from how the organization actually works with the code?

In this workshop you learn novel analysis techniques based on data from the most underused informational source that we have in our industry: our version-control system. You'll learn to:
  • Identify the code that's most expensive to maintain amongst millions lines of code.
  • Detect architectural decay in both layered and microservice systems.
  • Identify implicit dependencies across service boundaries.
  • Measure how multiple developers influence code quality and what you can do about it.
  • View your codebase from a social perspective and see how different organizational patterns influence the code you write.
  • Use behavioral code analysis to guide refactorings.
The practical exercises use CodeScene and Git for demonstrations, but this workshop isn't about tools. Rather, it's about pragmatic techniques and analyses that apply to systems of all scales. At the end you'll be able to base both technical and organizational decisions on data.

Style

The workshop blends theory and practice in a hands-on style where we analyze real world codebases.

Preparations

Participants need to bring their own laptop with a recent Java run-time (at least Java 8), a Git client (at least 2.15). Detailed preparations will be sent out in advance.
All participants are encouraged to take this opportunity to analyze their own codebase: just bring a local clone of your Git repositories.

Audience

Experienced developers, architects, and technical leads.

Programming languages

All techniques are language neutral and we show that by analyzing systems written in C, C#, Java, JavaScript, Scala, and many more.



Running Effective Workshops

workshops workshop facilitation ux design strategy product management innovation creativity collaboration teamwork leadership
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Learn how to run effective workshops for team and/or client sessions in this one-day masterclass from the author of "A Pocket Guide to Effective Workshops".

To build great products, you'll need to get insights from users and clients, brainstorm with your team and regularly get together with colleagues for high-level discussions. This interactive and practical workshop equips you with the confidence and skills to design and lead great brainstorming sessions, strategy workshops, project kickoffs and retrospectives. Through training, practical examples, group discussions and exercises, you will leave with a toolkit and framework to lead your future team or client workshops. 

Who should attend: This workshop is both for complete beginners and those who have some experience but want to up their game and refresh their skills.  

After this workshop, you will be able to:

  • Create structured workshop activities and plans, from a range of tools and methods
  • Design sessions that keep creativity flowing and participants engaged
  • Lead productive and effective workshops that generate great ideas, get tangible outputs and lead to great results
  • Facilitate great workshops that stay focused and encourage contributions from everyone in the room
  • Deal with the common challenges that come up during workshops
What is covered
The day covers tools and techniques that you can start using straight away, the knowledge and best practices that engage and motivate teams for creativity and innovation and practical methods for leading productive workshops:
  • Encouraging creativity and collaboration in workshops

  • Setting goals and expectations, types of workshops, designing activities and structuring workshops

  • Facilitation skills, techniques and styles, and troubleshooting

  • Workshop outputs and maintaining momentum after the event

About the trainer

Alison Coward is the founder of Bracket and author of “A Pocket Guide to Effective Workshops”. She is a workshop facilitator, trainer and speaker. 

With over 15 years’ experience of working in, leading and facilitating creative teams, Alison is passionate about finding the perfect balance between creativity and productivity. At Bracket, she helps teams to use the best of their talents to develop great ideas and collaborate to make them happen.

In this workshop, she shares the exact tried and tested methods that she uses with her clients to produce high-quality ideas, get clear insights and help them make significant progress.



Making Agile Work for You

agile, Scrum, Kanban, Lean
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Learn how to apply agile practices to develop the right products, deliver faster, increase quality, and become a happy high-performing team!

Many teams are adopting an agile way of working with Scrum, Kanban, XP, Lean, or any other agile framework. Their expectation is that it will help them to better serve the IT needs of their stakeholders and to develop products that satisfy their customer’s needs. Unfortunately, it doesn’t always work that way.

If your team is

  • finding it difficult to agree and decide with stakeholders on what to deliver when
  • not delivering working software every sprint or not able to finish user stories within reasonable time
  • finding it hard to understand what your customers actually need and unsure if you are delivering value to them
  • having difficulties communicating and working together as a self-organized team
  • feeling micromanaged and not empowered to decide and take control of their own journey
  • doing agile/Scrum/Kanban rituals but feeling that they are not always helpful
  • not getting good actions out of your retrospective or actions not being done

then this is the workshop for you!

Applying agile to make it work for your team isn’t easy. But it can be done!

Making Agile Work for You

In the workshop Making Agile Work for You you will experience agile practices that you can apply in your teams:

  • Practice how you can effectively tailor agile for planning your work, doing daily stand-ups with Scrum/Kanban boards, gathering feedback with product reviews/demos, and improving your way of working with agile retrospectives.
  • Learn how to apply agile practices with an agile mindset.
  • Increase your ability to pick those practices that help you to do a better job and collaborate better with your stakeholders.

The workshop is loaded with examples and suggestions to help you become more agile and lean.

Audience

This workshop is intended for:

  • Technical (team) leaders and Scrum masters
  • (Senior) Developers and Tester
  • Product Owners and Project/Line Managers
  • Stakeholders working with agile teams
  • Agile and Lean Coaches
  • Anybody who is supporting teams in agile transformations

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

Results

What will you get out of this workshop:

  • Practice working with Agile and Scrum/Kanban: planning, daily stand-ups, product reviews and retrospectives
  • Get ideas for improving collaboration and communication with stakeholders to deliver more value
  • Find out how to deal effectively with impediments to take control and truly become self-organized
  • Learn tips and tricks to improve your agile way of working
  • Get advice on selecting and applying agile (Scrum, Kanban, XP, Lean) practices effectively for you

Testimonials

“The workshop Getting More out of Agile and Lean was really interesting. I specially liked the product owner and team exercise, the impediment game and the 1-word retrospective that we did. I learned when and how I can use them in my daily work.”

Bill Souliotis – Manager Software Research & Development Graphics User Interface at BETA CAE Systems

“I’d like to thank you again for your excellent workshop. It was fun and I already started using some of the ideas with my team. The change is definitely notable.”

Liran Ben-Porat, qSpark LTD

“Nice to join a workshop in which the attendees and teacher actually have profound hands-on experience with agile.”
“Immersive, good choice of subjects, well led.”
“A lot of examples.”
“Good useful interactions and learning from other participants.”

Attendees from the GOTO Amsterdam workshop

“I attended Ben’s workshop in Athens (Getting More out of Agile and Lean) and I can highly recommend it to all professionals that are serious about Scrum and about applying agile processes in real-world problems of software development. Especially for Product Owners and for Scrum Masters, this training will help you and your organisation evolve to the next level. Thank you, Ben!”

Konstantinos Vasileiou – Certified Product Owner | Senior Business Analyst



Influence Strategies for Practitioners

Influence Thinking Communication Innovation
WHEN:
Tuesday 9:00 - 17:00
WHERE:

You’ve tried and tried to convince people of your position. You’ve laid out your logical arguments on impressive PowerPoint slides—but you are still not able to sway them. Cognitive scientists understand that the approach you are taking is rarely successful. Often you must speak to others’ subconscious motivators rather than their rational, analytic side. Linda Rising shares influence strategies that you can use to more effectively convince others to see things your way. These strategies take advantage of hardwired traits: “liking”—we like people who are like us; “reciprocity”—we repay in kind; “social proof”—we follow the lead of others similar to us; “consistency”—we align ourselves with our previous commitments; “authority”—we defer to authority figures; and “scarcity”—we want more of something when there is less to be had. Learn how to build on these traits as a way of bringing others to your side. Use this valuable toolkit in addition to the logical left-brain techniques on which we depend.



Hands On With Habitat

containers continuous delivery cloud deployment
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Introducing Habitat, where the automation travels with the app. It’s a new open source project from Chef, allowing you to create applications that are packaged with all the intelligence they need to run in production. Habitat makes this possible by producing immutable artifacts and a runtime environment, for new AND legacy applications. Habitat extends the reach of containers and guarantees the application’s behavior on any infrastructure. Learn how you can finally solve the build, manage and deploy cycle for any application on any platform.

In this workshop, we'll introduce Habitat and it's tools including the new Builder service that will help you get your code from Github to Docker Hub in one workflow. We'll also work through adding Habitat to an existing application, and deploying Habitat packages to Kubernetes. We'll use the templating languages and tools that allow Habitat to be flexible enough to work with all kinds of applications, from Ruby and Rails to Java on Tomcat. 



Data Science for Developers (Beginner)

Data Science Machine Learning Deep Learning Big Data Analytics
WHEN:
Tuesday 9:00 - 17:00
WHERE:

In this one-day beginners-level course, you will be introduced to a range of fundamental data science concepts. You will discover how to interrogate data, choose a which machine learning methods suit your problems and how to achieve results quickly. It will provide an overview of many tools and techniques. The course is focused towards developers through programming-led examples but is industry oriented. The goal is to provide you with enough knowledge to "know what you don't know" and enable you to discuss fundamental data science topics with confidence.

Who will benefit

This course is aimed towards developers, in which we will discuss a little mathematics, but focus on developing real-life algorithms in Python. One-to-one help will be provided for developers new to Python and all algorithms, frameworks and libraries used will be demonstrated by the instructor.

This is an introductory course, which is suitable for most users with limited development experience. Some experience of Python is helpful. No data science experience is expected.

What you will achieve

The day will comprise of a series of sub-hour theoretical sessions separated by practical exercises. It will cover a range of topics, but it is expected that you will be able to:

  • Discuss the differences between types of learning
  • Describe problems in a way which can be solved with Data Science
  • Understand the difference between regression and classification
  • Solve problems using regression algorithms
  • Solve problems using classification algorithms
  • Learn how to avoid overfitting and appreciate generalisation
  • Develop features within data
  • Describe how and where to obtain data

Topics covered in this training

  • How data science fits within a business context
  • Data science processes and language
  • Information and uncertainty
  • Types of learning
  • Segmentation
  • Modelling
  • Overfitting and generalisation
  • Holdout and validation techniques
  • Optimisation and simple data processing
  • Linear regression
  • Classification and clustering
  • Feature engineering
  • An in-depth practical example demonstrating the day’s concepts if time allows



Building A Self-Sufficient System

Cluster Docker Self-healing Self-adaptation Auto-scaling Metrics Monitoring Alerting
WHEN:
Tuesday 9:00 - 17:00
WHERE:

What do we expect from a modern cluster? If a replica fails, it should be brought back up (rescheduled). If a node goes down all the services that were running inside it should be distributed among healthy nodes. Those tasks are easy to accomplish. Schedulers (Swarm, Kubernetes, Mesos/Marathon, and so on) are already doing those things for us. Many solutions provide self-healing by making sure that the system is (almost) always in the desired state.

The problem with self-healing is that it does not take into the account constant changes. The number of requests is continuously changing, errors are created, network bandwidth is fluctuating, and so on. A cluster, and services inside it, is like a living body that needs to adapt to changes continuously. Services need to be scaled and de-scaled, nodes need to be created and added to the cluster only to be removed soon after. We call that process adaptation. Even that is not the problem in itself, as long as we have an army of operators that will monitor the system and do reactive and preventive actions.

How about converting adaptation into self-adaptation? Can we remove humans from the process and make a system that is self-sufficient?

The goal of this workshop is to provide hands-on exercises that outline the steps required for a design of a self-adapting and self-healing system that will continue operating efficiently even when we are on vacations. We'll define goals and processes and explore quite a few tools (Docker, Prometheus, Alertmanager, Jenkins, AWS, and so on). The end-result of the workshop will be a base for a self-sufficient system that you'll be able to implement in your organization.



Mob Programming, A Whole Team Approach

Pair Programming Mob Programming Teamwork
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Mob Programming Workshop 

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 Mob Programming and learn the mechanics of how to work together as a Mob and the techniques that make this form of development so effective.

You’ll learn how to do Mob Programming through instruction and hands-on 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 Mob Programming and its 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 as part of the team
• Refactoring as a team
• Continuous feedback at all levels of granularity

Instruction Approach
Hands-on Exercises, Interactive Dialogues, Simulations, Videos

Example Agenda 
(the exact order of things will likely be different)
• What Is Mob Programming & The basics of how it works
• First Exercise: A Code Dojo to Introduce Basic Concepts
• Driver/Navigator teamwork Roles and Techniques
• Second Exercise: A sample project
• The Importance of Retrospectives
• Advanced Mob Programming Concepts
• Third Exercise: Expanding on the Sample Project
• Amplified Learning - How to take advantage of learning opportunities
• Resolving Conflict
• Retrospective and review



Angular for Real

WITH Bill Odom
angular typescript javascript web development spa single-page web applications web frameworks
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Angular has exploded in popularity over the last few years, and for good reason. It provides a powerful approach to building web applications, and it's surprisingly easy to create a real, working application with very little effort.

Unfortunately, it's just as easy to get stuck as it is to get started. Angular is powerful, yes, but the learning curve is steep, and while it makes easy things very easy, progress beyond that early rush of success can be tough. Many developers find themselves, a few weeks (or even months) into an Angular project, wondering how things got so out of hand.

This workshop will fix that. We'll start with an overview that puts all the major pieces of Angular in context, and explains their purpose and intent. From there, we'll dive into specific tools and techniques to help you build Angular applications that are maintainable, performant, and scalable.

Specifically, we'll talk about these topics from a distinctly Angular perspective:
  • Architecture, layout, and file structure of large applications
  • What goes where, and why -- routing, services, components, and more
  • State management
  • Performance considerations
  • Testing strategies
  • Workflows, tooling, and automation
  • Future-proofing and migration (a.k.a., preparing for the inevitable)
  • Real-world style guidelines and best practices
In short, we'll cover what it takes to build complex Angular applications that are fast and robust, without losing the power and flexibility that Angular provides.

Audience:
This workshop is targeted toward experienced developers. (Experience developing web applications, however, is not strictly required.)

Preparation:
Please bring a laptop with the following installed:




HOW TO LEAD A GREAT DEVELOPER TEAM?

leadership teamwork creativity developer
WHEN:
Tuesday 9:00 - 17:00
WHERE:

Every leader has a great effect on its company, on its results, on employee motivation and on the overall atmosphere. In the world of accelerating changes, leaders’ approach to creativity, teamwork, cooperation, success and change are all critical factors.

How can a leader turn a challenging development process into a creative flow for the team, filled with long-lasting inspiration and easy-to-realize, market-relevant, successful results?

This is the focus question of the 1-day workshop organized by Invention Factory (www.inventionfact.com), the exclusive user of ORGANOCO method in organizational development. The method works with the deepest layers of personal and team-psychology, and opens brand-new doors to creative thinking and success. Surprising ORGANOCO viewpoints, combined with unusual team exercises and self-refelctions guarantee not only a memorable experience, but provide for the participants useful, practical tools that can be applied in everyday work easily.

 Leadership topics covered

  •  How to trigger team-level creativity by overcoming hidden limitations of subconscious barriers?
  •  How to move out from the mesmerizing dominance of past experiences and usual solutions?
  • How to find and empower the approach that supports developer teams to experience work as a joyful creation?
  •  What to know about team-roles, and the subconscious, limiting mechanisms in teams, such as the team level impacts of leader behaviour forms?
  • How to utilize the skills of team members for the organization the best, while teamwork gives them the highest level of support, inspiration and joy?

 

Audience

The workshop is intended for

  • top level leaders and
  • team leaders.



Balancing Business + Usage + Technology: A Holistic Solution Strategy

Product Management Product Ownership Product Strategy Service Design Program Management Project Management Leadership Systems Engineering
WHEN:
Tuesday 9:00 - 17:00
WHERE:

STOP developing products and START delivering solutions!

This workshop invites participants to shift their thinking toward a holistic solution strategy that balances business, usage, and technology. Delivering compelling solutions to customer problems is complex balancing act. Many products fail due to a flawed business model while others are neither desirable nor useful. In this workshop, participants will discover and explore a robust model that uses business, usage, and technology as lenses:

  • The Business lens represents the economic viewpoint. A solution must be marketable, profitable, affordable.
  • The Usage lens represents the conceptual viewpoint. A solution must be desirable, usable, useful.
  • The Technology lens represents the implementation viewpoint. A solution must be manufacturable, functional, consumable

The model at the heart of the workshop was developed over 15 years and used by many product teams. It is robust and proven to work well. The model forms a cohesive and consistent taxonomy that can be used by organizations as the basis of a shared vocabulary, thereby reducing misinterpretations and wasteful communication churn. It can also be used as an architecture for a solution life cycle. Teams and organizations can use these concepts to dramatically improve solution effectiveness, shorten time to market, and reduce risk.

Product managers, product owners, product planners, product marketing, business analysts, architects, designers, product engineers, software developers, and involved in discovering, defining, and delivering solutions. This course works exceptionally well in an intact-team setting.

What You Will Learn

By the end of this course, participants will be able to:

  • describe the three fundamental perspectives of a solutions: Business, Usage, and Technology
  • describe the lens overlaps in the model: Value, Capability, and Ingredient
  • grasp the concept of a “balanced” solution and “balanced” team
  • critically evaluate a product, service, or solution
  • apply the Three-Lens Model to a solution life cycle
  •  use the Three-Lens Model to assess, diagnose, and improve risks and issues in program management and product development

Who Should Attend

This workshop is designed for product managers, product owners, product planners, product marketing, service designers, business analysts, architects, product engineers, software developers, and anyone else involved in discovering, defining, and delivering solutions.  People who regularly deal with high-level tradeoffs for new products and services should attend as well.

What You Will Get

In addition, each participant will get:

  • A PDF of workshop slides
  • An invitation to a post-workshop virtual conference call for additional Q & A and coaching


Wednesday — Workshop Day 2



Software, Faster

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

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



Getting Started with Serverless Architectures

javascript serverless aws lambda cloud
WHEN:
Wednesday 9:00 - 17:00
WHERE:

This is a practical workshop for developers and architects that want to take advantage of the latest trends in cloud computing: serverless apps and cloud functions. Through hands-on exercises and teamwork, you’ll learn about using AWS Lambda and API Gateway to create responsive event-driven micro-services, auto-scaling web APIs, and high-performance web sites. By the end of the workshop, you will create a useful real-world serverless application, exploring the typical architectural patterns.

Serverless platforms significantly reduce the cost of running high-performance web sites and API services in the cloud, but with a major impact on architecture, these services also require teams to re-think how to approach sessions, storage, authorization and testing.

The author of the workshop is Gojko Adzic, a key contributor to Claudia.js, a popular open-source deployment tool for AWS Lambda.

Learn how to:

  • Use AWS Lambda and API Gateway
  • Managing sessions and state with serverless architectures
  • Start converting monolithic applications to cloud functions
  • Use Amazon Serverless Application Model (SAM) and Claudia.js to deploy Lambda functions
  • Design scalable, high-performance web sites with single-page apps backed by cloud APIs
  • Identify how serverless architecture impacts testing, monitoring and deployments

Participant prerequisites

  • Working knowledge of JavaScript. The tools and techniques you’ll learn about will apply for any programming language, but the coding examples will be in JavaScript/Node.js to keep things simple and make it easy for everyone to follow regardless of their primary platform. You don’t need expert level knowledge of JavaScript, but you should be comfortable writing simple functions and flows. You don’t need prior experience with AWS services, but this would definitely be useful.
  • An Amazon Web Services account (free tier accounts are also OK, you can register at https://aws.amazon.com)
  • Bring your own laptop, we'll be coding all the time



Paradigms Lost, Paradigms Regained

programming paradigms OO functional programming programming languages
WHEN:
Wednesday 9:00 - 17:00
WHERE:

It is very easy to get stuck in one way of doing things. This is as true of programming as it is of life. Although a programming paradigm represents a set of stylistic choices, it is much more than this: a paradigm also represents a way of thinking. Having only way to think about problems is too limiting. A programming paradigm represents a set of patterns of problem framing and solving and contains the ingredients of software architecture. As Émile Auguste Chartier noted, there is nothing more dangerous than an idea when you have only one idea.

Perhaps even more problematic than being stuck with a narrow view of paradigms, is being stuck with a dysfunctional view of each paradigm. For instance, many developers working in languages and frameworks that support object orientation lack a strong idea of the principles of interaction, data abstraction and granularity that support an effective view of OO, and instead surround themselves with manager objects, singletons and DTOs.

During the day we will explore the character and style of different programming styles, patterns, paradigms, languages, etc., with examples and opportunity for discussion.



Tips from Psychology for Problem-solving

Thinking Problem-solving Working environment Decision-making Cognitive neuroscience
WHEN:
Wednesday 9:00 - 17:00
WHERE:

Unfortunately, those of us who struggle with complex problems for a living don't have time to keep up with the enormous amount of cognitive science research that could help us become better thinkers, better problem solvers, and better decision makers. Having devoted more than ten years to researching the fast-moving fields that almost daily reveal new information, Linda shares what she has uncovered—some of it surprising, some even counterintuitive. She summarizes the research and provides concrete tips for improving your individual, team, and organizational abilities. Most of us sit all day, believing that concentrating without moving, in a room with no natural light, drinking too much caffeine, after our usual night of less than six hours of sleep is the way to get work done. Linda offers ways to incorporate movement, take a break, change focus, brighten our environments, think better, and be happier. Learn the latest tips for boosting your problem-solving power.



High-Performance Messaging with Aeron

Messaging Performance Networking
WHEN:
Wednesday 9:00 - 17:00
WHERE:

In this workshop you will learn how to build microservices with Aeron (https://github.com/real-logic/aeron) and SBE (https://github.com/real-logic/simple-binary-encoding) 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, recorded, clustered, etc.
  • Flow control and congestion control strategies – When and how to use them.
  • Customising channel endpoints for extending Aeron, e.g. testing loss scenarios.
  • How to build a non-blocking microservice using a single thread.
Delegates need a laptop with Java 8 installed and be comfortable with hands on coding.



Intro to the Menlo way

Joy Innovation Collaboration
WHEN:
Wednesday 9:00 - 17:00
WHERE:

Experience Menlo’s joyful workplace and methodologies that support our collaborative and innovative business culture. This workshop includes stories recounting Menlo's earliest days and how Menlo has evolved. During the workshop you will learn how we use visual management, what our different team roles and responsibilities are, how we use pairing, and more. This one-day overview of Menlo’s internal process is a great introduction to Menlo's history and culture and how you can apply these things inside of your organization.



Building Great Teams: Culture and Core Protocols

leadership team teams culture high-performance positive bias autonomy freedom self-awareness connection interactive deep dive team building continuous teaming culture design agile extreme teaming refactoring
WHEN:
Wednesday 9:00 - 17:00
WHERE:

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?
  1. My projects are completed effortlessly on schedule and in budget every time.
  2. Every team I’ve ever been on has shared a vision.
  3. In meetings, we only ever do what will get results.
  4. No one blames “management," or anyone else, if they don’t get what they want.
  5. Everybody shares their best ideas right away.
  6. Ideas are immediately unanimously approved, improved, or rejected by the team.
  7. Action on approved ideas begins immediately.
  8. 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



Designing Microservices

WITH Sam Newman
microservices
WHEN:
Wednesday 9:00 - 17:00
WHERE:

There is lots of theory out there about microservice architecture, but how often do you get to put that knowledge into practice? It's not feasible to re-architect your real system often, and certainly not in a single day, or is it? This brand new workshop from the author of Building Microservices gives you a safe space to explore ideas behind microservice architectures with peers from other organisations.

In this workshop, we'll share some framing for micro service architectures that explore the various forces that can drive the design and evolution of microservices, and then you'll participate in a series of interactive architectural kata exercises to put your new found knowledge to the test. Afterwards, you'll have a series of tools to take back to your own organisations to put into practice.

This workshop will cover

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

Audience

People who are in the process of moving to micro services, or are already on the path should get a lot out of the event. It's primarily aimed at people in technical leadership positions like tech leads and architects, but should be of use to any developer or operations person interested in how to move to microservices. Prior knowledge of service oriented architectures generally or microservices specifically is useful, but by no means essential.

Attendee Requirements

This is a participatory workshop. You won't get to just sit there and watch - the more you participate in the workshop, the more you'll get out!



High-Performance Java Persistence

Java Hibernate JPA JDBC SQL RDBMS
WHEN:
Wednesday 9:00 - 17:00
WHERE:

Based on my book, High-Performance Java Persistence, this workshop is meant to mind the gap between Java developers and Database programming. 

Most often, Java developers are very skilled when it comes to programming languages, design patterns, frameworks and everything that's related to their programming language of choice. However, the database is still uncharted territory, usually treated as a black box that we throw queries at and expect it to respond in no time. With this training, I want to get Java developers get to know more about RDBMS so that they can design their application data access layer accordingly.

In this workshop, we are going through various data access performance optimizations that are relevant for a great variety of Java Persistence frameworks.

Therefore, we are going to discuss:
  1. The best way to do database schema migrations. 
  2. Effective JDBC logging.
  3. How to assert the automatically generated SQL statements during testing.
  4. How to monitor database connection usage and provision connection pools.
  5. How to use JDBC batching and speed up write operations.
  6. How to use Statement caching efficiently to speed up read operations.
  7. Fetching best practices.
All in all, after attending this workshop, you'll know all sorts of tips that you can readily apply to your current enterprise project.

As prerequisites, you need a laptop, Java 1.8, Maven, PostgreSQL, and an Internet connection.

I've done this workshop both on-site and as a conference workshop (e.g. Voxxed Days Zurich), and I got very good feedback in return.



Resilient Software Design in theory and practice

Resilience Distributed Systems Software Design Communication Paradigms Patterns Best Practices
WHEN:
Wednesday 9:00 - 17:00
WHERE:

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.

This workshop will address those questions in three parts:
* In the first part you will learn about the challenges how to design applications in a resilient way, get an overview about the resilience pattern landscape, learn some of the most important patterns and when to apply them.
* In the second part 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.
* In the last part we will complete the workshop with a peek in some complementing topics, like some advanced patterns, a resilient design cycle and how to introduce the topic into the software development process.

After this workshop, you will have a much deeper understanding how to design solutions that satisfy your specific robustness needs.



Software Security Bootcamp: Architect's Edition

WITH Susan Sons
Security Refactor Code Triage
WHEN:
Wednesday 9:00 - 17:00
WHERE:

This day-long workshop will provide practical instruction in six essential activities that every security-conscious software engineer, software architect, and software project manager should know:

  • Code Triage, Code Rescue -- Take on a new, complex code base and rapidly find out where the biggest burning issues are, then make and execute a plan to untangle them.
  • Building and Maintaining Security Programs  -- Build security into the development process in a way that enables the production of great software, rather than inhibits it.
  • Security Culture 101 -- How to get an organization on board with secure software development practices, from the top down and bottom up.
  • Distribution Logistics -- How many vulnerable points exist in the chain between your developers and consumers, where malicious software could be injected into your trusted product?
  • Communicating Security -- How to get credit for your security accomplishments, and how to keep security expectations clear and reasonable within and outside the team.
  • Vulnerability Response Without Losing Your Mind -- Take a first responder's approach to fixing software vulnerabilities: get it done right and fast, without destroying your people or your code base along the way.

Preparing For the Workshop

  • Attendees should have experience developing software as part of a team, in any programming language.
  • Attendees should understand spoken and written English.
  • Bring a note-taking medium of choice.
  • You may also want a laptop or tablet to reference web resources during the workshop.

What to Expect

We won't get very deep into any particular code base: this is a completely programming language neutral presentation. We'll be focused on the process of producing secure and reliable code: what your team needs and what they need to do. The workshop is a combination of lecture, Q&A, and some planning and communication activities.

You'll  receive, included with the workshop, some print and digital reference material to help you put what you've learned into action.



Integrating Machine Learning into iOS Apps

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

Apple released the Core ML framework in iOS11, making it simple to integrate machine learning models into your app. In this workshop, you will learn the lifecycle of training, deploying, and evaluating a machine learning model for making on device predictions.

Predictions that have traditionally been made server side can now be made locally - offering unique advantages to the user, such as more data privacy and lower latency. Hardware improvements targeted for performing machine learning tasks (iPhone X’s A11 chip), industry standard models optimized for mobile (MobileNets), and many more recent developments signal that machine learning on mobile is part of the new path forward.

Target Audience:
• Experience building iOS apps in Swift
No previous machine learning experience necessary.


What we will cover:
• Brief overview of ML terminology, tasks, and common algorithms
• Typical end-to-end machine learning pipeline and where your iOS app fits into it
• Identifying areas of your app that could be helped with machine learning & clearly defining the problem(s) to be modeled
• Acquiring a suitable dataset
• Training a machine learning model using Apple’s 
Turi Create open source training framework
• Deploying the trained model to Core ML
• Integrating the Core ML model into your app to make predictions on device.
• Using Core ML in combination with Vision when performing computer vision tasks
• Evaluating the performance of your machine learning model



Advanced Go

WITH Mark Bates
go golang
WHEN:
Wednesday 9:00 - 17:00
WHERE:

Advanced Go Workshop


You've been writing Go now for a few months and you want to take things to the next level, this Advanced Go workshop will get you there. In this workshop we will skip the language basics and dive into the topics that all Go developers need to know about when writing production level Go applications.

In this one day Advanced Go workshop we will cover the following topics:

  • Profiling and Benchmarking
  • Debugging Applications with Delve
  • Understanding context.Context
  • Using Reflection
  • Working with Databases
  • Advanced Testing Techniques
Along the way we'll learn lots of great little tips, tricks, and other hidden gems about Go.

Who is this workshop for?

  • You have a solid handle on the foundations of the Go langauge
  • You are proficient with using the command line tools for your chosen platform
  • You want to take your Go applications to the next level of performance and stability



Exploratory testing

Exploratory Testing
WHEN:
Wednesday 9:00 - 17:00
WHERE:

This one day tutorial is for both testers and developers wanting to perform Exploratory Testing as part of their approach to software testing. It teaches exploratory testing and how to apply it in a systematic and deliberate way. Learn how it use it to add depth to your testing by focusing on risk and understanding business value.

 

This class is experiential and contains practical exercises to help gain a basic exploratory testing skills.

The workshop will focus on the following aspects of Exploratory Testing:

  • Heuristics in Exploratory Testing

  • Models in Exploratory Testing

  • Exploratory Testing Strategy

  • Oracles & bug finding

  • Reporting to others

You will learn:

  • How to find bugs important bugs rapidly

  • How to find bugs without test cases

  • How to describe your testing to other people without using test case metrics

This tutorial requires a laptop, please bring one.




Cynefin Workshop for Agile Teams

Leadership Teamwork Strategy Decision Making Agile Portfolio Mgmt Organizational Development Autonomy
WHEN:
Wednesday 9:00 - 17:00
WHERE:

Have you ever wondered why some Agile concepts work well in one context and fail in others? 

This workshop helps Agile practitioners and leaders at every level understand why different methods and practices work across various contexts. A primary reason for the success of Agile is because it’s methods, practices, and values are effective heuristics. Heuristics are anything that provide a plausible aid or direction in the solution of a problem. All heuristics work by exploiting the structure of an environment, so heuristics work well in some environments and less well (or not at all) in others. For example, Kanban works better than Scrum in certain environments (e.g. support teams managing help tickets and defects). Agile practitioners need to understand why and where certain methods and practices work - and where they don’t - in order to adopt, tailor, use, and improve them. One framework to help practitioners make sense of this is Cynefin. 

Cynefin is a sense-making framework that enables organizations to make sense of their world in order to take appropriate action. Agile teams can use the framework to select heuristics appropriate for the situation at hand. Taking a situational-based approach increases the chances for successful adoptions and highlights areas where alternative methods may be need. Approaching Agile as a set of heuristics reduces the risk dogmatic approaches that are fairly pervasive in the community at large today (e.g. #NoEstimates, Scrum vs Kanban).

What You Will Learn

By the end of the workshop participants will:

  • be able to describe Agile as a set of heuristics
  • know how to apply Cynefin to improve Agile practices
  • understand how to us Cynefin to select heuristics that fit with situation at hand
  • experience and learn several practical techniques to break silo mentalities, disrupt entrenched thinking, and cope with cognitive limitations and bias such as
    • The Butterfly Stamped - a sense-making method for characterizing different situations
    • The Future Backwards - a method for scanning and contrasting perspectives that can be used for kicking off a new initiative, goal setting, release planning, & retrospectives
    • Safe-to-fail intervention design - a way to develop a portfolio of options to nudge dynamic and constantly evolving environments
    • Ritual Dissent - a method for disrupting cognitive bias through rapid iteration while creating a safe environment for critical feedback

Who Should Attend

This workshop is designed for leaders, Agile and Lean practitioners, Scrum Masters, Product Owners, Product Managers, Agile coaches, project managers, people managers, architects, designers, developers, devops, and anyone else that works in constantly-evolving and dynamic situations.  People who regularly deal with high-degrees of uncertainty and ambiguity should attend, as should those that have an interest in building organizations that are resilient, autonomous, and innovative.

What You Will Get

In addition, each participant will get:

  • A PDF of workshop slides
  • Access to Cynefin Slack channel to continue the conversation with the instructor and other participants after the training
  • An invitation to a post-workshop virtual conference call for additional Q & A and coaching



Scaling Organizations and Technology

scalability architecture devops organizational culture agile microservices
WHEN:
Wednesday 9:00 - 17:00
WHERE:

Overview

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 highly interactive workshop 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:

  • Scalable Organizations
  • Scalable Development Process
  • Scalable Architecture
  • Scalable Culture

You will leave with concrete recommendations you can use to start implementing improvements in your own technology organization.

Intended audience is engineering leaders – CTO, VP Engineering, Director of Engineering

Syllabus

 Module 1: Scalable Organizations
  • Small Teams
  • Specialty Skills
  • Organizational Growth
  • Global and Remote Teams

Module 2: Scalable Development Process

  • What to Build and What NOT to Build
  • Prioritization
  • Test-Driven Development
  • Technical Debt
  • Continuous Delivery
  • Experimentation

Module 3: Scalable Architecture

  • Architecture Evolution
  • Monoliths and Microservices
  • Incremental Evolution
  • Service Patterns and Anti-Patterns

Module 4: Scalable Culture

  • Collaboration and Decisionmaking
  • Learning Culture and Blameless Post-mortems


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.