Loading…
Agile2019 has ended

Sign up or log in to bookmark your favorites and sync them to your phone or calendar.

Dev Practices and Craft [clear filter]
Monday, August 5
 

10:45

One Architecture to Rule Them All: Why Hexagons are Awesome (Ted Young)

Abstract:
In this session, you'll learn the details of the Hexagonal architecture (aka "Ports & Adapters") and how it helps keep your code clean and well-tested. You'll find out how can scale from small microservices to much larger applications and how it's superior to traditional tiered and horizontally layered architectures.
You'll see how the core domain is easily augmented with RESTful APIs, a Web UI, database persistence, and calling out to external APIs. You'll learn how each part fits nicely into place in the Hexagonal architecture, yet are expendable when external needs change, without causing a major overhaul.
While this talk is full of multiple examples of working Java code (Spring Boot) that implements this architecture, it is directly applicable to other languages, such as PHP and JavaScript.

Learning Outcomes:
  • Learn why separation between the core and the adapters supports testability
  • Learn how adapters are identified and the difference between "primary" and "secondary" adapters
  • Understand the problems with vertically layered architectures
  • Know how to easily enforce the architecture constraints to keep code in the right place

Attachments:

Speakers

Monday August 5, 2019 10:45 - 12:00
National Harbor 6/7

14:00

Testing 1, 2, 3, ..., ...? (Wouter Lagerweij)

Abstract:
We talk about the Testing Pyramid, and it has helped move us away from the focus on end-to-end testing. But just ‘unit’, ‘component’, and ‘integration’ is not sufficient as a testing vocabulary.
In this talk I go through the different types of testing we need to apply to keep our increasingly extensive services landscape running smoothly. We’ll look at all the different parts of our code we need to test, what type of unit tests are applicable, how and where to test our APIs, and the APIs we depend upon, what exactly is an ‘acceptance test’, how to deal with multiple clients, multiple API versions and exactly when we have a need for a test environment. And how all these tests are parts of your continuous delivery pipeline.
All of this is shown as code written specifically for the purpose of the talk, so that we don’t get stuck in abstractions, but have concrete examples to show how it works.
The code will be available from github, including the pipeline and deployment setup, so you can take the learnings back to work and apply them immediately.

Learning Outcomes:
  • Realisation of how many different types and places thereare to do developer testing
  • Every Test Has A Specific Purpose
  • Test Where The Functionality Is

Attachments:

Speakers
avatar for Wouter Lagerweij

Wouter Lagerweij

Agile Coach
I love spending time with teams and organizations to figure out how to improve the way they make software, and make it more fun.To make that happen I use the knowledge and skills gathered in over ten years of experience applying Agile processes and practices from XP, Scrum, Kanban... Read More →


Monday August 5, 2019 14:00 - 15:15
Chesapeake J/K/L
 
Tuesday, August 6
 

14:00

Ground Rules for Sustainable Code Refactoring (Amr Noaman)
Limited Capacity seats available


Abstract:
Teams face many challenges to keep a sustainable and constant pace of refactoring. In many cases, this is due to oversight of some very basic guidelines and ground rules to enable a "refactoring-friendly" environment.
In this session, I'll build on my 10-year journey doing successful refactoring of poor code and present necessary ground rules and practical guidelines for enabling sustainable refactoring. I've clustered these guidelines into three high level categories:
  • Team development habits in maintaining old code
  • Enabling a configuration management environment
  • Making refactoring effort visible and trackable
Whether you're a technical person working on enhancing poor code or a manager sponsoring this activity, you'll walk away with a very good background information to enable a sustainable refactoring environment and eventually a high quality product code.

Learning Outcomes:
  • Explain key challenges to refactoring poor code
  • Learn about pre-requisites teams should take into consideration to enable sustainable and continuous refactoring
  • Understand how visibility can help sustain continuous refactoring

Attachments:

Speakers
avatar for Amr Noaman

Amr Noaman

Co-Founder & Principal Coach, Agile Academy
* Coach, consultant, and speaker passionate to propagate lean and agile thinking in the Middle East and North Africa* One of the drivers of Egypt's GoAgile program, transforming tens of teams and organizations from a wide range of private and public organizations. * Co-founder and... Read More →


Tuesday August 6, 2019 14:00 - 15:15
National Harbor 6/7

15:45

Automation as a Lofty Goal (Christopher Lucian)
Limited Capacity seats available


Abstract:
How many things in your work day can be automated that currently are not? 1%? 100%? Chances are that everything you do today can theoretically be automated. Of course this is an inflammatory argument. It is also likely that you have some low hanging fruit for automation that typically gets ignored. The funny thing about software development is that over time you automate all the stuff you did in the past. I don’t write HTML anymore, I write an HTML template, or generator. I don’t write generators anymore, I create a domain abstraction…. I don’t write domain abstractions anymore I write acceptance tests and an evolutionary algorithm writes the code for me. As I automate more and more of what I do, I get more and more time to automate more things. How do we gracefully transition into a future of automation? I believe we should be considering automation continuously, in this way we will be able to automate more and more things.
What about those of us who are content to repeat automatable tasks? It needs to be clear that the less we have to do day to day, the more effective we can be in the long run. In my career I have witnessed many developers who had thought their job was to do repetitive tasks to keep production up and running. We had automated everything they did and got back these developers.
I want to talk about today's options for automation in our craft and extrapolate to the future! Then I want to discuss automation as a lofty goal and how we can promote the need for automation of our automation on our teams with some practical technical examples.
As a developer you will learn new automation techniques as well as communication techniques for discussions around automation as a priority with management.
As a manager or director you will learn how automation as a team goal can increase your teams productivity continuously, and how to eliminate waste in your system to write software faster and with higher quality.

Learning Outcomes:
  • Practical implementations of Automation as a Habit
  • How to Implement a strict workflow that includes automation as a habit
  • How to Analyse the impact of a habit of automation on your process

Attachments:

Speakers
avatar for Christopher Lucian

Christopher Lucian

Director of Software Development, Hunter Industries
I'm Chris Lucian, the director of software development at hunter industries and a founder of mob programming. I am passionate about the advancement of machine learning and software craftsmanship. I seek the continuous improvement of myself, my family, my company, and my community... Read More →


Tuesday August 6, 2019 15:45 - 17:00
Chesapeake A/B/C

15:45

BDD, ATDD, TDD, DDD, DP, OOAD, ... If You’re D’d out, Try A Holistic Approach (Ken Pugh)
Limited Capacity filling up


Abstract:
Teams starting to become agile often get caught by the technical issues of software development. While stories may be completed initially, technical debt such as lack of cohesion, bad coupling, missing tests, and other issues slow things down. Test automation becomes harder and brittle for both internal units and external flows. Team members are not sure which of the techniques such as Behavior Driven Development, Acceptance Test Driven Development, Test Driven Development, Domain Driven Design, Design Patterns, Object Oriented Analysis/Design, or others will help them.
This session presents a holistic approach to discovering how these D’s relate to each other and how they can help you. We start by concentrating on the desired behavior and the context in which that behavior occurs. Next we explain how tests specify that the behavior is being implemented correctly and we recognize that all tests specify some behavior. We continue by illustrating how external behaviors that a user experiences are a combination of behaviors of the implementing components. We end up by showing how behavior of those components (microservices, classes, methods) can be specified in an implementation independent manner. Along the way, we’ll show how principles, such as separation of concerns and low coupling, apply in many aspects of development including defining behavior.
This interactive session is appropriate for anyone working on the creation of a software application – developers and testers. It’s aimed at newer agile teams, but any teams who are experiencing delivery issues may benefit.

Learning Outcomes:
  • Explain the different contexts of an application
  • Identify what are external and internal behaviors and how to specify them
  • Create a shared understanding of the behavior of business rules and domain terms
  • Minimize the amount of redundancy in tests and code

Attachments:

Speakers
avatar for Ken Pugh

Ken Pugh

Chief Consultant, Ken Pugh, Inc.
Ken Pugh helps companies evolve into lean-agile organizations through training and coaching. His special interests are in collaborating on requirements, delivering business value, and using lean principles to deliver high quality quickly. Ken trains, mentors, and testifies on technology... Read More →


Tuesday August 6, 2019 15:45 - 17:00
Chesapeake J/K/L
 
Wednesday, August 7
 

10:45

Agile Design Systems that Scale (Miriam Suzanne)
Limited Capacity seats available


Abstract:
Design Systems, style guides, and component libraries can be essential tools for software development – documenting the relationships between code and design. But design systems take work to build, and require regular upkeep. We don’t all have dedicated teams and budgets to build and maintain a centralized system. Working with an agile team on quickly-growing products, it's important to keep the design system flexible and iterative, continuously up-to-date with the product itself. How can we use meaningful code abstractions and automation to encourage design systems from the start? We'll look at both the human and code aspects of building and maintaining agile design systems that scale.

Learning Outcomes:
  • Understanding of design system goals, deliverables, and processes
  • Understanding abstractions that encourage pattern-making and low-touch documentation
  • Building a meaningful code architecture that supports automation
  • Examples of what we’ve done, where we’ve failed, and where we’re headed

Attachments:

Speakers
avatar for Miriam Suzanne

Miriam Suzanne

Founder, OddBird
Miriam is a co-founder at [OddBird](https://oddbird.net), with 15 years experience as a project manager, user-experience designer, and front-end architect. She is the creator of [Susy](http://oddbird.net/susy), [True](http://oddbird.net/true), and other popular open source tools... Read More →


Wednesday August 7, 2019 10:45 - 12:00
Chesapeake D/E/F

14:00

What I Learned About Software Development from Origami (Jonathan Turner)
Limited Capacity seats available


Abstract:
Origami is the art of paper folding. Software development is the process of putting together instructions for a computer in order to get the computer to perform some desired operation. At first glance origami and software development appear to have very little in common. One is very physical in nature. The other is almost completely digital. Is there anything that can be learned by comparing the two?
In this session we’ll talk about some of the parallels we can draw between origami and software development and some of the things about software development that can be learned from origami. This presentation is from a technical perspective, but anyone involved in the software development process can benefit. If you’re a fan of origami in the shape of unicorns, dragons, dinosaurs or popular Star Wars characters you should probably attend this session. Origami paper will be provided, and no previous origami experience is required.

Learning Outcomes:
  • Learn about the importance of good software development practices by comparing them to good origami practices.
  • Learn that good software development practices not only impact the quality of software, but also impact what software an individual or team is capable of creating.

Attachments:

Speakers
avatar for Jonathan Turner

Jonathan Turner

Software Craftsman, Pluralsight


Wednesday August 7, 2019 14:00 - 15:15
National Harbor 4/5

15:45

Software contracts or: how I learned to stop worrying and love releasing. (Seb Rose)
Limited Capacity seats available


Abstract:
The test automation pyramid suggests that we should favour unit and integration tests over end-to-end tests, which leads developers to use test doubles (fakes, stubs, mocks etc.). The risk is that the developer's test double does not behave in exactly the same way as the actual component that it is replacing. When this happens, the tests all pass in your build pipeline, but you get failures when it's released into an integration (or production) environment.
Contract testing is a technique that can give you confidence that your test doubles are accurately simulating the dependencies that they replace. This is not a new technique, but the extra investment in creating and maintaining (yet another) suite of tests has restricted its uptake. Instead, organizations mitigate the risks by investing in more and more integration environments and end-to-end tests. This was always expensive, but with the adoption of micro-service architectures across the industry, the cost and complexity has escalated to a point where this approach is no longer sustainable.
There is now an urgent need for organizations to revisit contract testing, with a specific focus on consumer driven contracts for micro-services. This need led to the creation of the Pact open source tool for HTTP based micro-services. The Pact project has created a multi-platform suite of tools that dramatically simplifies the adoption of contract testing.
In this session, you'll learn why contract testing is critically important, look at how you can incorporate contract testing in your development practices, and get an introduction to Pact.

Learning Outcomes:
  • Describe what contract testing is (using a high-level schematic of its operation) and how it enables teams to stick to the test automation pyramid
  • Implement contract testing from first principles without the use of frameworks (with an example in Java)
  • Demonstrate the challenges of continuous delivery for a family of integrated micro-services, and how consumer driven contracts can simplify matters
  • Show how PACT and PACT Broker can help teams adopt contract testing for HTTP-based micro-services, while acknowledging its limitations
  • Presentation History:

Attachments:

Speakers
avatar for Seb Rose

Seb Rose

BDD Advocate, SmartBear
Consultant, coach, trainer, analyst, and developer for over 30 years.Seb has been involved in the full development lifecycle with experience that ranges from Architecture to Support, from BASIC to Ruby. He’s a BDD Advocate with SmartBear, helping people integrate all three practices... Read More →


Wednesday August 7, 2019 15:45 - 17:00
Chesapeake 4/5/6
 
Thursday, August 8
 

10:45

Post-hoc systems architecture: an argument for microservices first for product development (Anastas Stoyanovksy)
Limited Capacity seats available


Abstract:
Common advice regarding microservice architectures is to begin with a monolithic application and then break it into microservices, such as per Martin Fowler’s observation of the difficulty of getting bounded contexts right from the outset. On the opposite side of the spectrum, others such as Stefan Tilkov make arguments for starting with a microservice architecture “to allow for fast, independent delivery of individual parts within a larger system.” We go one step further than Mr. Tilkov by proposing that it can be a good investment to start with a microservice architecture when long-term product design is not clear, in order to to be able to later identify business-critical components to merge and refactor into small, but highly maintainable monoliths while isolating low priority technical debt in non-critical microservices that require little to no maintenance. This approach aims to expedite initial release as much as possible, while both retaining development agility in response to customer feedback/usage and minimizing the long-term cost of strategic technical debt incurred along the way. We describe how this originally unintentional approach played out over two years for the information retrieval infrastructure of Watson Discovery Service and why we are now formalizing it.

Learning Outcomes:
  • A strategy for adopting a microservice architecture to enable agile product design
  • What pitfalls to avoid using this strategy

Attachments:


Thursday August 8, 2019 10:45 - 12:00
National Harbor 2

14:00

Challenge Everything! Using EventStorming to challenge your business and architecture too! (Alberto Brandolini)

Abstract:
The recipe is simple: put the key people in the same room, and have them model an entire line of business with events along a timeline. A bit of facilitation magic will allow your Big Picture EventStorming to discover gaps and challenge assumptions, enabling deeper collective learning about your domain.
But clarity and confidence are only the first steps. On a smaller scale, EventStorming can turn into a powerful process and software modeling tool; merging the contributions of business, service design, and software people into one coherent model, perfectly suited for modern event-driven architectures.

Learning Outcomes:
  • EventStorming fundamentals.
  • Different purposes and dynamics of the different EventStorming workshop recipes.
  • The special sauces that make it special.

Attachments:

Speakers
avatar for Alberto Brandolini

Alberto Brandolini

AUTHOR of EVENTSTORMING, Avanscoperta
Alberto Brandolini is a 360° consultant in the Information Technology field. Asserting that problems cannot be solved with the same mindset that originated them, Alberto switches perspective frequently assuming the architect, mentor, coach, manager or developer point of view.He’s... Read More →


Thursday August 8, 2019 14:00 - 15:15
Chesapeake 1/2/3

14:00

Patterns of Object Instantiation (David Bernstein)

Abstract:
One important difference between writing object-oriented software and writing procedural software is the notion of object construction. Objects must be instantiated before they can be used. This is much more than a technical detail, it is at the very core of OO's usefulness.
A key distinction—and therefore opportunity—of object-oriented programming over procedural programming is that objects have two phases in their lifecycle: creation and use. By separating these two phases so that certain kinds of tasks are done when an object is created, and other kinds of tasks are done later during usage, we can build software that’s more modular, independently verifiable, and extensible.
In this session, we’ll explore how you can leverage object instantiation to build more testable, decoupled, and maintainable systems. We’ll cover several common antipatterns in instantiation along with replacement patterns that drop the cost of ownership for software built in object-oriented languages such as Java, C Sharp, C++, etc.

Learning Outcomes:
  • Leverage object instantiation to write more decoupled and maintainable code
  • Use the object-oriented programming model to build maintainable software
  • Recognize and avoid instantiation anti-patterns that make code harder to extend
  • Apply instantiation patterns that improve software’s testability and extensibility
  • Know when to use factories to efficiently construct groups of objects that go together
  • Encapsulate object construction to gain the benefits of a factory without extra work

Attachments:

Speakers
avatar for David Bernstein

David Bernstein

Consultant, To Be Agile
David Scott Bernstein is the author of the new book _Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software._ It’s an insider’s view of the software industry drawn from his decades of hands-on experience as a software developer, trainer, and consultant... Read More →


Thursday August 8, 2019 14:00 - 15:15
Chesapeake A/B/C

15:45

Deep Stack - Tracer Bullets and ZOMBIES in a Green Field IoT Product (James Grenning)

Abstract:
A blank page can be very intimidating, even for a Test-driven developer. Where do we start? Write a test, right? Not always.
I've heard TDD learners say: "I don't know what my code needs to do, how can I write a test? I need to write some code first." I used to make a flippant reply to that, like: "You don't know what your code needs to do! How could you possibly start with the code! Tests describe what the code must do. How can you write the code if you don't know what the code is supposed to do?"
Sometimes, it's simply a matter of software with interface, boundaries and constraints understood or under your control. When it's simply a matter of software, take some guidance from ZOMBIES! Start with the simplest cases (Zero an One) to get the Interface in place, generalize (to Many) and then make sure the anticipated Exceptional and Boundary cases are all covered with Simple test scenarios. ZOMBIES can really help, except when they can't.
With my most recent green-field side-project, interacting with Commercial Off The Shelf hardware and software (COTS),I found that unknowns prevented me from writing tests. I totally get that helpless feeling (again) of not knowing what test to write! In Hexagonal Architecture (a.k.a. Ports and Adapters), we strive to separate the land where ZOMBIES rule and where we need something else. In the core of the hexagonal architecture, ZOMBIES rule, in the Adapters we need to discover what works.
In this session we'll look at how ZOMBIES help sneak up on the solution. In the adapters we need a DIRECT approach to Determine, discover and Isolate Risk, and Encapsulate Current Technology. DIRECT helps isolate and understand things out of our control.
In this talk we'll explore the challenges and risks developing a real-time water pressure measuring system. We'll look at how to get to a walking skeleton of the product together by discovering what is needed to get this stack of technologies elements working together:
  • Analog to digital converter (ADC)
  • Serial peripheral interface (SPI)
  • Micro-controller
  • IoT radio
  • IoT mesh network
  • Little Linux box
  • Web-server
  • JSON and javascript driven browser.
In a multi-layered system like this there are unknowns hide at every boundary. We'll look at how we address the unknowns DIRECTly, striving to get to where ZOMBIES can guide. Integration is considered from the beginning because that is where the risk is.
There are more risks than strictly technical risks. Business risk assessment will impact technical choices. If we can build it, will it be affordable and profitable? How do we track progress in the face of significant risk. We'll look at both the technical approach and how to keep progress and risk mitigation visible.

Learning Outcomes:
  • Practice identifying risks and how to mitigate them
  • Practice identifying where TDD should be used
  • Understand how a walking skeleton helps reduce risk
  • Understand using tracer bullets to directly address risks
  • Understand the Using cause and effect


Speakers
avatar for James Grenning

James Grenning

President, Engineer, Coach, ..., Wingman Software Consulting
James Grenning’s trains, coaches and consults worldwide. With decades of software development experience, both technical and managerial, James brings knowledge, skill, and creativity to software development teams and their management.  As his professional roots are in embedded... Read More →


Thursday August 8, 2019 15:45 - 17:00
Chesapeake J/K/L