Presentation given by Fadi Stephan from Kaizenko at AgileDC2018 on 10/15/2018 in Washington DC. Also see blog series on Managing Technical Debt at https://www.kaizenko.com/managing-technical-debt/
Is your team constantly missing delivery dates? Is the velocity decreasing from sprint to sprint while the development costs are rising? Are customers complaining about the increasing number of bugs and the long time it takes to add new features? These are all signs that you are mired in technical debt and probably on your way to bankruptcy or a complete system rewrite. Technical debt is inevitable, whether intentional or unintentional. However, not managing technical debt can paralyze your organization. Fadi Stephan expands on the technical debt metaphor and introduces a technical debt management plan that enables executives and teams to make prudent decisions on code quality and technical debt. Come learn how to measure the quality of your code base and determine the amount of your debt.
The technical debt metaphor is useful in capturing the long-term impacts of
tradeoffs taken during software maintenance between productivity (getting
something done sooner) and maintainability (degradation of the code's
quality over time). This webinar on Technical Debt will present
techniques and insights that help software engineers to identify and track
technical debt in their projects. We will outline how business and product
quality goals should affect the choice of approaches (and combinations of
approaches) for managing technical debt. More specifically, we will discuss
a set of automated approaches based on static code analysis that are likely
to spot problems in source code that have real impact on productivity and
defect proneness. Based on previous empirical studies, we will give further
advice on which types of debt can be found by these tools, and which types
are not yet detectable.
From Technical Debt to Technical HealthDeclan Whelan
Everyone agrees that technical debt is a burden on software innovation that we would rather avoid, and certainly clean up whenever possible. However, in most organizations, people don't prevent technical debt nearly as much as they should, and they don't ever get the time to clean it up. Why, then, if there are clear incentives to deal with technical debt, is it a rampant problem?
In this session, we will focus on how to deal with technical debt on several levels, including the individual developer, the team, the software value stream, and the larger organization. While technical debt may manifest itself in a developer's IDE, the problem starts long before the developer decides to copy and paste some code, or creates an overly-complex and under-documented class. The pressures on teams and individuals to take on more debt than they should come from many sources. Therefore, the solutions to the technical debt problem must extend beyond the team.
The Next Wave of Reliability EngineeringMichael Kehoe
In 2018, Site Reliability Engineering (SRE) will turn 15 years old. Since Google's inception of the term SRE, companies across the world have adopted a new operations mindset along with automation, deployment and monitoring principals. Most of what SRE does now is well established throughout the industry, so what is the next-wave of reliability principals and automation frameworks?
This session will dive into what the future holds for reliability engineering as a field and what will be the next areas of investment and improvement for reliability teams.
The technical debt metaphor is useful in capturing the long-term impacts of
tradeoffs taken during software maintenance between productivity (getting
something done sooner) and maintainability (degradation of the code's
quality over time). This webinar on Technical Debt will present
techniques and insights that help software engineers to identify and track
technical debt in their projects. We will outline how business and product
quality goals should affect the choice of approaches (and combinations of
approaches) for managing technical debt. More specifically, we will discuss
a set of automated approaches based on static code analysis that are likely
to spot problems in source code that have real impact on productivity and
defect proneness. Based on previous empirical studies, we will give further
advice on which types of debt can be found by these tools, and which types
are not yet detectable.
From Technical Debt to Technical HealthDeclan Whelan
Everyone agrees that technical debt is a burden on software innovation that we would rather avoid, and certainly clean up whenever possible. However, in most organizations, people don't prevent technical debt nearly as much as they should, and they don't ever get the time to clean it up. Why, then, if there are clear incentives to deal with technical debt, is it a rampant problem?
In this session, we will focus on how to deal with technical debt on several levels, including the individual developer, the team, the software value stream, and the larger organization. While technical debt may manifest itself in a developer's IDE, the problem starts long before the developer decides to copy and paste some code, or creates an overly-complex and under-documented class. The pressures on teams and individuals to take on more debt than they should come from many sources. Therefore, the solutions to the technical debt problem must extend beyond the team.
The Next Wave of Reliability EngineeringMichael Kehoe
In 2018, Site Reliability Engineering (SRE) will turn 15 years old. Since Google's inception of the term SRE, companies across the world have adopted a new operations mindset along with automation, deployment and monitoring principals. Most of what SRE does now is well established throughout the industry, so what is the next-wave of reliability principals and automation frameworks?
This session will dive into what the future holds for reliability engineering as a field and what will be the next areas of investment and improvement for reliability teams.
Project To Product: How we transitioned to product-aligned value streamsTasktop
The project to product movement is quickly gathering speed - a recent Gartner report found that 85% of respondents are shifting to a product-centric mentality. However, the complexity and uncertainty of software delivery at scale, coupled with the sheer number of people involved in the process, is too much for traditional project management techniques. Motivation is not enough to achieve a successful transformation—the product-centric model requires new skill sets, different investments and a change in culture.
What does the shift away from project-thinking really look like?
During this webinar, Tasktop VP of Product Development, Nicole Bryan, combines our own journey with the experience of working with our enterprise customers, to paint a clear picture of the cross-organizational challenges in store - and how you can address them by:
- Adopting a “customer-first” mindset
- Appointing a Product Value Stream Lead and a Product Manager
- Implementing the Flow Framework™ to align the language of IT with the language of the business
Copy and paste to access the full recording: http://www.castsoftware.com/news-events/event/gartner-technical-debt?gad=ss
-------------------------------------------------------
In this webinar David Norton of Gartner Research discusses recent findings on Technical Debt that estimates industry IT debt is at $500 billion—and on target to reach $1 trillion by 2015. He also talks about the importance of Software Analysis & Measurement to manage Technical Debt, how to measure debt continuously to control TCO of the application lifecycle and include debt measurement in project management and prioritization.
According to Google, SRE is what you get when you treat operations as if it’s a software problem. In this video, I briefly explain the term SRE (Site Reliability Engineering) and introduce key metrics for an SRE team SLI, SLO, and SLA.
Youtube Channel here: https://www.youtube.com/playlist?list=PLm_COkBtXzFq5uxmamT0tqXo-aKftLC1U
Customer case - Dynatrace Monitoring RedefinedMichel Duruel
One of the largest Airline in the world chose Dynatrace, here is the customer case.
Including:
Vision and Goal / Challenges / Requirements / Why Dynatrace is Unique / ROI and TCO / Rollout Status / Solution Screenshots
Dynatrace redefined monitoring with AI powered 3rd Generation APM, User Experience Monitoring & Continuous Improvement, Cloud-native, Full Stack, Auto Everything, End-to-End, Easiest to Implement, Use and Maintain
Presented by David Croley at ALN Houston.
Learn about technical debt (the good and bad kind), its impact on your ability to ship working product via game format.
“Technical debt” refers to any quality issues within the implementation of an IT solution that hampers your ability to work with or evolve that solution. Technical debt is often thought of as a source code problem, but it also occurs in your user interface design, in your data sources, in your network architecture, and in many other places. This presentation explores disciplined agile strategies to avoid technical debt in the first place, to remove existing technical debt, and how to fund the removal of technical debt. Industry data regarding technical debt will be shared.
The Lean Product Playbook provides specific, step-by-step guidance on how to apply Lean Startup ideas. In his talk, Dan describes an actionable model for product-market fit and a 6-step process that explains how to rapidly iterate based on customer feedback, illustrated with real world examples.
Key takeaways:
• Lean Startup principles.
• The Lean Product Process: a methodology for achieving product-market fit.
Case study on operating an Offshore Delivery Center (ODC)Oak Systems
A Case study on operating an Offshore Delivery Center (ODC). This ODC infrastructure and teams were specifically put together for a US based customer in the Industrial Automation space with a team size of 6 - 23 Engineers.
Everything You Need to Know About the 2019 DORA Accelerate State of DevOps Re...Red Gate Software
Each year, the DevOps Research and Assessment group (DORA) publishes critical research revealing the impact of DevOps on organizations of all sizes. The findings show what makes some teams successful at DevOps, while others fall behind.
Jez Humble, a founding member of DORA well known for his groundbreaking research on IT performance, and Redgate’s Microsoft MVP Steve Jones offer the latest insights from the 2019 Accelerate State of DevOps Report – and what they mean for your organization and career.
Would you like to be able to increase the adoption rate of your product? In this session, we will introduce you to cutting edge concepts and techniques to shift your product development process from output to outcome driven. We will combine elements of Lean Startup, Product Discovery, and Experiment Driven Development to accelerate learning to quickly build products customer love.
Technical Debt is a gap between Computer Science and Software Engineering. Common understanding of causes for the Technical Debt is centered on the careless software development choices for the sake of speed and expediency. However Technical Debt usually goes beyond just Technology. This presentation covers the origins of Technical and Product Debt, how to manage it and mitigate it
This talk was presented at AgileDC2018
Abstract:
Is your team constantly missing delivery dates? Is the velocity decreasing from sprint to sprint while the development costs are rising? Are customers complaining about the increasing number of bugs and the long time it takes to add new features? These are all signs that you are mired in technical debt and probably on your way to bankruptcy or a complete system rewrite. Technical debt is inevitable, whether intentional or unintentional. However, not managing technical debt can paralyze your organization. Fadi Stephan expands on the technical debt metaphor and introduces a technical debt management plan that enables executives and teams to make prudent decisions on code quality and technical debt. Come learn how to measure the quality of your code base and determine the amount of your debt.
Project To Product: How we transitioned to product-aligned value streamsTasktop
The project to product movement is quickly gathering speed - a recent Gartner report found that 85% of respondents are shifting to a product-centric mentality. However, the complexity and uncertainty of software delivery at scale, coupled with the sheer number of people involved in the process, is too much for traditional project management techniques. Motivation is not enough to achieve a successful transformation—the product-centric model requires new skill sets, different investments and a change in culture.
What does the shift away from project-thinking really look like?
During this webinar, Tasktop VP of Product Development, Nicole Bryan, combines our own journey with the experience of working with our enterprise customers, to paint a clear picture of the cross-organizational challenges in store - and how you can address them by:
- Adopting a “customer-first” mindset
- Appointing a Product Value Stream Lead and a Product Manager
- Implementing the Flow Framework™ to align the language of IT with the language of the business
Copy and paste to access the full recording: http://www.castsoftware.com/news-events/event/gartner-technical-debt?gad=ss
-------------------------------------------------------
In this webinar David Norton of Gartner Research discusses recent findings on Technical Debt that estimates industry IT debt is at $500 billion—and on target to reach $1 trillion by 2015. He also talks about the importance of Software Analysis & Measurement to manage Technical Debt, how to measure debt continuously to control TCO of the application lifecycle and include debt measurement in project management and prioritization.
According to Google, SRE is what you get when you treat operations as if it’s a software problem. In this video, I briefly explain the term SRE (Site Reliability Engineering) and introduce key metrics for an SRE team SLI, SLO, and SLA.
Youtube Channel here: https://www.youtube.com/playlist?list=PLm_COkBtXzFq5uxmamT0tqXo-aKftLC1U
Customer case - Dynatrace Monitoring RedefinedMichel Duruel
One of the largest Airline in the world chose Dynatrace, here is the customer case.
Including:
Vision and Goal / Challenges / Requirements / Why Dynatrace is Unique / ROI and TCO / Rollout Status / Solution Screenshots
Dynatrace redefined monitoring with AI powered 3rd Generation APM, User Experience Monitoring & Continuous Improvement, Cloud-native, Full Stack, Auto Everything, End-to-End, Easiest to Implement, Use and Maintain
Presented by David Croley at ALN Houston.
Learn about technical debt (the good and bad kind), its impact on your ability to ship working product via game format.
“Technical debt” refers to any quality issues within the implementation of an IT solution that hampers your ability to work with or evolve that solution. Technical debt is often thought of as a source code problem, but it also occurs in your user interface design, in your data sources, in your network architecture, and in many other places. This presentation explores disciplined agile strategies to avoid technical debt in the first place, to remove existing technical debt, and how to fund the removal of technical debt. Industry data regarding technical debt will be shared.
The Lean Product Playbook provides specific, step-by-step guidance on how to apply Lean Startup ideas. In his talk, Dan describes an actionable model for product-market fit and a 6-step process that explains how to rapidly iterate based on customer feedback, illustrated with real world examples.
Key takeaways:
• Lean Startup principles.
• The Lean Product Process: a methodology for achieving product-market fit.
Case study on operating an Offshore Delivery Center (ODC)Oak Systems
A Case study on operating an Offshore Delivery Center (ODC). This ODC infrastructure and teams were specifically put together for a US based customer in the Industrial Automation space with a team size of 6 - 23 Engineers.
Everything You Need to Know About the 2019 DORA Accelerate State of DevOps Re...Red Gate Software
Each year, the DevOps Research and Assessment group (DORA) publishes critical research revealing the impact of DevOps on organizations of all sizes. The findings show what makes some teams successful at DevOps, while others fall behind.
Jez Humble, a founding member of DORA well known for his groundbreaking research on IT performance, and Redgate’s Microsoft MVP Steve Jones offer the latest insights from the 2019 Accelerate State of DevOps Report – and what they mean for your organization and career.
Would you like to be able to increase the adoption rate of your product? In this session, we will introduce you to cutting edge concepts and techniques to shift your product development process from output to outcome driven. We will combine elements of Lean Startup, Product Discovery, and Experiment Driven Development to accelerate learning to quickly build products customer love.
Technical Debt is a gap between Computer Science and Software Engineering. Common understanding of causes for the Technical Debt is centered on the careless software development choices for the sake of speed and expediency. However Technical Debt usually goes beyond just Technology. This presentation covers the origins of Technical and Product Debt, how to manage it and mitigate it
This talk was presented at AgileDC2018
Abstract:
Is your team constantly missing delivery dates? Is the velocity decreasing from sprint to sprint while the development costs are rising? Are customers complaining about the increasing number of bugs and the long time it takes to add new features? These are all signs that you are mired in technical debt and probably on your way to bankruptcy or a complete system rewrite. Technical debt is inevitable, whether intentional or unintentional. However, not managing technical debt can paralyze your organization. Fadi Stephan expands on the technical debt metaphor and introduces a technical debt management plan that enables executives and teams to make prudent decisions on code quality and technical debt. Come learn how to measure the quality of your code base and determine the amount of your debt.
Pay Now or Pay More Every Day: Reduce Technical Debt Now!TechWell
Is your team missing delivery dates? Is your velocity inconsistent from sprint to sprint? Are customers complaining about defects or the time it takes to add new features? These are signs that you are mired in technical debt-a metaphor that describes the long-term costs of doing something in a quick and dirty way and not going back to clean up the mess. Fadi Stephan shares a technical debt management approach to help you make prudent decisions on how much effort to invest in reducing technical debt. Discover ways to measure the quality of your current code base and determine the cost of eventual rework hanging over your system. Learn how to engage executives and get buy-in on a debt removal plan that will improve system design, increase the quality of your code, and return your team to high productivity. If you are burdened with technical debt, the choice is to pay now or continue paying more every day-forever.
How to justify technical debt mitigations in Software EngineeringAndré Agostinho
In this presentation André Agostinho e Cassio Silva covers the importance in dealing with technical debt in software engineering showing the real impacts, daily approaches and best practices for mitigations
FWD50 Agile/ Lean Workshop Slides - November 1
Ottawa Ontario, Canada. Authors/Presenters: Dan MurphyGlenn Waters, Ellen Grove, Craig Szelestowski - Thanks Team
Technical Debt is a powerful metaphor for a clear and present risk in today's software development projects. At Torino Coding Society we've had a conversation about it, and experimented the outcome of improvement initiatives to tackle it.
How to deal with tech debt: Lessons learned from the best engineering teamsAlexandre Omeyer
Tech debt can be really overwhelming. Often when you start to address it, you realize you’re only just scratching the tip of the iceberg. It doesn’t have to be an insurmountable problem, understanding how to prioritize the right issues will enable you to turn the boat around.
Join us in hosting Alexandre Omeyer, CEO & Co-founder at Stepsize. For the first time he will be walking us through his incredible research, which includes interviews with 200+ software engineers.
In this webinar you will learn:
- How to define and understand tech debt.
- The tactics for dealing with tech debt head on.
- Implementing processes and tools to use when dealing with small, medium, and large pieces of tech debt.
- How to think and approach tech debt depending on your company’s stage, size, business priorities, and culture.
Watch the webinar on YouTube: https://www.youtube.com/watch?v=QnizCRe-sV8
Often as developers we are stuck evaluating only the negative artifacts of technical debt. However, what if we looked at the debt metaphor from the point-of-view of our business executives. Would we reach the same conclusions?
In this presentation, I demonstrate that technical debt is not always something to be avoided. In fact, when debt is incurred responsibly, it can become a powerful tool that improves the communication between stakeholders and technologists.
As we inspect this concept, I offer rules and guidelines for evaluating when debt is good and when it is toxic. Once we have a firm understanding of this framework, I present strategies for prudently measuring, paying, and using debt. At the end of the presentation, both developers and business stakeholders will gain a new vocabulary for describing project decisions that will maximize the collaboration between both teams.
What is Technical Debt? It doesn't have to be negative, but it does have to be carefully managed. Here is a quick run-down of best practice to approaching Technical Debt management.
One of the biggest challenges that are faced when marketers and their IT department work together is managing technical debt. By not taking the time to maintain clean coding and processes when working with your website and always choosing the "quick and dirty" way to get work done, it's easy to become less flexible and have your site performance suffer. Learn more about what technical debt is and ways to manage it efficiently. This presentation was given by Scott Mowery at a workshop during the 2015 Healthcare Internet Conference in Orlando, FL.
What is technical debt, really? How does it affect your software, and how can you practically measure it in time, money, and impact? This topic is often mysterious and covered in vagaries, and I'll remove much of that mystery stuff by providing clear, actionable ways in working toward technical health, from basics to advanced topics.
Create Success With Analytics: Living With Technical Debt - Balancing Quality...Aggregage
As a Product Manager, you probably have to deal with technical debt. Regularly. Whether you like it or not - because it can’t be avoided. Unexpected details pop up, as small as UX that needs clean-up, and as big as a previously unforeseen flaw in the infrastructure of a project. We have to accept that nobody gets away without some technical debt. And of course, the longer you take to deal with your technical debt, the more difficult it becomes to address fully.
Feeling frustrated? Fortunately, we can take a step back, gain clarity, and see how the decisions we make impact our technical debt. Then, we can make decisions about how we want to balance technical debt with other priorities. Are we willing to live with some level of technical debt in order to ship product and meet deadlines? Can we mitigate technical debt to get to an MVP faster?
Many UX designers struggle to work within a Scrum environment and see Scrum as a framework mainly for programmers. Working in time-boxed Sprints and delivering small pieces iteratively and incrementally might force designers to focus on a single story at a time. This in turn can lead to tunnel vision, losing focus of the big picture and resulting in a fragmented user experience. Come to this presentation to learn where design fits in Scrum and how to apply design principles in Agile environments and work effectively with Scrum teams to produce a great user experience.
One of the 12 principles of the Agile Manifesto states that “The best architecture, requirements, and designs emerge from self-organizing teams.” Why is that? And what exactly are self-organizing teams? How does a team become self-organizing? Teams that have always been used to command and control cannot suddenly become self-organizing overnight. Come to this session to learn what self-organizing really means. Understand the attributes of a self-organizing team and some of the challenges you face in getting your team there. Learn how to use the Self-Organizing Teams Canvas and appropriate delegation to find the right balance between team learning and team empowerment vs. control. Leave with tools and techniques to help you build and foster high-performing self-organizing teams.
Many Scrum teams still struggle with delivering a high-quality, fully tested, production-ready product increment at the end of each Sprint. These teams likely have a weak Definition of Done and still approach product development using more of a phased approach. The Definition of Done is an often misunderstood or overlooked concept in Scrum. Most teams don’t normally have one or confuse it with the Acceptance Criteria. In this session, we'll clarify the difference and gain a better understanding of how the Definition of Done has a direct impact on the quality of our product increment as well as the composition of our cross-functional team. Come to this session to learn more about the Definition of Done, practice creating one, use it to produce a product increment, and learn a new retrospective technique to regularly inspect and strengthen your Definition of Done to help you produce quality product increments.
Fadi Stephan presented on Agile metrics at the 2022 Global Scrum
Gathering
Abstract:
There are more to Agile metrics than velocity and burn-down charts. However, most Agile teams just focus on velocity and target story points which leads to managers misusing the metric and teams gaming the system. Velocity should stay within the team and there are other metrics that can be shared with others that are outside the team. These metrics provide a more holistic view of the project’s overall health. The Agile Dashboard collects such metrics and acts as an information radiator giving us real time project updates on value, performance, schedule, scope, cost, quality, and team spirit.
Come learn what to measure and for how long. Learn how to read warning signs and what corrective actions to take. Learn to setup your own Agile dashboard to arm yourself with the right information and make careful and constant adjustments to ensure forward and safe progress towards your final deliverable.
Check out the play list https://www.youtube.com/playlist?list=PL_PJn_AGUdkPd3II7p5pubozQqnkqpFo8
or read the blog post https://www.kaizenko.com/top-11-changes-in-the-updated-2020-scrum-guide/
In November 2020, a new updated version of the Scrum Guide was released by Jeff Sutherland and Ken Schwaber. Here are the most important updates to the 2020 Scrum Guide, why they were made, and the impact they might have.
Snowbird 2001 - A Behind the Scenes Look at the Writing of the Agile ManifestoKaizenko
Video along with presentation deck at https://www.kaizenko.com/a-behind-the-scenes-look-at-the-writing-of-the-agile-manifesto-by-fadi-stephan-at-the-dc-scrum-user-group-dcsug/
In February of 2021, the AgileReflect20 festival is celebrating 20 years since the writing of the Agile Manifesto in Snowbird, Utah.
Join the DC Scrum User Group as we kick-off the festival with a behind the scenes look at what happened at Snowbird back in 2001 during the writing of the Agile Manifesto. In addition to the skiing, hot tubs and beers, there were some passionate discussions on various light weight methods, approaches and techniques. Find out how the event came about, who initiated it and why, how the location was picked, what were the objectives and agenda coming into the event, who was there and why, who didn’t make it, what were some of the heated discussions that occurred, how the values and the principles came about, what was included and what was left out, and finally, looking back in retrospect, what would the authors want to change or add today?
Slides from the session "TDD - That Was Easy!" presented by Fadi Stephan from Kaizenko at AgileDC2019 on September 23, 2019 in Washington DC. A blog post accompanying this talk will be published soon on kaizenko.com
Abstract:
Have you tried TDD? Do you hate it? Do you have a hard time applying it in practice? Do you find it promoting bad design decisions because you must write micro tests instead of looking at the big picture? Are your tests tightly coupled to the implementation due to a lot of mocking making refactoring a pain? Do tons of tests break when a simple change is made? Do you have a hard time justifying all the time spent on writing tests vs. just focusing on development?
You are not alone. Every organization or team that I run into is supposedly Agile. Some are also applying agile engineering practices such as automated unit, integration and acceptance testing, etc… However, many struggle with TDD. TDD is hard, seems counter-intuitive and requires a lot of investment. Come to this session for a TDD reboot. We will look at the benefits of TDD, discuss the resistance to TDD and uncover some common difficulties along with misconceptions. We will address these misunderstandings and explore different approaches to making TDD easier. Leave with a fresh perspective and new insights on how to become better at TDD and apply it with ease
Slides from a session presented by Fadi Stephan from Kaizenko at the 2017 Global Scrum Gathering in San Diego, CA in May 2017. Also see the blog series on Fostering Self-Organizing Teams at https://www.kaizenko/fostering-self-organizing-teams
Abstract:
One of the 12 principles of the Agile manifesto states that “The best architecture, requirements, and designs emerge from self-organizing teams.” Why is that? and what exactly are self-organizing teams? How does a team become self-organizing? Teams that have always been used to command and control cannot suddenly become self-organizing overnight. Come to this session to learn what self-organizing really means. Understand the attributes of a self-organizing team and some of the challenges you face in getting your team there. Understand how to find the right balance between team learning and team empowerment vs. control? Leave with techniques to help you build and foster high performing self-organizing teams.
Slides from a session presented by Fadi Stephan from Kaizenko at the 2019 Global Scrum Gathering in Austin, TX on 05/20/2019 DC. Also see the blog series on Agile Testing at https://www.kaizenko.com/agile-testing/
Abstract:
Many teams struggle with fitting in testing activities inside of a Sprint. They end up doing primarily development activities in a Sprint and push testing activities to run in dedicated testing Sprints following the coding Sprints or have a coding and testing Sprint running in parallel. However, in Scrum, the output of every Sprint is a potentially shippable product increment. This means the product increment should be well tested within the Sprint and ready to be delivered. Come to this presentation to learn how to tackle testing on an Agile team, what kind of tests to execute, what to automate and what not to automate, the different test responsibilities, and when to run which tests. Leave with a testing strategy that you can start applying the next day to gradually get a team to start testing from day 1 of the Sprint and deliver a true product increment at the end of each Sprint.
Lean discovery, Agile Delivery, & a DevOps MindsetKaizenko
More and more organizations and teams are adopting Agile, however most stay focused on just the development part. They maintain a Big Upfront Requirements/Design (BRUF) phase and still have a long test and deployment phase. This approach results in more of a mini-waterfall approach rather than an Agile approach where we actually place valuable products in our customers’ hands. The old risks and pain points are still there: are we building the right thing? Is it valuable and usable? Does it work? So the true benefits of an Agile approach in terms of quality valuable products and higher ROI is never achieved due to our long cycles and slow feedback loops. Come to this session to see how Lean Discovery and Agile Delivery combined with a DevOps mindset, can make actual delivery of customer value sustainable. We will look at how Lean Discovery replaces BRUF and ensures the team is constantly building the right thing. We will also see how applying Agile Engineering practices ensure that the team is building the thing right and how a DevOps mindset ensures that the product the team builds actually gets delivered to the customer early and often.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
GridMate - End to end testing is a critical piece to ensure quality and avoid...ThomasParaiso2
End to end testing is a critical piece to ensure quality and avoid regressions. In this session, we share our journey building an E2E testing pipeline for GridMate components (LWC and Aura) using Cypress, JSForce, FakerJS…
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
zkStudyClub - Reef: Fast Succinct Non-Interactive Zero-Knowledge Regex ProofsAlex Pruden
This paper presents Reef, a system for generating publicly verifiable succinct non-interactive zero-knowledge proofs that a committed document matches or does not match a regular expression. We describe applications such as proving the strength of passwords, the provenance of email despite redactions, the validity of oblivious DNS queries, and the existence of mutations in DNA. Reef supports the Perl Compatible Regular Expression syntax, including wildcards, alternation, ranges, capture groups, Kleene star, negations, and lookarounds. Reef introduces a new type of automata, Skipping Alternating Finite Automata (SAFA), that skips irrelevant parts of a document when producing proofs without undermining soundness, and instantiates SAFA with a lookup argument. Our experimental evaluation confirms that Reef can generate proofs for documents with 32M characters; the proofs are small and cheap to verify (under a second).
Paper: https://eprint.iacr.org/2023/1886
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
3. While we wait for the session to start,
meet your neighbors and discuss …
• Do you think you are currently suffering from
technical debt?
• How do you know? What are the indications
that you are or are not?
4. @FadiStephan
Fadi Stephan
20+ years of experience in software development
Technology Consultant, Agile Coach and Trainer
Co-organizer of the DC Scrum User Group (DCSUG)
www.kaizenko.com @KaizenkoLLC
@FadiStephan
25. Technical Debt
“Shipping first time code is like going
into debt. A little debt speeds
development so long as it is paid back
promptly with a rewrite... The danger
occurs when the debt is not repaid.
Every minute spent on not-quite-right
code counts as interest on that debt.”
- Ward Cunningham
26. Technical Debt Metaphor
“Neglecting the design is like borrowing money”
“Refactoring, it's like paying off the principal debt”
“Developing slower because of this debt is like paying
interest on the loan”
“Every minute spent on not-quite-right code counts as
interest on that debt”
35. Types of Debt
• Unintentional
• Intentional
– Short term & focused
– Short term & unfocused
– Long term
• Only short term focused debt & long term
debt are “good” debt
forums.construx.com/blogs/stevemcc/archive/2007/11/01/technical-debt-2.aspx
55. Approach
• Have a technical debt reduction sprint
immediately after a release (better than nothing)
• Have a technical debt reduction sprint once we
reach a certain limit (better than nothing)
• Rotate dedicated members to work on reducing
technical debt (good)
• Dedicate 10% of each sprint to reducing technical
debt (better)
• Reduce technical debt by story (best)
59. Summary
Adapt by
1. Paying down the debt focusing on high
interest rate 1st.
2. Starting with what you know. Train for the
rest
3. Continuously monitor the debt
62. References
• Design Principles and Design Patterns - Robert Martin
• Design Stamina Hypothesis -
martinfowler.com/bliki/DesignStaminaHypothesis.html
• Technical Debt Quadrant -
martinfowler.com/bliki/TechnicalDebtQuadrant.html
• The Agile Triangle –
theagileexecutive.com/tag/the-agile-triangle/
• Technical Debt Assessment and Reduction –
theagileexecutive.com/category/technical-debt/
• Technical Debt, Cutter IT Journal October 2010 -
www.cutter.com
63. References
• Technical Debt A Perspective for Manager –
www.infoq.com/articles/technical-debt-levison
• Managing Technical Debt -
blogs.versionone.com/agile_management/2011/07/11/managing-technical-debt/
• What Testers Can Do About Technical Debt -
www.stickyminds.com/sitewide.asp?ObjectId=3629
• Climb Out of Technical Debt –
www.ayeconference.com/climboutoftechnicaldebt/
• Don't Live with Broken Windows–
www.artima.com/intv/fixit.html
64. References
• Technical Debt -
forums.construx.com/blogs/stevemcc/archive/2007/11/01/technical-debt-
2.aspx
• Sonar –
http://www.sonarsource.org/evaluate-your-technical-debt-with-sonar/
• Pay Down your Technical Debt –
www.codinghorror.com/blog/2009/02/paying-down-your-technical-debt.html
• SQALE Method For Evaluating Technical Debt –
http://www.sqale.org/wp-content/uploads/2012/04/SQALE-3RD-WS-on-MTD.pdf
Definition of done
Debt conversion
Probability of occurance
Heat maps
Agenda
About me
What’s going on?
Start a little slow
Quickly pick up - A lot of features are getting developed
Things start to slow down
Can’t seem to recover
These are signs of bad code and technical debt
Adding new features or simple changes take forever
Picture: http://www.flickr.com/photos/49531720@N00/247730111/
Delivery dates are missed
Picture: http://www.flickr.com/photos/89306448@N00/2247180420/
Team is frustrated
Morale is low
Picture: http://www.flickr.com/photos/16857236@N03/2429136239/
Customer is unhappy
Uncle Bob provides the following attributes of bad code:
Rigidity – difficult to change. A change causes a cascade of subsequent changes in dependent modules. Result -> manager fear to fix non critical problems because no reliability on impact and how long it will take. This lead to rigidity.
Fragility – closely related to rigidity. Software tends to break in many places every time it is changed. Even in areas that are conceptually unrelated. As this increases, software becomes impossible to maintain because every fix introduces 5 new bugs. This leads to distrust and a loss of credibility.
Developers end up playing whack-a-bug.
Picture: http://www.flickr.com/photos/tpapi/2765541278/
Immobility – inability to reuse software from other parts of the system. Need module similar to another one already written, however, module has too much baggage. It is hard and risky to separate desirable part from undesirable part so decide to rewrite instead of reuse.
Picture: http://www.flickr.com/photos/97041449@N00/5261698908/
Viscosity – design (when faced with a change, take easy way(hack) or hard way)
Environment-
If compile time is long, make changes that do not force large recompile
If check-in takes a long time, make as few check ins as possible
If deployment is difficult, make changes in database.
End up applying the easiest change to avoid environment issues even if change is in the wrong place.
Reasons for bad code:
Excuses about deadlines – no time to test, no time for design change
Broken Window Theory:
Police in NYC conducted a study
1. Parked a car in a bad neighborhood and observed
2. Nothing happened for a couple of days
3. Police broke small rear window and observed
4. Within 4 hours, car was stripped
Picture: http://www.flickr.com/photos/7389424@N05/2351559480/
Broken window theory also applies to code.
Start out and things are clean
Once you introduce one sign of bad code, things quickly get out of hand
As developers, we’ll say, well we are already doing things wrong here, so it does not matter if we do it wrong here as well.
Soon things spread and get out of control.
Picture: http://www.flickr.com/photos/17454738@N00/2245445147/
Over architecting:
Attempt to envision all possible future scenarios
Create unnecessary layers of complexity to support things that are not really requirements
Tempted to design solutions to problems in advance of their needs
Program goes in a different direction and code is written without benefit
Code doesn’t really fit need because written before problem well understood
Overdesign takes extra time and produces code that is either unused or doesn’t fit the needs of the project
Sometimes design is bad and instead of stopping to fix we continue building on top of it and create an even bigger mess.
Picture: http://www.flickr.com/photos/25196025@N00/381877979/
Poor skills or lack of proper training is also a major contributor
http://www.flickr.com/photos/25507200@N07/3120849218/
Technical debt by Ward Cunningham
Principal: Cost due to amount of time we need to code it the right way
Interest: Cost due to amount of extra time we spend to work with something not coded the right way
If it costs the same (no interest), it is just differed work and not technical debt
Jim Highsmith about technical debt in terms of impact on Cost of Change
We trade on quality daily. Have option to buy quality watch, but decide to buy cheaper one with out knowing what is inside. No visibility into internal quality.
Picture: http://www.flickr.com/photos/39516732@N08/4666623572/
Looks the same, and cheaper!
Picture: http://www.flickr.com/photos/64211362@N02/6338814898/
Martin Fowler about design stamina hypothesis:
Some benefit by ignoring good design
Soon productivity flattens out
Good design route starts out slower, but soon becomes almost linear
Intersection is design pay-off line
If above the line, no longer makes sense to ignore good design decision
Trick to know how far from line.
Martin estimates in most cases this is in magnitude of weeks not months or years
Is all technical debt bad?
Quick and dirty or clean? Which one would you choose?
It depends…
Not all technical debt is bad
Loans to buy a house or a car are generally considered good loans
We want to be responsible in our decisions
Martin Fowler introduces the technical debt quadrant:
1. Inadvertent/Reckless: Don’t know that they are doing something wrong
2. Deliberate/Reckless: Know it wrong and continue to do it
3. Deliberate/Prudent: Make conscious decision to take on debt due to specific business need
4. Inadvertent/Prudent: With the best of intentions, things did not go well (rare)
Most people are in quadrant 1 and 2 and we need to move them to 3.
There are good reasons to take on debt like a shorter time to market, preserving startup capital, delaying development expenses
Types of debt
Unintentional debt: careless mistakes, and honest mistakes (bad judgment) – never a good idea
Intentional debt – short term (focused and unfocused), long term
Only short focused and long term good debt
Flower shop website must be live 2 weeks before valentines day
Otherwise business will go under
Must take on debt to meet date
Will spend x weeks paying back debt while preparing for Mother’s day
Make prudent and deliberate decision on debt
Have plan to service debt
Make our payments
Avoid late payment notices
We don’t want to take on debt when we are behind schedule. This causes a vicious circle
If debt not paid back, business shuts down or application will require re-write
Picture: www.flickr.com/photos/66622362@N00/3353570653/
Step 1 - Register our debt
Add shortcuts decisions to technical debt backlog
Include estimated hours to do it the right way
Add date of estimate because only valid if paid off immediately
We want to try to determine
Cost of clean way
Cost of dirty way
Savings now
Impact (interest rate)
Cost of fix later
Beware of Broken Windows
Avoid debt that is untrackable
Avoid low ROI
We want to try to determine
Cost of clean way
Cost of dirty way
Savings now
Impact (interest rate)
Cost of fix later
Beware of Broken Windows
Avoid debt that is untrackable
Avoid low ROI
Step 2 – Evaluate existing code
Inspect and assess level of debt and also register it
Sonarqube
Various metrics with drill down capabilities
Various metrics with drill down capabilities
Step 3 - monetize the debt
1. Estimate the amount of hours it takes to fix each type of deficit
2. Multiply by rate/hr
3. Multiply by the total number of items
Technical debt plugin in Sonar calculates it this way
Another plugin is the SQALE metric (Software Quality Assessment based on Life Cycle Expectations)
that breaks things along characteristics (non functional requirements), sub characteristics, and source code requirements
Changeability -> loose coupling or related changeability -> code duplication
Maintainability -> understandability -> redundant throws or simplifying Boolean expressions, or unused variables
Security -> Errors -> preserving track trace, sql injection, or system.exit
Reliability - > unit test or exception handling -> unit test coverage, illegal throws
Testability -> unit level testability -> cyclomatic complexity
Efficiency -> memory usage -> correct data types or static final or string buffering
Portability -> software related portability -> imports, or locale
The method defines 4 key concepts:
1. The Quality Model: The SQALE Quality Model is used for formulating and organizing the non-functional requirements that relate to code quality. It is organized in three hierarchical levels. The first level is composed of characteristics, the second of sub-characteristics. The third level is composed of requirements that relate to the source code’s internal attributes. These requirements usually depend on the software context and language.
2. The Analysis Model: The SQALE Analysis Model contains on the one hand the rules that are used for normalizing the measures and the violations relating to the code, and on the other hand the rules for aggregating the normalized values.
3. The Indices: All indices represent costs. One represents the Technical Debt of the application. Others are used to analyze that debt.
4. The Indicators: The method defines three summarized indicators. They have been defined to provide a visual representation of the Technical Debt.
Example dashboard from sonarqube
Example dashboard from sonarqube
Costs can be customized for own environment
Future work:
Prioritization, based on impact.
Try to link cost vs. impact on business. Example, fixing non-initialized variable is low cost, however, it can cause large damage
With dollar amount associated with technical debt, we can engage upper management with a language they understand
Agile Triangle by Jim Highsmith
Technical debt triangle by Israel Gat
Step 4 – Establish debt limit
We can now have a conversation with the business in $$$ and talk about technical debt and the impact on ROI.
Today about 70% of an organizations IT budget is spent on maintenance instead of new development.
What is a good amount of debt?
It depends on appetite for risk.
Tension between business and tech
Biz optimistic about benefit and the cost of carrying the debt
Tech pessimistic about benefit and costs
Key is to manage and monitor it.
If reach certain threshold, then make major payments to get back on track and keep debt under control.
Credit rating: based on teams ability to avoid unintentional technical debt
Acquired debt: merger with other companies, decisions made by others
90 day same as cash: if you fix it quickly there will be no interest payment
Low monthly payment: web vs. embedded software – ability to payoff debt depends on type of software
Retiring debt: Once we retire system, there is no more debt. This is hard with financial debt
Deficit programming
Technical Inflation: Failing behind in versions to the point where the code is no longer compatible with the compiler
The key is that technical debt enables a conversation between the technical folks and the business folks to make informative decision on code quality
Step 5 – Pay down debt
Where do we start?
Use sonar to help you narrow down on problem areas
Tool gives us information on where to focus
Step 5a – Pay high interest debt 1st
Don’t quickly jump to fix most complex class. There are long term debt and short term debt. 1st reduce short term debt which is like credit card debt.
Short term debt has highest interest rate. Tackle 1st the classes that are constantly changing the most. The more changes we make the more interest we are paying.
Consider high minimum payment & required on going payment.
A class with no test coverage at all, or one that is very complex, but is never or rarely modified, needs to be left on the side for now and is considered as a low interest debt. Focus on the high interest 1st.
Picture: http://www.flickr.com/photos/23327787@N08/3027534098/
Picture: http://www.flickr.com/photos/37815348@N00/5398908333/
Step 5b – Pay down debt based on team skills
Does the team know how to write tests to increase code coverage?
Does the team know how to reduce complexity?
If not, come up with a training and coaching plan.
Does the team understand the rules they are violating? If so start their.
Do they know how to remove duplications?
It is going to depend, but the key is to put a plan and execute on it.
Also, don’t try to many things at once. This can be overwhelming.
Reduce debt while fixing bugs
Do not take on additional debt for new code
Picture: http://www.flickr.com/photos/51035555243@N01/155589939/
Approach:
Immediately after a release
10% of each iteration
Above certain threshold
Rotate individual
Research for this presentation based mainly on the work of Robert Martin, Steve McConnell, Israel Gat, Martin Fowler