Dave Todaro
CEO at Ascendle
North Hampton, New Hampshire, United States
Dave Todaro is a software visionary, entrepreneur, and agile project management expert. Even from an early age, Dave had a knack for technology. At age 11, he wrote his first program. At age 13, he shipped his first worldwide-distributed product. And at 15, he started his first software company. Since then, he and his teams have designed and built award-winning products across a wide range of industries.
Dave has taught agile software development techniques to thousands of people around the world and regularly advises companies on a wide range of product strategy, project management, software engineering, and DevOps topics. He has appeared as a guest lecturer at institutions such as the University of New Hampshire and Boston College, and is a Master Instructor at Caltech.
Dave is the author of the bestselling book, The Epic Guide to Agile. His book has been adopted as an internal reference for multinational corporations and as a text for university classes.
Area of Expertise
Topics
Utilizing Git Flow for Agile Source Code Control
There are a few reasons a solid source code control strategy is a critical component of a successful Scrum team. Since the product must remain shippable at all times, the main codebase must be isolated from any changes that haven’t been fully tested. Multiple developers need to be able to work on different parts of the product at the same time. Finally, code changes must be reviewed in a structured manner before they are merged into the main codebase. Git Flow is a way to utilize Git source code control technology to support the real world of managing multiple production streams while keeping code properly isolated. This presentation will explain the fundamental concepts of this approach using step-by-step actionable instructions.
Writing User Stories: It's Not as Difficult as You Think
We used to write hundreds of pages of software documentation spelling out every detail of the system to be built. Every function point. Every possible usage scenario.
"The system shall do this..." and "The system shall do that..."
They were works of art.
The only problem? No one ever read them, and if they did, they quickly became obsolete as business conditions changed.
Today the foundation of the agile process is user stories, a lightweight technique to rapidly capture business requirements that gets the team on-vision and successfully delivering on stakeholder needs.
In this session, software engineering expert Dave Todaro will walk you step-by-step through the process of creating and managing user stories, both before a project begins as well as when the project is underway.
Key takeaways:
* Learn how to write an effective user story title and what three parts of the title you should always include.
* Understand how user stories are different and more effective than traditional software requirements specifications.
* Learn techniques to handle non-functional requirements, technical constraints, and business domain modeling in the user story world.
There's a Branch for That: Black-Belt Agile Source Control
Many teams have moved from legacy, centralized version control systems to distributed version control systems (DVCSs) such as Git. But those same teams often struggle with managing source code.
As the saying goes, with great power comes great responsibility, and DVCSs can make your life hell if branches are mismanaged.
Software development expert Dave Todaro explains key branch management techniques to keep things simple, while remaining flexible enough to handle the demands of a contemporary development team.
Key takeaways:
* Get a refresher on key concepts and features of distributed version control systems such as Git
* Discover the one key practice that makes branches easy to manage
* Learn how branch management strategies such as Git Flow can help your team be more agile
* Understand how branches provide an easy way to facilitate code reviews
* Find out the key techniques to avoid "merge hell" when it comes time to combine code from multiple branches
The Fundamentals of Continuous Integration
A solid test-driven development strategy is a great first step, but the team needs to know if a bug is introduced into code they’ve already written and tested. Although software engineers should be running all unit tests prior to committing any code changes to the source code repository, sometimes things slip through the cracks.
A continuous integration server automatically builds the latest code and runs all of the unit tests,
notifying the team if there were any failures. This session will explain the fundamental concepts of continuous integration, and talk through an example of how this works with one of the latest continuous integration tools: Bitbucket Pipelines.
Conducting Agile Code Reviews With Git Pull Requests
Although a solid test-driven development approach with comprehensive unit tests forms a good quality strategy, that doesn’t mean the code was written in a way that adheres to company coding and architecture standards. A manual code inspection is critical to maintaining consistency across the team and across the company, ensuring best practices are being followed, while permitting software engineers and technical leads to “cross-pollinate” among different teams to work with code that’s familiar. This presentation will walk through the key fundamentals of using pull requests to perform code reviews for all code changes before they are merged into the main codebase.
An Introduction to Git Source Control
Historically, centralized version control systems such as Subversion (SVN), CVS and Perforce have been utilized to manage source code. Over the last ten years, development teams have shifted to a more advanced model: distributed version control systems. The most popular tool of this type is Git. Distributed version control systems provide more speed, flexibility and power, and are a better fit for the fast-paced nature of a Scrum team.
This presentation will provide a history of Git, compares it to traditional centralized version control systems, and gets under the covers to outline how Git works from a technical perspective.
Agile Architecture and Technical Design
Back in the waterfall days, we knew exactly where architecture and technical design lived. It was right there on the waterfall diagram. We'd put our heads down for a couple of months and do the big design up front, figuring out all the details and making it perfect. Then coding began and...we ended up reworking most of the design.
Fast-forward to agile and architecture is gone! There is no "technical design phase" before coding begins.
But does that mean it's not important any more? How can that be?
Software development expert Dave Todaro explains how architecture shifts from an up-front activity to part of "doing a little of everything all the time."
Key takeaways:
* Learn the difference between waterfall, "Scrummerfall," and Scrum approaches to architecture and technical design
* Understand how the "last responsible moment" allows making architectural decisions at the perfect time
* Discover the five up-front decisions that still need to be made before coding begins
* See how a "walking skeleton" is leveraged to establish architectural patterns at the start of a project
* Know why inversion of power is a key concept to granting ownership to the Scrum development team
Agile Success Factors: Three Keys to Drive Your Software Development Goals
Agile principles are pretty straightforward. Keep a to-do list. Prioritize by business value. Work in short iterations. Frequently demonstrate working, usable software.
It sounds simple, but most companies struggle with getting the promised value from their agile transformation efforts. It’s likely they’re neglecting one of three critical success factors.
In this presentation Dave describes what you should see when agile is working well, and the three factors that are crucial to your success in meeting your software development goals.
You'll learn:
* The 3 most critical factors for a successful Scrum team
* How a well-tuned scrum team will deliver business value
* Keys to help teams become more empowered and take on true ownership for delivery
Domain Modeling: Visualizing the Information That Drives Your Software Application
With agile, gone are the days of 400-page specifications outlining every detail of the software application, only to have most of it change along the way. Today, we use lightweight user stories to capture high-level reminders and use interactive conversations to coordinate our work.
One challenge teams sometimes face with this approach is understanding the information within the application. If we’re building an online booking system, does everyone on the team understand Guests, Rooms, and Reservations, and how they’re related?
In this session, software development expert and author Dave Todaro will explain how a lightweight domain modeling process addresses this problem by allowing the team to visualize real-world entities and the relationships between them.
Key takeaways:
* How domain modeling brides the gap between the problem space and solution space
* Understanding who’s involved with domain modeling and the best time to do it
* Tools to support rapid domain modeling
* The elements of a clear domain model
* Multiple examples to understand the domain modeling concept
The Art of Thin Slicing: Build 100% of Something Instead of 100% of Nothing
Scrum promises teams will produce a usable product increment at the end of each sprint. This means designing, coding, testing, and having the product owner accept the work of the team, typically in two short weeks.
Most teams struggle with this process. Stories can quickly turn into layers–one for the back end and one for the front end–or product owners may get caught up in debates around what is truly "usable."
In this session, software development expert and agile author Dave Todaro will leverage a real-life example to explain how to leverage a variety of techniques to learn the art of thin slicing.
Key takeaways:
* Why it's so important to build the product in thin, vertical slices to avoid "building 100% of nothing"
* When epics and user stories are too large and need to be split
* The right time to perform the splitting process and who should be involved
* Two models you can lever for splitting stories
* Using the INVEST mnemonic to ensure the quality of your split stories
The Agile PMO: How the traditional project management office fits into the Agile landscape
Since 1939, when the term “project management office” was coined, PMOs have led the project management effort at companies large and small, driving the process and standards used to deliver business results. With the drive toward the use of Agile in recent years, many PMO executives wonder, “How do we fit in?” Some may even wonder, “Will we be viewed as less important to the organization?” or “Will we somehow be marginalized?”
The answer is, “Absolutely not!” Given the high reliance on a lightweight but disciplined project management framework such as Scrum, it’s critically important that there is a group of individuals in the organization who support not only the initial adoption of Scrum, but the continued adherence to its guideposts. Many companies fail to get results from Scrum not because the initial rollout, but because teams stop doing the handful of critical things that are needed to realize its benefits.
The contemporary PMO fills this role perfectly and plays a critically important role in leading Agile transformations. By filling the ScrumMaster role on project teams, the PMO can ensure both the adoption and continued usage of Scrum principles across the organization. Since the ScrumMaster is the “owner of the process,” the PMO can ensure that the discipline required to realize the potential of Scrum is sustained, and the Scrum process is adapted to the unique needs of the organization.
Key takeaways:
* Learn how the PMO is a critical part of the Agile Transformation.
* Understand how the traditional PMO fits into the agile organization.
* Understand a variety of ways the PMO can support agile teams throughout the organization
Leveraging a Minimum Viable Product to Speed Time to Market and Reduce Risk
Studies show that up to two-thirds of new software projects fail. One of the primary reasons for this high rate of failure is not truly understanding end user’s needs and doing one of the following:
* Building the wrong product - You create the wrong set of features that do not represent the primary needs of the user.
* Building a product that’s too big - You create a very large set of features that delays or prevents project completion, greatly increases development cost, and delays getting the product to market and opening the door to competitors.
How can you create a new product when you don’t truly know what your users need? The answer is the minimum viable product, or MVP.
By using the approach of developing an MVP, you greatly reduce the risk of project failure, get your product to market much faster, and learn what your users truly want for features.
In this webinar Dave Todaro and Tom Schwendler will explain why an MVP is so powerful, and tell you how to decide what should go in your MVP. They’ll also include some pointers for driving your MVP to completion.
Key takeaways:
* How you define what’s in the MVP
* How to set a deadline and budget for an MVP project
* Steps to take when you find your MVP project is off track
* How to manage MVP user expectations
* What happens after the MVP is done
Virtually Agile: 3 Key Scrum Success Factors for Your Work-From-Home Team
In today’s new world, working remotely has challenges not faced in the office environment and productivity can be reduced by a multitude of factors:
* Adjusting to remote work and new technologies, possibly for the first time. This includes finding a good space at home that is conducive to work and loads of conference calls: Your closet? Your car? Your spare bedroom?
* Distractions from personal demands, whether it's a spouse, kids, or caring for parents and grandparents.
* Other challenges that threaten the ability to work a typical 9 to 5 day.
When your team is co-located, communication and coordination come easy. But when employees are working in an entirely new world, how do you keep their productivity from falling off a cliff?
The good news is agile teams already have the tools they need to navigate these challenges and remain highly productive. They just need to leverage three critical success factors to drive a level of resiliency that can absorb and accommodate the new world they’re facing.
By embracing a handful of techniques, teams can leverage their collective capacity to drive the results of each sprint, to keep moving the company’s business objectives forward.
Key takeaways:
* The three tools that drive effective Scrum team communication.
* Tricks to leverage key Scrum ceremonies to set the team up for success.
* Bug management secrets to prevent the team from getting derailed.
* Coordination tips that accommodate offset working schedules.
T-Shaped Teams: How to Speed Throughput by Avoiding Over-Specialization
Traditional software development relied heavily on separate teams of specialists. The back end team. The front end team. The architecture team. The QA team. The deployment team.
That was a highly ineffective approach.
No single team was able to completely own and deliver a product into production, causing friction, inefficiency, and unpredictability.
Scrum turns this concept on its head, where each cross-functional team has all the skills required to create value every sprint. However, many teams still fall into the trap of over specialization. Back end developers can only work on the back end. Front end developers only the front end, and so on. But what happens when the business requires work that’s not evenly balanced between those disciplines?
The answer is “T-shaped teams,” where each team member has an area of deep expertise (the vertical part of the T), but also has general skills to contribute to the overall goal of shipping software (the horizontal part of the T).
In this session, software development expert and agile author Dave Todaro will talk about the pitfalls of over-specialization, and techniques to turn groups of specialists into high-performing, unified Scrum teams capable of high throughput, high quality, and high predictability.
Key takeaways:
* The dangers of over-specialization on a Scrum team
* Techniques to develop additional skills within the team
* Tricks to keep everyone productive--especially at the end of a sprint
* Slicing tips to avoid user stories that deliver no value to the user (front end stories, back end stories, etc.)
* How to deal with skepticism from your team members
Agile KPIs: What You Should (and Shouldn't) Measure
When adopting agile, many executives ask what can be a tricky question: "What numbers can we look at to tell if our team members are performing?" They want key performance indicators (KPIs) or objectives/key results (OKRs) to measure their software development organization.
Wanting to monitor results is a valid goal, but when done incorrectly it can fly in the face of an "empowered Scrum team." Measuring the wrong things can make team members feel "watched" and micro managed, leading to disastrous results.
In this session, software development expert and agile author Dave Todaro will talk about what you should measure--and what to avoid--to ensure you can understand how teams are performing, while supporting their empowerment.
Key takeaways:
* What metrics Scrum gives you "for free"
* Leveraging DORA and SPACE to gain insight
* Key techniques to ensure you can generate effective metrics
* How to educate management about agile metrics
* Caustic metrics to absolutely avoid
Essentials of Scrum
More than an agile process, Scrum forms the foundation of effective human collaboration toward a common result. In this session, Dave talks about agile theory at a high level then dives into Scrum theory, empirical Scrum pillars, and the roles, events, and artifacts that provide the moving parts. Finally, Dave discusses Inversion of Power and provides tips to help support the ownership and accountability that make Scrum teams shine.
Using Velocity for Good and Not Evil
Velocity -- the average number of story points completed each sprint -- gets a bad rap. Is it often misused? Yes. But does it still provide value? Absolutely. In this session Dave discusses the fundamentals of velocity and the value it provides, not only as a metric but as a tool for leverage the team's collective knowledge. He also talk about how to avoid a variety of pitfalls of velocity when used inappropriately.
Leveling Up: Selecting the Right Agile Scaling Framework
As you grow beyond one Scrum team, you can keep things organized for a while. As you add more teams, however, complexities multiply, and a scaling framework becomes more and more critical.
Today's most popular choice is the Scaled Agile Framework (SAFe), but there are others as well, including Large-Scale Scrum (LeSS), Scrum@Scale, Nexus, and more.
In this session, software development expert and agile author Dave Todaro provides a high-level overview and comparison between the leading frameworks, including the benefits and drawbacks of each.
He'll then dive into the decision-making process to help guide you toward the best framework for your unique challenges.
Key takeaways:
* An overview of the various agile scaling frameworks
* How the frameworks are similar, and how they differ
* How do decide which framework to choose
* How your scaling framework might change over time
* Critical success factors, regardless of which scaling framework you select
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top