Loading…
deliver:Agile 2018 has ended
Lone Star F/G [clear filter]
Monday, April 30
 

10:20 CDT

Mastering Legacy Code: Preventing Bugs in Code You Can't Test (Arlo Belshee)

Abstract:
"I can't test this code because the design is awful. I can't refactor because I don't have tests. Yet it keeps having (and breeding) bugs. Now what?"
--- Everyone, everywhere
I've talked in the past about how this apparent catch-22 is resolved by a better understanding of the word "refactoring" --- that using a specific set of techniques allows defect detection and prevention even in untested --- or untestable --- code. Now I'm going to show you those techniques by applying them to some gnarly code.
This session is 75% live-coding, 25% talking. Most of the talking will be me asking you questions. So come if you want to think, want to get your hands dirty, and want to see specifics that you can try to apply immediately in your own code.
Agenda:
  1. Microtesting: understanding what the code does and deriving a spec.
    1. Resolve microtesting blocker: mechanically spot CQRS violations; resolve them via extract method + make method static.
    2. Resolve microtesting blocker: mechanically spot multiple responsibilities in a class; resolve them via extract method + make method static + introduce parameter object.
  2. Safeguarding: preventing bugs by eliminating hazards.
    1. Remove hazard: primitive obsession leads to inconsistent computation; resolve it via introduce parameter object + extract method + move method.

Learning Outcomes:
  • See a new way to test, with best features of both a unit test and an acceptance test.
  • Observe that testing this way induces design pressure, and use that to guide your design.
  • Spot and address the 2 most-common design obstacles to testing.
  • Understand that defects are not spontaneous; they can be prevented by addressing hazards.
  • Spot and address the #2 bug-creation hazard (#1 is naming, and that is already well-addressed in other work).
  • Pick which habits to take home and learn by applying on your code.


Speakers
avatar for Arlo Belshee

Arlo Belshee

Team Craftsman, Legacy Code Mender, and Rabblerouser, Tableau Software
Arlo helps you change cultures in large organizations. He transitions hundreds or thousands of people at a time to full technical and cultural prowess in a way that sticks. More importantly, Arlo gives your company the ability to change its own culture. He seeks to be the last consultant... Read More →


Monday April 30, 2018 10:20 - 11:05 CDT
Lone Star F/G

11:15 CDT

Noisy Code: The SNR Conjecture (Tim Ottinger)

Abstract:
We will focus solely on how clearly and starkly code presents its intention: its Signal-to-Noise Ratio (SNR).
We will explore this one aspect as a potential replacement for other measures and heuristics of code quality.
When the meaning and mechanics of any passage (paragraph, function, or page) of source code are both apprehended easily, that code is
  • faster to skim
  • faster to read deeply
  • faster to improve
  • quickly identified or excluded as the site of a defect
Reaching that point of easy comprehension is trickier. Relying on catalogs of code smells and/or automated code quality metrics can leave a lot of room for misunderstanding:
  • One passage of code may strictly have low cyclomatic complexity, low line count, no constants, low operator density, and longer variable names but remain tricky to modify
  • Another passage can be terse, dense, and use short names but remain easy to understand and modify until the metrics system requires a developer to make it less dense and thereby less understandable.
Come see some examples of low-signal (or high-noise) software, in a "before and after" format, and let's discuss how and whether this one aspect makes code craft more learnable and teachable, and deepens your awareness of code quality.

Learning Outcomes:
  • Those in the room will learn a (perhaps) new way to consider their code, and to teach others to consider the code they write.
  • Attendees will focus on the essential nature of the code, and their ability to use code craft to cooperate with their IDEs for faster/safer coding.


Speakers
avatar for Tim Ottinger

Tim Ottinger

Anzeneer, Industrial Logic
Tim is a long-time programmer (since 1979), reviewer, speaker, writer. He has been active in many of the big changes in software over the past 36 years (including Design Patterns, Object-Oriented Design, and Agile software development). In addition to his contributions in "Clean... Read More →


Monday April 30, 2018 11:15 - 12:00 CDT
Lone Star F/G

13:30 CDT

Your First TDD (James Grenning)

Abstract:
You've heard about TDD but have never tried it or don't quite get it. The best way to get TDD is to try TDD with an experienced TDD practitioner. In this workshop, you will get a brief overview and demo of TDD, but way more. We will all practice TDD in a language of your choosing (C, C++, Java, C#, Python). Bring a laptop or a tablet with a keyboard. You can access my custom cyber-dojo.org server with your browser and begin doing TDD with no special tool setup. I'll set up a virtual pairing experience, I write the tests, you make them pass. You will know what TDD is after this session. Bring a friend!

Learning Outcomes:
  • Why is TDD important and what problems does it help with?
  • What is TDD?
  • Experience how TDD prevents defects.
  • Experience the cadence and small steps of TDD.
  • Experience right-sized unit tests.
  • Get your questions about TDD answered.


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 →


Monday April 30, 2018 13:30 - 15:00 CDT
Lone Star F/G

15:20 CDT

Unit Tests as Specifications (David Bernstein)

Abstract:
Test-driven development is a core practice of Extreme Programming (XP) and the “secret sauce” for some teams, enabling them to rapidly build quality code. But for other teams it’s an impediment that keeps them from refactoring code and increases their technical debt. TDD is supposed to help us refactor code safely but we often find that when we refactor our code we also have to change our tests, and what was supposed to add safety becomes a burden, requiring time and effort to keep tests up to date.
Writing good unit tests is a critical skill that developers need to master in order to get the most benefit from test-driven development. Tests must be unique, written at the right level of abstraction, and implementation-independent in order to be most valuable. When we understand how to use tests to articulate the behaviors we want to create, we can recognize the correct number and kind of tests needed to describe the behavior we want to build, putting every member of a team on the same page and building the right kind and number of tests that drive the creation of any behavior in the system. Our tests become a form of living specifications.
In this session, we’ll cover effective techniques for doing TDD that support building useful tests and quality code. You’ll learn how to instrument unit tests so they’re more readable and flexible. Instrumentation helps make a test’s intention clear and removes magic numbers from code.
You’ll also learn how to approach TDD in a way that yields the right number and kind of tests that allow you to refactor code later without breaking it. Working through a few code examples, we’ll see how many assertions are required to specify a linear range, exceptions, and other boundary conditions. We’ll look at how to write tests that don’t need to be changed when code is refactored while still keeping test coverage high.
If you’ve struggled to apply TDD on a project, or are just not sure how to start, then this session is for you.

Learning Outcomes:
  • Avoid the common pitfalls of doing TDD
  • Identify the minimal number of tests required to specify a behavior
  • Avoid writing implementation-dependent tests
  • Build test suites that acts as a safety net for refactoring
  • Instrument tests so they read more like specifications
  • Use unit tests to specify testable behaviors

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 →


Monday April 30, 2018 15:20 - 16:05 CDT
Lone Star F/G

16:15 CDT

True Tales of Antifragile Code (Rob Myers)

Abstract:
Have you ever abandoned an innovative user story because it was deemed too costly to implement?
Leaders of software development teams want to be able to adapt their existing product to innovative ideas and shifting market conditions. This is often the reason organizations "go Agile," yet this ability to flexibly deliver rich business value is often frustratingly out of reach.
Agile teams and their leadership are also familiar with the value of individual development practices. For example, they know that Test-Driven Development can "catch defects early." What Rob has found by working with a number of teams, each for six months or more, is another much greater--and more rare--source of business value resulting from diligent attention to software craftsmanship, and the resulting two-way trust that forms between Development and Product.
You will hear a few of surprising (but true) first-person tales, each detailing a time when changing market forces, dramatic pivots, disruptive technological changes, or insightful requests were delivered by the team within a single week. Each of these "Black Swan User Stories" (Rob's term for powerful, risky, and unforeseen user-stories) resulted in multiplying user productivity, opening whole new markets, or delighting and retaining critical customers.
Rob will then share the retrospective findings regarding those successes; and the great news that these are obtainable by any team willing to diligently apply a few core incremental and iterative technical practices. Your Agile team can realize the long-held expectations for the delivery of greater business value.

Learning Outcomes:
  • Hear real examples of how maintainable, high quality code is critical to the rapid completion of innovative user stories.
  • Explore the surprisingly direct path between Agile software development practices and business value.
  • Learn why leadership would want to encourage, support, and defend a team's dedication to the use of Agile technical practices such as Test-Driven Development.
  • Learn why an early commitment to diligent technical practices is crucial to product longevity and innovation.

Attachments:

Speakers
avatar for Rob Myers

Rob Myers

Principal Instructor & Coach, Agile Institute
Rob Myers has over 30 years of professional experience in software development, and has been coaching teams on TDD, Scrum, Lean, Agile, and XP practices since 1998. He has been delivering Agile-related talks and courses since 2002. His courses are always a blend of fun and practical... Read More →


Monday April 30, 2018 16:15 - 17:00 CDT
Lone Star F/G
 
Tuesday, May 1
 

10:20 CDT

Agile Schizophrenia: Consistent Agile is the Hobgoblin of Little Minds (Fred George)

Abstract:
Consistent Agile has one guarantee: Consistent failure, or mediocrity at best. Agile is no more a universal set of practices any more than Java (or Ruby or Fortran in my day) is a universal language, or Spring a universal framework, or Angular.js a universal UI tool.
In this talk, we will explore the behavioral purpose behind the practices, and assert that once the behavior is achieved, the practices serve as a barrier to success, or at a minimum, a barrier to further process innovation. Understand that these practices, radical in their time, were meant to break the chains of waterfall thinking. Unfortunately, these practices have too often become new, gilded chains.
We make two arguments for flexibility in team-to-team, project-to-project Agile practices. First, the type of problems we are solving today vary greatly. We will expound on that with Dave Snowden’s Cynefin framework.
Second, we will dissect several key Agile processes, making claims about the intended behavior for the practice. Once that behavior is achieved, the value of the process is largely gone, and sometimes even an inhibitor to further progress. As an Agile practitioner for nearly two decades, I will talk about my use and removal of these processes.
We briefly present several signs that your current Agile process is staid (ie, not Agile anymore!)
We wrap up by looking at a UK retailer, and how they have adopted different practices for different purposes.

Learning Outcomes:
  • The audience should understand rationale for various Agile practices, and the point at which the Agile practice becomes an inhibitor rather than facilitator. The material should also help justify new experiments in the processes in Agile teams in their companies.


Speakers
avatar for Fred George

Fred George

Founder, Fred George Consulting
Fred George is an industry consultant, and has been writing code for 50 years in (by his count) over 70 languages. He has delivered projects and products across his career, and in the last decade alone, has worked in the US, India, China, and the UK. He started ThoughtWorks University... Read More →


Tuesday May 1, 2018 10:20 - 11:05 CDT
Lone Star F/G

11:15 CDT

Refactoring with Cognitive Complexity (G. Ann Campbell)

Abstract:
For 40 years, cyclomatic complexity has been the de facto standard for measuring testability and maintainability. While it's absolutely accurate for testability, the same can't be said for maintainability. Cognitive complexity solves the problem and returns "fair" relative measurements of control flow complexity. In this session, you'll learn what the cognitive complexity methodology is and why you should add it to your metric suite. You’ll see how it applies to a number of code samples from open-source projects on SonarCloud.io. And you’ll learn how to use a method's cognitive complexity score as a guide to designing better code and refactoring existing code to be simpler and more maintainable. Because there's no "cost of entry" with Cognitive Complexity, a high cognitive complexity at the class level is a reliable indicator that a class contains a lot of logic, not just a lot of methods. That is, you can use cognitive complexity to sift POJOs from the logic-intense classes that impose a higher maintenance burden. Cognitive Complexity is available in most of the SonarQube ecosystem, but is an open standard, implementable by all.

Learning Outcomes:
  • Learn what Cognitive Complexity is (and why it's needed in addition to Cyclomatic Complexity)
  • Understand how Cognitive Complexity is assessed
  • See how Cognitive Complexity can be used as a guide to refactoring for simpler, more maintainable code

Attachments:

Speakers
avatar for G. Ann Campbell

G. Ann Campbell

Product Manager, SonarSource SA
G. Ann Campbell is a Product Manager at SonarSource SA, the company behind SonarQube, SonarLint, and SonarCloud. She has coded in Perl, C, and Java as well as the usual assortment of web development technologies. In the process, Ann has seen some good code and a lot of bad code. As... Read More →


Tuesday May 1, 2018 11:15 - 12:00 CDT
Lone Star F/G

13:30 CDT

UX for the Agile Developer (Eva PenzeyMoog)

Abstract:
Are you a developer who has found yourself making design decisions for the product you’re building? Many people find themselves in this situation, and often there’s no designer on the project to recruit users, get feedback, and design a solution.
This workshop will arm developers with the UX basics of quickly identifying user-friendly solutions for when you find yourself in the role of a defacto designer.
You’ll learn how to quickly test the people around you through setting up thoughtful 10 minute sessions and asking the right kinds of questions to identify a user-friendly solution.
This workshop is ideal for people from the development, product, and design world who are new to UX and interested in learning how to build user-friendly features though a quick and simple process that is easy to work into a fast-paced sprint.

Learning Outcomes:
  • Learn how to break out of round-about conversations with your client about how a feature should work.
  • Learn how to respond to your client saying “why don’t we just…”
  • Learn that user testing doesn’t have to be a long, painful process and how to get the insights you need from the people already around you in user testing sessions as short as 10 minutes.
  • Learn how to prepare for quick, high-impact user testing sessions.
  • Learn how to ask the right kind of questions and how to guide people to give you the most effective feedback.
  • Learn how to explain and defend the decisions you made based on user testing.


Speakers
EP

Eva PenzeyMoog

UX Designer, 8th Light


Tuesday May 1, 2018 13:30 - 15:00 CDT
Lone Star F/G

15:20 CDT

Enable your Agile Team with Continuous Delivery Pipelines (Esteban Garcia)

Abstract:
As your Agile team looks to shorten the cycle time from idea to production, it is important to give them the tools that will enable continuous feedback, collaboration with stakeholders, and most importantly, a way to get the product in front of the customer and enable a feedback loop.

This session will teach you how to create an effective release pipeline that incorporates Continuous Integration, automated testing, cloud deployment with Infrastructure as Code, Instrumentation, load testing, and more.

We will go from zero to Production in less than an hour and you will go back to work on Monday ready to deploy!

Learning Outcomes:
  • Continuous Integration
  • Continuous Deployment
  • Automation

Attachments:

Speakers

Tuesday May 1, 2018 15:20 - 16:50 CDT
Lone Star F/G
 
Wednesday, May 2
 

08:30 CDT

Continuous Delivery Patterns for Contemporary Architecture (Daniel Bryant)

Abstract:
Modern software has almost completed its evolution toward component-based architectures—seen in the mainstream embrace of self-contained systems (SCS), microservices, and serverless architecture. We all know the benefits of component-based architectures, but there are also many challenges to delivering such applications in a continuous, safe, and rapid fashion. Daniel Bryant shares a series of patterns to help you identify and implement solutions for continuous delivery of contemporary service-based architectures.

Learning Outcomes:
  • - Identify core stages in the component delivery lifecycle: Develop, test, deploy, operate, and observe
  • - How contemporary architectures impact continuous delivery and how to ensure that this is factored into the design
  • - Modifying the build pipeline to support testability and deployability of components (with a hat tip to Jez Humble’s and Dave Farley’s seminal work)
  • - Commonality between delivery of SCS, microservices, and serverless components
  • - Continuous delivery, service contracts, and end-to-end validation: The good, the bad, and the ugly
  • - Validating NFRs within a service pipeline
  • - Lessons learned in the trenches

Attachments:

Speakers
avatar for Daniel Bryant

Daniel Bryant

Independent Tech Consultant, Big Picture Tech
Daniel Bryant currently works as an independent technical consultant. His expertise focuses on ‘DevOps’ tooling, cloud/container platforms, and microservice implementations. Daniel is a Java Champion who contributes to several open source projects. He also writes for InfoQ, O’Reilly... Read More →


Wednesday May 2, 2018 08:30 - 09:15 CDT
Lone Star F/G

09:25 CDT

Need for Speed: Accelerate Automation Tests From 3 Hours to 3 Minutes (Emanuil Slavov)

Abstract:
All automated tests except unit are slow for today’s fast paced, first-to-marked environment. This is the elephant in the room that every Agile practitioner ignores. With slow automated tests you’re just shipping problems to production faster.
At Komfo, we had automated tests running for more than 3 hours every night. The execution time just kept growing unrestricted, and the tests were getting more unstable and unusable as a feedback loop. At one point the continuous integration build for the tests was red for more than 20 days in a row. Regression bugs started to appear undetected in production. We decided to stop this madness and after considerable effort and dedication, currently the same tests run for 3 minutes. This is the story of how we achieved nearly 60x faster tests.
This was accomplished by using Docker containers, hermetic servers, improved architecture, faster provisioning of test environments.
Running all your tests after every code change, in less than 5 minutes will be key differentiator from now on. In 5 years it will be a standard development practice, much like unit tests and CI are considered these days. Start your journey today.
Learn how to do this by applying four steps strategy:
Tests should create the data they need.
Use dedicated automation testing environment.
Simulate dependencies you don’t control.
Run in parallel and optimize.

Learning Outcomes:
  • Being able to execute all your tests after every code change, in less than 5 minutes will very soon be your competitive advantage.
  • Apply our proven four step strategy.
  • Avoid the common pitfalls we've identified on this journey.


Speakers

Wednesday May 2, 2018 09:25 - 10:10 CDT
Lone Star F/G

10:30 CDT

Beyond Waste: Exploratory Charters in Action (Claire Moss)

Abstract:
Think manual testing is waste? Think again! If you're not learning when you're testing, you're doing it wrong! People exploring systems can be your best defense against unknown problems and your greatest way of finding unexpected opportunities.
While automation is well adapted for repeating the same thing over and over again, human beings are great at doing things differently.
Doing is not enough! We need to think during our review and examination processes to improve outcomes. How do we design manual exploration to provide value in today's fast-moving development culture?
Come to this workshop for hands-on experience with the full lifecycle of exploratory testing charters.

Learning Outcomes:
  • Structuring manual exploratory testing for transparency
  • Charter guidance during test execution
  • Outcomes of exploratory testing
  • Value delivery through debrief of testing session

Attachments:

Speakers
avatar for Claire Moss

Claire Moss

Developer, Agilist, Tester, ScrumMaster, Product Owner, Agile coach, aclairefication
Agilist working as part of product development teams to support and accelerate development through fast feedback. I help teams to craft more executable user stories. Product backlog creator and groomer with emphasis on progressive elaboration. Front-end Javascript development, back-end... Read More →


Wednesday May 2, 2018 10:30 - 12:00 CDT
Lone Star F/G

13:30 CDT

Patterns of Iterative Architecture (Chris Gow, Declan Whelan)

Abstract:
In Agile you should start with the simplest thing that will give you value, and iteratively build on top of that. But how does that work with a Legacy Enterprise Application that everyone is terrified to touch? Or what if we need to build an application that handles millions of transactions a day? How can we make sure that our architecture will meet our needs two years from now, when we don’t know what the application will look like? And how does the process of architecture work in an Agile environment?
Join Chris and Declan in this interactive session, as they explore these topics. Learn architectural patterns that allow you to evolve your architecture. Examine techniques to help you work with legacy apps and dependencies. Learn how good architecture allows us to manage technical risk. See how business and technical people can work together to build an iterative plan for your product, both functionally and architecturally.

Learning Outcomes:
  • What is Evolutionary Architecture and why it is essential
  • How to balance evolvability with the other capabilities architecture provides
  • The factors that enable or limit the evolvability of an architecture
  • Patterns (and anti-patterns) for evolutionary architecture, in green-field and legacy systems


Speakers
avatar for Declan Whelan

Declan Whelan

Leanintuit
Helping organizations improve value steams and their organizational structure.


Wednesday May 2, 2018 13:30 - 14:15 CDT
Lone Star F/G
 
Filter sessions
Apply filters to sessions.