This document discusses technical debt in software development and how open source development helps mitigate it. It defines technical debt as code maintained solely by one organization that deviates from the main development branch. Open source development helps reduce technical debt by unifying development efforts. The document outlines different types of technical debt and their causes, as well as strategies like contributing code to open source projects and aligning internal development with upstream projects to address technical debt at an organizational level.
Technical debt refers to the additional development work that arises due to poor quality code and system design decisions. This document provides a framework for calculating the costs of technical debt in order to optimize software delivery. It outlines that:
1) The average organization wastes 23-42% of development time on unplanned work like bugs and rework due to technical debt.
2) Technical debt cannot simply be fixed by hiring more developers since coordination costs increase exponentially with team size.
3) Organizations can establish a baseline for technical debt costs by calculating the percentage of work that is unplanned versus planned, with more than 15% indicating wasted capacity.
4) By addressing technical debt and related issues like process bottlenecks,
The document discusses technical debt in software development. Technical debt occurs when developers take shortcuts or make suboptimal design decisions to quickly deliver features. This debt accumulates interest over time as more changes are made, making the software harder to maintain. If left unchecked, technical debt can lead to "technical bankruptcy" where the cost of change becomes prohibitively high. Common causes of technical debt include schedule pressure, lack of skilled designers, and inadequate design principles and refactoring. Managing technical debt involves increasing awareness of it, detecting and repaying existing debt, and preventing further accumulation through monitoring and periodic repayment.
Software engineering is the application of engineering principles and methods to the development of software. It involves developing software products using well-defined scientific principles, methods, and procedures. The role of software has evolved significantly over the past 50 years from standalone programs to complex systems that deliver both information and control functions. Addressing the "software crisis" of the 1960s required treating software development as an engineering discipline with processes, documentation, and quality assurance rather than an art. Applying software engineering principles and practices was seen as a solution to issues like projects running over budget and schedule, producing inefficient and low-quality software that did not meet requirements.
What scrum masters and product owners should know about software quality and ...STX Next
The document discusses technical debt in software projects. It defines technical debt as compromises in quality or maintainability that accumulate when developers take shortcuts or make quick fixes rather than implementing clean code. Technical debt comes from decisions to cut corners, such as not refactoring code or thoroughly testing features. Over time, technical debt can lead to slower development, more bugs, and heavier testing needs.
The document recommends calculating technical debt through software metrics like code complexity, duplication, and test coverage. It also suggests effective ways to manage technical debt in agile projects, such as creating a technical debt backlog, educating stakeholders, automating tests, and conducting retrospectives to improve practices and prevent accumulating further debt. Regularly paying down
The document discusses Joint Application Development (JAD) methodology which involves taking users, executives, and developers off-site to work out project details. It also discusses the risks of scope creep, where additional features are added during a project. A good change order procedure is recommended to manage any scope changes, and should involve a written request and time to consider changes. Source code escrow is described as depositing source code with a neutral third party to protect a company if a developer goes bankrupt.
Restructuring Technical Debt - A Software and System Quality ApproachAdnan Masood
Agile Software Architecture based overview of the technical debt metaphor … idea is that developers sometimes accept compromises in a system in one dimension (e.g., modularity) to meet an urgent demand in some other dimension (e.g., a deadline), and that such compromises incur a "debt": on which "interest" has to be paid and which the "principal" should be repaid at some point for the long-term health of the project. (ACM)
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
The term ‘technical debt' and the challenges it can bring are becoming more widely understood and discussed by IT practitioners, vendor managers and business leaders. If you're looking at technical debt in your organization, or already thinking about measuring technical debt with your vendors, you will find this report useful.
Technical debt refers to the additional development work that arises due to poor quality code and system design decisions. This document provides a framework for calculating the costs of technical debt in order to optimize software delivery. It outlines that:
1) The average organization wastes 23-42% of development time on unplanned work like bugs and rework due to technical debt.
2) Technical debt cannot simply be fixed by hiring more developers since coordination costs increase exponentially with team size.
3) Organizations can establish a baseline for technical debt costs by calculating the percentage of work that is unplanned versus planned, with more than 15% indicating wasted capacity.
4) By addressing technical debt and related issues like process bottlenecks,
The document discusses technical debt in software development. Technical debt occurs when developers take shortcuts or make suboptimal design decisions to quickly deliver features. This debt accumulates interest over time as more changes are made, making the software harder to maintain. If left unchecked, technical debt can lead to "technical bankruptcy" where the cost of change becomes prohibitively high. Common causes of technical debt include schedule pressure, lack of skilled designers, and inadequate design principles and refactoring. Managing technical debt involves increasing awareness of it, detecting and repaying existing debt, and preventing further accumulation through monitoring and periodic repayment.
Software engineering is the application of engineering principles and methods to the development of software. It involves developing software products using well-defined scientific principles, methods, and procedures. The role of software has evolved significantly over the past 50 years from standalone programs to complex systems that deliver both information and control functions. Addressing the "software crisis" of the 1960s required treating software development as an engineering discipline with processes, documentation, and quality assurance rather than an art. Applying software engineering principles and practices was seen as a solution to issues like projects running over budget and schedule, producing inefficient and low-quality software that did not meet requirements.
What scrum masters and product owners should know about software quality and ...STX Next
The document discusses technical debt in software projects. It defines technical debt as compromises in quality or maintainability that accumulate when developers take shortcuts or make quick fixes rather than implementing clean code. Technical debt comes from decisions to cut corners, such as not refactoring code or thoroughly testing features. Over time, technical debt can lead to slower development, more bugs, and heavier testing needs.
The document recommends calculating technical debt through software metrics like code complexity, duplication, and test coverage. It also suggests effective ways to manage technical debt in agile projects, such as creating a technical debt backlog, educating stakeholders, automating tests, and conducting retrospectives to improve practices and prevent accumulating further debt. Regularly paying down
The document discusses Joint Application Development (JAD) methodology which involves taking users, executives, and developers off-site to work out project details. It also discusses the risks of scope creep, where additional features are added during a project. A good change order procedure is recommended to manage any scope changes, and should involve a written request and time to consider changes. Source code escrow is described as depositing source code with a neutral third party to protect a company if a developer goes bankrupt.
Restructuring Technical Debt - A Software and System Quality ApproachAdnan Masood
Agile Software Architecture based overview of the technical debt metaphor … idea is that developers sometimes accept compromises in a system in one dimension (e.g., modularity) to meet an urgent demand in some other dimension (e.g., a deadline), and that such compromises incur a "debt": on which "interest" has to be paid and which the "principal" should be repaid at some point for the long-term health of the project. (ACM)
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
The term ‘technical debt' and the challenges it can bring are becoming more widely understood and discussed by IT practitioners, vendor managers and business leaders. If you're looking at technical debt in your organization, or already thinking about measuring technical debt with your vendors, you will find this report useful.
This document discusses the importance of software modernization for companies still relying on legacy systems. It defines legacy software as older systems that are difficult to modify and maintain. While costly, software modernization is necessary to keep up with changing technology, ensure system stability, and reduce maintenance costs. The document recommends companies first assess their legacy systems to understand the risks of maintaining the status quo versus upgrading. Based on this assessment, companies can then develop a plan and deadline to modernize their systems incrementally in a controlled manner.
How To Manage And Reduce Development Techical DebtAbdul Khan
The document discusses managing development technical debt. It defines technical debt as imperfections in code that accumulate over time due to pressure to develop features quickly. It identifies different types of technical debt and their impacts, such as debt that affects teams, prevents business growth, or damages businesses. It provides recommendations for identifying, prioritizing, and reducing technical debt through refactoring code, updating technologies, and addressing issues based on their potential consequences. The overall message is that while some technical debt is inevitable, it needs to be managed carefully to avoid significant problems for products, teams, and businesses in the future.
Patterns for Success: Lessons Learned When Adopting Enterprise DevOpsCognizant
The document discusses common reasons for failure of DevOps initiatives in large enterprises and provides recommendations for successful adoption of DevOps. Some key reasons for failure include lack of a common definition, organizational resistance to change, cultural issues, technology complexity, divergent tools used, architectural differences, and existing technical debt. The document recommends addressing these issues by having a well-defined plan, executive support, stakeholder buy-in, dedicated roles to lead the effort, a phased approach using pilots, automation, and objective metrics to track progress. Following these patterns can help large organizations successfully adopt DevOps.
Rise of the Open Source Program Office for LinuxCon 2016Gil Yehuda
Open Source Program Offices collaborate on open source, policy, governance, and github to help developers improve successful outcomes for open source strategy. We describe why OSPOs are emerging, how they work, and what this means to the open source industry. We highlight a Linux Foundation sponsored collaboration called the TODOGroup where program office directors are meeting to coordinate efforts and ideas.
The presentation was delivered at LinuxCon and ContainerCon in Tokyo, Japan in July 2016.
DevOps aims to rapidly develop and deploy software applications through cross-company collaboration. While open source software allows for faster development, it can introduce legal, security and operational risks if not properly managed. The document proposes integrating continuous compliance checks into the DevOps process to proactively monitor for risks from open source components throughout development. This catches issues earlier and avoids delays from fixing problems found later through audits. It recommends pre-approving open source packages and monitoring components for policy compliance and vulnerabilities to balance rapid development with risk management.
No code the next big thing in supply chain technologyArpitGautam20
Traditional supply chain software relies on coding which makes it difficult and expensive to customize and implement new features. No-code platforms allow organizations to build customized supply chain solutions visually without coding by using tools like drag and drop. This simplifies and streamlines the configuration process. No-code allows for quicker testing and deployment of new supply chain applications and integrations. It puts stakeholders in control and allows organizations to more easily meet changing demands by quickly building and deploying new solutions.
How to save on software maintenance costsFrancisJansen
This document discusses ways to reduce software maintenance costs. It identifies several key drivers of high maintenance costs, including lack of documentation, complexity of code, volatility of requirements, and dispersed code changes. The document then presents six approaches to reducing costs: (1) creating or improving documentation, (2) eliminating dead code, (3) reducing cloned code, (4) avoiding and eliminating bugs, (5) focused testing on changed code only, and (6) reducing complexity. It advocates for an integrated approach called CARE (Computer Aided (Re)documentation & Evaluation) to systematically apply these cost-saving techniques.
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.
Uncovering Key Challenges in Offshore Software Development.pdfSiya Carla
Offshore development can be cost effective and provide access to global talent, but it also comes with some challenges. Let’s understand them here.
https://www.finoit.com/blog/key-challenges-in-offshore-development/
Interaction Room - Creating Space for Developments (Software Projects)adesso Turkey
The Interaction Room serves several purposes:
1) The focus on mission-critical aspects
2) Identification and elimination of risks associated with intuitive visualization methods at an early stage
3) Improving teamwork and the establishment of joint project responsibility between the IT and specialist departments.
The Interaction Room makes the relationships between processes, data and the application environment transparent and creates the basis for efficient decision-making processes. It is a method which steers the interest of those involved in the project’s progress and contributes to ensuring that all participants continuously work on the vision of the software that is being developed. The Interaction Room is not a theoretical concept but has proven itself in the business environment, as can be seen in successful projects in which the Interaction Room has already been used effectively.
Streaming Processes: Creating a Start-up Within a Big Corporate (Mohammad Sha...Executive Leaders Network
Presented at Executive Leaders Network CMO/DPO/CIO/CISO Event on October 06th.
"How Haleon have established a software-defined lifecycle that decreases the effort required for build and integration. Making new features, bug fixes, experiments, configuration changes always ready for deployment to a production environment."
Outsourcing product development introductionsuryauk
The document discusses outsourcing software product development. It defines key terms like outsourcing, offshoring, and offshoring. It also discusses reasons for outsourcing like increasing speed and reducing costs. The document provides frameworks for assessing an organization's readiness for outsourcing and determining what product development activities can be outsourced. It identifies common issues with outsourced projects like taking a "big bang" approach without proper preparation.
Wait for it: identifying “On-Hold” self-admitted technical debtRungrojMaipradit1
This document presents the results of a study analyzing how developers remove self-admitted technical debt (SATD) from five open source projects. The study found that 20-50% of SATD removals were accidental due to code being removed. It also found that only 8% of SATD removals were acknowledged in commit messages. While most SATD fixes required complex code changes, some were addressed with simpler changes like modifying method calls or conditionals. The study provides insights into how SATD is typically removed and patterns that may help recommend SATD solutions.
OSS - enterprise adoption strategy and governancePrabir Kr Sarkar
The document discusses open source software (OSS), including its benefits and risks. It covers four main parts:
1. What is OSS and its benefits, such as lower costs, access to source code, and continued innovation.
2. The risks of using OSS, including technical issues, regulatory compliance, security vulnerabilities, legal risks, and impacts to brand.
3. The need for an OSS strategy and policy to maximize benefits while minimizing risks. Critical policy elements are discussed.
4. The importance of governance to ensure effective OSS management, avoid legal issues, and address security and support challenges. Lack of governance can result in technical failures, security breaches and legal action.
A collection of slides that illustrate how to go about effectively managing technical debt on a software project. I used these slides during a demonstration at an internal demonstration on technical debt at Fuzz Productions.
I am Mohsin Ali Student of Sofware Engineering. Software Engineering Sir give us these slides to read and learn from it. And these Slides are very interesting for Sofware Eng Students.
The document discusses the importance of conducting thorough due diligence, including independent source code reviews, when venture capitalists and private equity firms invest in technology startups. It notes that source code reviews are crucial for identifying risks related to intellectual property, security, licensing, and software quality. The review process involves analyzing the source code to evaluate its structure, components from other sources, and adherence to the company's standards. This helps investors assess the overall quality and viability of the technology as well as the company seeking investment.
OpenMetadata Community Meeting - 5th June 2024OpenMetadata
The OpenMetadata Community Meeting was held on June 5th, 2024. In this meeting, we discussed about the data quality capabilities that are integrated with the Incident Manager, providing a complete solution to handle your data observability needs. Watch the end-to-end demo of the data quality features.
* How to run your own data quality framework
* What is the performance impact of running data quality frameworks
* How to run the test cases in your own ETL pipelines
* How the Incident Manager is integrated
* Get notified with alerts when test cases fail
Watch the meeting recording here - https://www.youtube.com/watch?v=UbNOje0kf6E
Takashi Kobayashi and Hironori Washizaki, "SWEBOK Guide and Future of SE Education," First International Symposium on the Future of Software Engineering (FUSE), June 3-6, 2024, Okinawa, Japan
More Related Content
Similar to TechnicalDebtandOpenSourceDevelopment_Whitepaper_062220.pdf
This document discusses the importance of software modernization for companies still relying on legacy systems. It defines legacy software as older systems that are difficult to modify and maintain. While costly, software modernization is necessary to keep up with changing technology, ensure system stability, and reduce maintenance costs. The document recommends companies first assess their legacy systems to understand the risks of maintaining the status quo versus upgrading. Based on this assessment, companies can then develop a plan and deadline to modernize their systems incrementally in a controlled manner.
How To Manage And Reduce Development Techical DebtAbdul Khan
The document discusses managing development technical debt. It defines technical debt as imperfections in code that accumulate over time due to pressure to develop features quickly. It identifies different types of technical debt and their impacts, such as debt that affects teams, prevents business growth, or damages businesses. It provides recommendations for identifying, prioritizing, and reducing technical debt through refactoring code, updating technologies, and addressing issues based on their potential consequences. The overall message is that while some technical debt is inevitable, it needs to be managed carefully to avoid significant problems for products, teams, and businesses in the future.
Patterns for Success: Lessons Learned When Adopting Enterprise DevOpsCognizant
The document discusses common reasons for failure of DevOps initiatives in large enterprises and provides recommendations for successful adoption of DevOps. Some key reasons for failure include lack of a common definition, organizational resistance to change, cultural issues, technology complexity, divergent tools used, architectural differences, and existing technical debt. The document recommends addressing these issues by having a well-defined plan, executive support, stakeholder buy-in, dedicated roles to lead the effort, a phased approach using pilots, automation, and objective metrics to track progress. Following these patterns can help large organizations successfully adopt DevOps.
Rise of the Open Source Program Office for LinuxCon 2016Gil Yehuda
Open Source Program Offices collaborate on open source, policy, governance, and github to help developers improve successful outcomes for open source strategy. We describe why OSPOs are emerging, how they work, and what this means to the open source industry. We highlight a Linux Foundation sponsored collaboration called the TODOGroup where program office directors are meeting to coordinate efforts and ideas.
The presentation was delivered at LinuxCon and ContainerCon in Tokyo, Japan in July 2016.
DevOps aims to rapidly develop and deploy software applications through cross-company collaboration. While open source software allows for faster development, it can introduce legal, security and operational risks if not properly managed. The document proposes integrating continuous compliance checks into the DevOps process to proactively monitor for risks from open source components throughout development. This catches issues earlier and avoids delays from fixing problems found later through audits. It recommends pre-approving open source packages and monitoring components for policy compliance and vulnerabilities to balance rapid development with risk management.
No code the next big thing in supply chain technologyArpitGautam20
Traditional supply chain software relies on coding which makes it difficult and expensive to customize and implement new features. No-code platforms allow organizations to build customized supply chain solutions visually without coding by using tools like drag and drop. This simplifies and streamlines the configuration process. No-code allows for quicker testing and deployment of new supply chain applications and integrations. It puts stakeholders in control and allows organizations to more easily meet changing demands by quickly building and deploying new solutions.
How to save on software maintenance costsFrancisJansen
This document discusses ways to reduce software maintenance costs. It identifies several key drivers of high maintenance costs, including lack of documentation, complexity of code, volatility of requirements, and dispersed code changes. The document then presents six approaches to reducing costs: (1) creating or improving documentation, (2) eliminating dead code, (3) reducing cloned code, (4) avoiding and eliminating bugs, (5) focused testing on changed code only, and (6) reducing complexity. It advocates for an integrated approach called CARE (Computer Aided (Re)documentation & Evaluation) to systematically apply these cost-saving techniques.
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.
Uncovering Key Challenges in Offshore Software Development.pdfSiya Carla
Offshore development can be cost effective and provide access to global talent, but it also comes with some challenges. Let’s understand them here.
https://www.finoit.com/blog/key-challenges-in-offshore-development/
Interaction Room - Creating Space for Developments (Software Projects)adesso Turkey
The Interaction Room serves several purposes:
1) The focus on mission-critical aspects
2) Identification and elimination of risks associated with intuitive visualization methods at an early stage
3) Improving teamwork and the establishment of joint project responsibility between the IT and specialist departments.
The Interaction Room makes the relationships between processes, data and the application environment transparent and creates the basis for efficient decision-making processes. It is a method which steers the interest of those involved in the project’s progress and contributes to ensuring that all participants continuously work on the vision of the software that is being developed. The Interaction Room is not a theoretical concept but has proven itself in the business environment, as can be seen in successful projects in which the Interaction Room has already been used effectively.
Streaming Processes: Creating a Start-up Within a Big Corporate (Mohammad Sha...Executive Leaders Network
Presented at Executive Leaders Network CMO/DPO/CIO/CISO Event on October 06th.
"How Haleon have established a software-defined lifecycle that decreases the effort required for build and integration. Making new features, bug fixes, experiments, configuration changes always ready for deployment to a production environment."
Outsourcing product development introductionsuryauk
The document discusses outsourcing software product development. It defines key terms like outsourcing, offshoring, and offshoring. It also discusses reasons for outsourcing like increasing speed and reducing costs. The document provides frameworks for assessing an organization's readiness for outsourcing and determining what product development activities can be outsourced. It identifies common issues with outsourced projects like taking a "big bang" approach without proper preparation.
Wait for it: identifying “On-Hold” self-admitted technical debtRungrojMaipradit1
This document presents the results of a study analyzing how developers remove self-admitted technical debt (SATD) from five open source projects. The study found that 20-50% of SATD removals were accidental due to code being removed. It also found that only 8% of SATD removals were acknowledged in commit messages. While most SATD fixes required complex code changes, some were addressed with simpler changes like modifying method calls or conditionals. The study provides insights into how SATD is typically removed and patterns that may help recommend SATD solutions.
OSS - enterprise adoption strategy and governancePrabir Kr Sarkar
The document discusses open source software (OSS), including its benefits and risks. It covers four main parts:
1. What is OSS and its benefits, such as lower costs, access to source code, and continued innovation.
2. The risks of using OSS, including technical issues, regulatory compliance, security vulnerabilities, legal risks, and impacts to brand.
3. The need for an OSS strategy and policy to maximize benefits while minimizing risks. Critical policy elements are discussed.
4. The importance of governance to ensure effective OSS management, avoid legal issues, and address security and support challenges. Lack of governance can result in technical failures, security breaches and legal action.
A collection of slides that illustrate how to go about effectively managing technical debt on a software project. I used these slides during a demonstration at an internal demonstration on technical debt at Fuzz Productions.
I am Mohsin Ali Student of Sofware Engineering. Software Engineering Sir give us these slides to read and learn from it. And these Slides are very interesting for Sofware Eng Students.
The document discusses the importance of conducting thorough due diligence, including independent source code reviews, when venture capitalists and private equity firms invest in technology startups. It notes that source code reviews are crucial for identifying risks related to intellectual property, security, licensing, and software quality. The review process involves analyzing the source code to evaluate its structure, components from other sources, and adherence to the company's standards. This helps investors assess the overall quality and viability of the technology as well as the company seeking investment.
Similar to TechnicalDebtandOpenSourceDevelopment_Whitepaper_062220.pdf (20)
OpenMetadata Community Meeting - 5th June 2024OpenMetadata
The OpenMetadata Community Meeting was held on June 5th, 2024. In this meeting, we discussed about the data quality capabilities that are integrated with the Incident Manager, providing a complete solution to handle your data observability needs. Watch the end-to-end demo of the data quality features.
* How to run your own data quality framework
* What is the performance impact of running data quality frameworks
* How to run the test cases in your own ETL pipelines
* How the Incident Manager is integrated
* Get notified with alerts when test cases fail
Watch the meeting recording here - https://www.youtube.com/watch?v=UbNOje0kf6E
Takashi Kobayashi and Hironori Washizaki, "SWEBOK Guide and Future of SE Education," First International Symposium on the Future of Software Engineering (FUSE), June 3-6, 2024, Okinawa, Japan
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
Need for Speed: Removing speed bumps from your Symfony projects ⚡️Łukasz Chruściel
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
Introducing Crescat - Event Management Software for Venues, Festivals and Eve...Crescat
Crescat is industry-trusted event management software, built by event professionals for event professionals. Founded in 2017, we have three key products tailored for the live event industry.
Crescat Event for concert promoters and event agencies. Crescat Venue for music venues, conference centers, wedding venues, concert halls and more. And Crescat Festival for festivals, conferences and complex events.
With a wide range of popular features such as event scheduling, shift management, volunteer and crew coordination, artist booking and much more, Crescat is designed for customisation and ease-of-use.
Over 125,000 events have been planned in Crescat and with hundreds of customers of all shapes and sizes, from boutique event agencies through to international concert promoters, Crescat is rigged for success. What's more, we highly value feedback from our users and we are constantly improving our software with updates, new features and improvements.
If you plan events, run a venue or produce festivals and you're looking for ways to make your life easier, then we have a solution for you. Try our software for free or schedule a no-obligation demo with one of our product specialists today at crescat.io
Neo4j - Product Vision and Knowledge Graphs - GraphSummit ParisNeo4j
Dr. Jesús Barrasa, Head of Solutions Architecture for EMEA, Neo4j
Découvrez les dernières innovations de Neo4j, et notamment les dernières intégrations cloud et les améliorations produits qui font de Neo4j un choix essentiel pour les développeurs qui créent des applications avec des données interconnectées et de l’IA générative.
UI5con 2024 - Boost Your Development Experience with UI5 Tooling ExtensionsPeter Muessig
The UI5 tooling is the development and build tooling of UI5. It is built in a modular and extensible way so that it can be easily extended by your needs. This session will showcase various tooling extensions which can boost your development experience by far so that you can really work offline, transpile your code in your project to use even newer versions of EcmaScript (than 2022 which is supported right now by the UI5 tooling), consume any npm package of your choice in your project, using different kind of proxies, and even stitching UI5 projects during development together to mimic your target environment.
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
Do you want Software for your Business? Visit Deuglo
Deuglo has top Software Developers in India. They are experts in software development and help design and create custom Software solutions.
Deuglo follows seven steps methods for delivering their services to their customers. They called it the Software development life cycle process (SDLC).
Requirement — Collecting the Requirements is the first Phase in the SSLC process.
Feasibility Study — after completing the requirement process they move to the design phase.
Design — in this phase, they start designing the software.
Coding — when designing is completed, the developers start coding for the software.
Testing — in this phase when the coding of the software is done the testing team will start testing.
Installation — after completion of testing, the application opens to the live server and launches!
Maintenance — after completing the software development, customers start using the software.
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
Zoom is a comprehensive platform designed to connect individuals and teams efficiently. With its user-friendly interface and powerful features, Zoom has become a go-to solution for virtual communication and collaboration. It offers a range of tools, including virtual meetings, team chat, VoIP phone systems, online whiteboards, and AI companions, to streamline workflows and enhance productivity.
Atelier - Innover avec l’IA Générative et les graphes de connaissancesNeo4j
Atelier - Innover avec l’IA Générative et les graphes de connaissances
Allez au-delà du battage médiatique autour de l’IA et découvrez des techniques pratiques pour utiliser l’IA de manière responsable à travers les données de votre organisation. Explorez comment utiliser les graphes de connaissances pour augmenter la précision, la transparence et la capacité d’explication dans les systèmes d’IA générative. Vous partirez avec une expérience pratique combinant les relations entre les données et les LLM pour apporter du contexte spécifique à votre domaine et améliorer votre raisonnement.
Amenez votre ordinateur portable et nous vous guiderons sur la mise en place de votre propre pile d’IA générative, en vous fournissant des exemples pratiques et codés pour démarrer en quelques minutes.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
1. Technical Debt
and Open Source
Development
A discussion towards a better understanding of technical
debt and how open source development helps mitigate it
By Ibrahim Haddad, Ph.D. & Cedric Bail, M.Sc.
A Publication of The Linux Foundation | July 2020
www.linuxfoundation.org
2. The Linux Foundation 2
Technical Debt and Open Source Development
Abstract
This paper grew out of a phone conversation the
authors had on a Sunday morning mid-March 2020
while being confined in their homes. Both authors
worked together within the Open Source Group at
Samsung Research and directly experienced minimizing
internally carried technical debt via working with
upstream open source projects. That experience
covered dozens of open source projects used across
multiple products and business units with varying
degrees of involvement and experience with upstream
development. The paper provides an overview of the
problem of technical debt at large scale. It includes
discussions on identifying technical debt, how to
minimize it, the role of open source development, and
strategies to address the issue.
Disclaimer
The opinions expressed in this paper are solely the
authors’ and do not necessarily represent their current
or past employers’ views. The authors would like to
apologize in advance for any error or omission and are
open to feedback and updates.
3. The Linux Foundation 3
Technical Debt and Open Source Development
Table of Contents
Technical Debt 4
Definition 4
Symptoms 4
Types of Technical Debt 4
Temporary Technical Debt 5
Unknown Technical Debt 5
Purposely Created Technical Debt 5
Obsolete Technical Debt 5
Organizational Technical Debt 5
The Many Causes of Technical Debt 5
Consequences 6
How does technical debt accumulate? 7
Working with Technical Debt 8
Identifying Technical Debt 8
Minimizing Technical Debt 8
Choice of programming language 8
Choice of ecosystem 9
Choice of dependencies 9
Example 1: The Role of Custom Build 10
Systems
Example 2: User Interface Framework 11
The Role of Upstream Development 12
Upstream - Unifier of Efforts 13
Addressing Technical Debt at Scale 14
At the Policy and Process Level 14
At the Development Level 14
Too late! Technical debt is already here. 15
What should we do?
Recommended Practices 16
Conclusion 17
Feedback 18
About the authors 18
4. The Linux Foundation 4
Technical Debt and Open Source Development
Technical Debt
Definition
Technical debt, a term used in software development,
refers to the cost of maintaining source code that was
caused by a deviation from the main branch where joint
development happens. A wider interpretation of what
constitutes technical debt is proprietary code by itself:
• It has been developed by a single organization.
• It is source code that the organization alone needs
to carry and maintain.
• In some cases, the organization depends on a
partner’s ability to maintain the code and carry that
said debt.
A noteworthy clarification is that upstream code is
not without technical debt when the upstream project
doesn’t have resources/time to maintain itself via its
developers’ community. An example of this scenario is
the various companies that depended on the OpenSSL
project without contributing to the project and realizing
that the project was maintained only by a single person
during their spare time. This was the specific case
scenario that motivated the Linux Foundation to launch
its Core Infrastructure Initiative to support open source
projects critical to our modern infrastructure.
Symptoms
How would you identify the symptoms pointing to
the existence of technical debt? And, what are these
symptoms? In this section, based on our experiences,
we list several such symptoms with a brief description
of each one of them. This is not intended as an exhaustive
and comprehensive list but rather a list of the most
common and widely observed technical debt symptoms.
• Slower release cadence Time increases between
the delivery of new features
• Increased onboarding time for new developers
Onboarding new developers becomes highly
involved due to code complexity where only
insider developers are familiar with the codebase.
The second manifestation of this symptom is the
difficulty in retaining developers or hiring new
developers.
• Increased security issues At least, experiencing
more security issues than the main upstream branch.
• Increased efforts to maintain the code base
Maintenance tasks become more time consuming
as the body of code to maintain becomes larger and
more complex.
• Misalignment with the upstream development
cycle illustrated in the inability to maintain pace,
be aligned, with the upstream development and
release cycles.
Types of Technical Debt
There are several types of technical debt. We are
not aware of a standardized or commonly agreed-upon
definition to describe these various technical debt
types. Therefore, in this section, we present our
interpretation.
5. The Linux Foundation 5
Technical Debt and Open Source Development
Temporary Technical Debt
A team may be working on a complex feature that possibly
touches several components, systems, or subsystems.
The need arises to carry out certain technical debt for
a temporary period as things get developed and integrated
with the upstream branch. We are aware of the fact that
we’re creating technical debt. However, our purpose is
to accelerate product development, and the end goal
is to repurpose and merge the fork with the upstream
branch at a later point.
Unknown Technical Debt
Unknowingly creating technical debt as a result of bad
engineering practices. An example of this scenario
is poorly-written code that is not accepted into the
upstream branch and is not even a candidate for
reusing somewhere else. We’re stuck with this code.
Purposely Created Technical Debt
This unusual type of technical debt is being created
on purpose. An example of such a case would be an
organization that wants to maintain certain features
exclusive to them without sharing them with the
broader community. As a result, such organizations find
themselves creating this fork to keep it independent
without merging it with the upstream branch. Over
time, such forks grow, leading to larger technical debt
and increased associated maintenance costs.
Obsolete Technical Debt
Obsolete technical debt is a unique use case of technical
debt resulting from the “not invented here” syndrome
or the result of isolated development of new components
that could have benefited the broader community.
However, due to a lack of technical oversight or
leadership, one organization only uses that development.
Simultaneously, the world moved on to solve the problem
and created a defacto solution (or a standard) that
is now incompatible with what the organization has
developed. This situation makes that development a
source of technical debt by obsolescence.
Organizational Technical Debt
It is widely discussed how the source code that an
enterprise creates often matches that enterprise’s
organization -- a very interesting theory. In some
cases, it so happens where code should be developed
and where it ends up being developed do not match.
When developers cannot push back on managers and
have the code written by the right people, or they can’t
contribute to the right piece of code, the result is often
a piece of duct tape on code that shouldn’t be there
and that nobody wants to deploy. This is technical debt.
The Many Causes of
Technical Debt
A large number of factors contribute to the creation
and growth of technical debt. In this section, we
explore the most common causes and provide a brief
description of each one.
• Low-quality code that can’t be upstreamed for
some reason, such as it doesn’t meet the code
quality criteria set by the target open source
project. Another manifestation of this factor is what
is commonly referred to as “spaghetti code.”
• Self-serving code that is only useful to the specific
company contributing the code without much use to
the general community. Such code (or functionality)
is usually not accepted upstream, and the recomm
endation is often to adjust it in such a way to benefit
general use cases and the wider number of users.
6. The Linux Foundation 6
Technical Debt and Open Source Development
• Fragmented development leading to duplicated
efforts and competing implementations
• Lack of effort to drive code upstream -- in many
cases, the team’s organization creating the code
does not have enough bandwidth to work with
the community and drive the code into being
accepted in the upstream branch. This may improve
effectiveness in the short term but creates technical
debt and long term negative consequences in code
maintenance and upkeep.
• Intrusive code that requires additional coordination
across multiple components or various systems/
subsystems.
• Time to get code accepted upstream that causes
temporary technical debt until the code is accepted
and merged in the upstream branch. It has no
adverse effect on the long term.
• Lack of testing preventing complete test coverage
and causing failure in submission.
• Lack of documentation or documentation that is
not up-to-date.
• Poor technical leadership and inadequate
engagement with the technical community lead to
being sidelined and having to, later on, play catch
up with the rest of the world as they move on.
• Ongoing change in requirements within the internal
development efforts in any given organization.
• Non-standard technology or lack of alignment with
a given standard.
• Organizational obliviousness that combines
the aspects of poor technical leadership and
unawareness of the technical direction of upstream
development. This scenario is increasingly
common in non-digital-native companies who are
increasingly forced into development work.
Consequences
Creating and carrying technical debt will have several
negative effects on development efforts, including:
• The higher cost of code maintenance.
• Slower innovation and development cycles.
• Paying interest on the debt -- payment of technical
debt is in the form of additional development
needed to keep up with the main branch, the
competition, and the rest of the world.
• Possibly missing on new features in the main
branch or having to backport all new development
into the forked branch internally.
• Duplicate work with the main branch arising due to
the delta between the internal and public branches
being too large.
The worst possible consequence is the effect on the
long term maintainability of the code base where
organizations often find themselves maintaining their
own fork.
7. The Linux Foundation 7
Technical Debt and Open Source Development
How does technical debt accumulate?
Arthur Bloch is an American writer, author of Murphy’s Law books. He is quoted, “Friends come and go, but
enemies accumulate.” This is a great quote to reference when discussing technical debt as just like enemies,
technical debt accumulates. How does it happen? Figure 1 offers an illustration of a basic scenario that explains
how technical debt gets created and carried over.
Figure 1: Development cycles without upstream integration
Open Source
Project Tree
V 1.1
of upstream
Download
V 1.2
of upstream
Merge with
product tree
Product
Source
Code Tree
Apply
custom
patches
Fix custom code
that won’t work with
new version of
upstream code
New code updates
happening to product
tree while adapting
latest upstream code
Test
Re-do
Everything
for V 1.2 of
upstream
8. The Linux Foundation 8
Technical Debt and Open Source Development
Working with Technical Debt
Identifying Technical Debt
Every line of code is potentially technical debt that
consumes engineering time best put on specific
business needs. Figuring this out is mostly about
figuring out your business goals and what your team
is putting time on. Answering a few questions can help
with this thought exercise:
• What is your team working on?
• What do you need to tell a new hire regarding your
software stack?
• How often can you update your full software stack?
• Do you know all the software you depend on?
• What usually breaks?
• What dependencies are the most painful to deal with?
• What would have been the alternative for every
single component of the software stack used?
• How active are the communities of each of these
alternatives?
• How much work is needed to maintain that component
if the community disappears or gets stagnant?
• How much effort to switch to this component?
• How hard is it to debug problems reported by your
customers or engineers?
This series of questions will help you start discussing
technical debt and where your blind spots are.
Minimizing Technical Debt
The core question to address now is how to minimize
tech
nical debt and minimize its impact on development
efforts.
Choice of programming language
The programming language or development framework
used to build the product poses certain restrictions
on your developers. The higher the complexity of a
language or a framework, the harder it is to maintain a
workforce that can work with it. It becomes a balance
between the constraint of the system you are building
your software for and the access to the necessary
developers base to get the job done. In general, for
most cases, you are better off with a higher-level1
language as it will:
• Facilitate hiring developers that provide good results.
• Help third parties identify and solve problems.
• Be portable and easily maintained due to
community involvement.
• Be more tolerant of mistakes and allow for a
simpler solution.
1 The choice of a high-level programming language is context
specific, however, as examples of such languages, we’d like to
suggest Go, Python, C#, and Typescript.
9. The Linux Foundation 9
Technical Debt and Open Source Development
• Important online source of documentation, tutorial,
and pre-made solutions.
Choice of ecosystem
Your application is always built on top of a software
stack of language, framework, and operating system.
This is typical of the structure or composition of
the ecosystem the application is going to live in.
This ecosystem will shape the technical debt, and
developers should know how it aligns with their own
goals. For instance:
• Linux distributions have different terms of support
and guarantee various levels of API/ABI/security
over time.
• The choice of programming language impacts the
ability to run software over time. It affects the
ability to execute code as the runtime and build
environment it runs within evolve. Also, it might
pose some limitations on your ability in finding new
developers to manage those changes.
• Modern language and framework also tend to
bypass Linux distributions to package software.
This factor might have a long term impact on your
software in the same way the Linux distribution will,
so it should also follow your API/ABI/security needs.
Choice of dependencies
As the world moves forward, more open source
software of high quality is made available. This is a
continuous process, and it is essential to evaluate each
piece of software that your organization is developing.
These dependencies simplify the necessary work
and enable them to build more complex features and
solutions. Still, they can also become technical debt if
their communities are not healthy enough. Choosing
the right dependencies and contributing to the
important ones to you reduces your technical debt by
sharing it with the world.
Also, what was true for the value of dependency a
few years ago might not be anymore. This means
that like dealing with technical debt, evaluating your
dependencies needs to be done continuously.
10. The Linux Foundation 10
Technical Debt and Open Source Development
Example 1: The Role of Custom
Build Systems
Maintaining an operating system is more than a full-
time job. It requires making sure that
• It works reliably and securely over time,
• Building each component is reproducible over time,
• Each component is properly evaluated and tested,
• Licenses are respected, and,
• That you have a robust and secure update
mechanism.
This type of work is undervalued as putting together
a Linux environment can now be done in a matter of
hours; however, this is just the first step of maintaining
an operating system over a long period. Today, with
the ARM entrance in the server market, it is possible
to have a more easily standardized distribution for
embedded devices. Debian, Ubuntu, Redhat, and SuSE,
to name a few, provide ARM server distributions that
run just fine, or with a small tweak, on any embedded
device and remove the need for maintaining a custom
operating system and associated package build. It also
provides developers with standardized tools to transfer
knowledge from one environment, the cloud, to the
embedded market. Finding developers that can now
work on embedded systems becomes easier as hiring
managers can tap into the larger market -- the Linux
server market.
It is most likely that an important trend in embedded
device development is going to be in picking an ARM
server distribution with some kind of Long Term
Support, along with a small service written in a higher-
level language, much in the same way that the cloud
industry writes them. Python, Node.js, and Go all have
a bright future in the embedded systems industry.
The next time you have an embedded Linux project,
consider going with a standard Linux distribution that
provides some form of Long Term Support and reduces
your future technical debt.
11. The Linux Foundation 11
Technical Debt and Open Source Development
Example 2: User Interface
Framework
It is easy to gather a few open source components and
run them on a Linux Kernel to name this assemblage
a Linux Distribution. It is not very difficult to display
a picture on the screen with some text and call it
a small UI framework. And in the same way that
maintaining a Linux distribution is a never-ending
task, writing and maintaining your UI framework will
also be a never-ending task. Consider the need to
display language from around the world correctly,
the need for accessibility, the need to scale up and
fit a more constrained environment, and support
different rendering systems as the world moves to
better technologies. There is no end to maintaining
any UI framework. You can easily observe these in the
development of existing UI frameworks. Qt, GTK, and
EFL are more than 20 years old today. They required
hundreds of developers to get where they are, and we
should expect them to require the same level of effort
for the next 20 years. React, and ReactNative require
hundreds of developers as well, a language change
isn’t changing the need to address all this external
constraint. When you pick a UI framework, understand
that you choose a community, and rely on them to carry
its technical debt. Being able to step in and help might
be necessary to ensure that this community stays
healthy and keeps moving that debt off your shoulder.
It is also recommended to pay attention to the licenses
in effect and generally who owns any given project’s
IP assets. Depending on a UI Framework and without
being involved in its development nor paying any
licensing fees, you are inherently weakening one of
your core dependencies if you are making a visual
application and so increasing your technical debt. It
is usually hard to switch frameworks, and the more
complex your application, the harder it becomes to
change frameworks. As for Linux distributions, you’d
want to be involved in some form with your upstream
dependencies to align with your own needs in the
long run. Contributing to upstream can take many
different forms, and you should choose the one that
matches your business the best (code, monetary,
documentation, marketing, etc.)
12. The Linux Foundation 12
Technical Debt and Open Source Development
The Role of Upstream Development
It is expected to branch out or fork and do your development as long as the end goal is to contribute back to the
upstream branch. Figure 2 illustrates this process.
Open Source
Project Tree
V 1.1
of upstream
Download
from Upstream
project
V 1.3
of upstream
Product
Source
Code Tree
V 1.2
of upstream
Apply
custom
patches
Apply fewer
custom
patches
Apply fewer
custom patches
to latest
upstream code
Download from
upstream
project
Download from
upstream
project
Test Test
Contribute
changes
to upstream
project
Contribute
changes
to upstream
project
Integrate in
product tree
Integrate in
product tree
Figure 2: Development cycles with upstream integration
• Continuous integration and continuous delivery/
deployment: Features are available more quickly to
developers; new code appears in developer trees
sooner. At a higher level of quality, each code commit
requires testing, regressions, and bugs are more visible.
• Release early and often: The release early and
often practice has numerous proven advantages.
The “release early” allows others to provide
feedback and participate in the development,
welcoming new ideas that can be incorporated.
13. The Linux Foundation 13
Technical Debt and Open Source Development
Simultaneously, code is still flexible and offers
time for problems to be flagged by others before
development gets too far. On the other hand, the
“release often” makes it possible for the codebase
changes to be easier to understand, debug, and
drive to maturity, and at the time, facilitates the
ability to maintain the rapid pace of development
and innovation.
• Peer review: Share as early as possible, even
during the design phase of your code; Requests for
comments are expected; subsystem/maintainer
model with multi-layer hierarchy; by the time
code is released, it has typically been reviewed
many times. Code is always reviewed before being
committed. Enables projects to accept code from
a much wider range of contributors (establishes a
web of trust).
• Ongoing or continuous testing:
• Early discovery means faster triage and fixes.
• Smaller changes make troubleshooting easier.
• Regressions are noticed earlier.
• Helps subsystem maintainers determine which
code submissions to accept.
• Projects may have multiple build and test cycles.
• Build service tools can automate the process.
• Typically tightly aligned with feature freezes.
• Easier Maintenance (changing technology, security
fixes)
• Better testing, bug report gathering, and analysis
• Focus on modular designs and architecture:
Modularity has several benefits: it allows projects
to scale, minimizes contention over common code
with a smaller core and features implemented
as plugins reduce collisions, creates a natural
separation of tasks and scope, allows features
to be available more quickly to developers, and
if well done modular designs often have fewer
interdependencies with clear interfaces.
Upstream - Unifier of Efforts
Done well, developing in alignment with upstream is
a guarantee that you will have little to zero technical
debt. However, that requires involvement and active
participation in upstream open source projects.
You can not enforce that upstream is going in the
direction that benefits you. Still, you can influence
it by contributing to it and sharing your goal/will
with upstream and influencing other contributors to
understand your needs.
14. The Linux Foundation 14
Technical Debt and Open Source Development
Addressing Technical Debt at Scale
If your organization uses hundreds or thousands of
open source packages and makes modifications to
many of them, you will need to consider a contribution
strategy that will allow you to contribute code back to
the core or essential components to minimize technical
debt towards such strategic components. What are some
of the ways to address the technical debt on a large scale?
We explore two sets of practices that help that at policy
and process level and then at the development level.
At the Policy and Process Level
• Blanket approval to contribute for dedicated open
source developers.
• Faster approval path that allows contributions to
upstream projects to flow much faster.
• Flexible IT support enables developers with
needed tooling (now facilitated with the Windows
Subsystem for Linux and virtual machines if you
can’t afford a dedicated Linux environment for your
developers).
• Structure performance reviews that reward
developers who follow the set processes/policies
and work towards minimizing technical debt
• Guaranteed time for your developers to work with
the upstream project
At the Development Level
• Explain your business goals to your engineers by
sharing your vision and goals. In the end, they are
the ones implementing it, so they should know what
you have in mind.
• Ensure that your developers and new members
joining your team understand what technical debts
are and why you choose to maintain the technical
debt you already have.
• Have realistic expectations in terms of merging your
contributions with the upstream branch.
• Embrace the review/feedback cycle. There will be
multiple back-and-forth cycles as part of the review
process with the upstream development.
• Don’t be too selfish with your contributions. Get
involved with upstream on tasks that are not
necessarily directly needed in the short term by
your organization, but improve upstream viability
and health.
• Encourage your developers to explicitly leave
comments in the code when they are adding
technical debt.
• Work for the short term but plan for the long term.
15. The Linux Foundation 15
Technical Debt and Open Source Development
Too late! Technical debt is already
here. What should we do?
The organization you work with has accumulated a
lot of technical debt, and all the symptoms are there.
Now, what should you do about it? We wish there was
a silver bullet, but there isn’t. The approach you take
will depend on several factors; however, you can start
examining these different options:
• Choose what feature/functionality needs to be saved.
• Identify the code that is still useful.
• Remove code that should not be maintained or
used anymore.
• Reduce the need for branches/fork.
• Refactor, clean and upstream the code that can be
upstreamed.
These activities are time-consuming and will slow down
your development cycle as you dedicated developers to
focus on this effort. It will also be hard for the organization
to add any features during that time and might be very
controversial or counter to the ongoing efforts.
It is also possible that there exists now an open source
project that does or could provide the feature or some
of the features you need. Migrating to it might also
make more sense than trying to deal with the current
codebase. It is something not to forget, the world
moves even when you are not looking, and there might
be something out there now that does what you need.
Do not let your organization pride prevent you from
looking at other solutions and use the one that makes
most business sense.
Another more radical approach: Give up on your
technical debt and drop the code altogether. This can
be done in multiple ways. If your business can not
afford to maintain the code still and that there aren’t
enough clients to justify its existence, just drop it. For
that, be explicit with your clients and tell them that
this code is going to be deprecated and sunsetted.
This is the equivalent of declaring bankruptcy on your
technical debt and ceasing payment on it.
16. The Linux Foundation 16
Technical Debt and Open Source Development
Recommended Practices
In this section, we provide a list of recommended
practices listed in random order. Please keep in mind
that they may not all apply to your specific situation
and organization as you read this section. Some may
apply, some may not. Therefore, it is essential to do
a self-evaluation of an appropriate practice to adopt
within your company and possibly how such presented
practices can be adjusted to provide the best possible
outcome for you.
• Adopt an upstream first philosophy.
• Careful evaluation for any custom code that is not
going upstream.
• Always plan to merge back with the main branch.
Forks and side branches are ok as long as there is a
plan to merge with upstream.
• Align internal development effort with the
upstream branch release cadence
• Allow fast approvals for upstream contributions.
This is done via a clear and lightweight policy and
process to facilitate interactions with upstream
developers.
• Update your performance metrics to incorporate
metrics related to technical debt as part of
the overall performance goals to ensure that
development goals are not achieved due to a high
or unacceptable technical debt cost.
• Train developers/managers to identify and mitigate
technical debt scenarios.
• Require all code to be properly documented to be
better understood by upstream reviewers and
most likely will contribute to a faster acceptance
cycle (Document also why code is not upstreamed)
• Follow the release early and often practice.
Don’t build a huge code base and then decide to
upstream it. Share design, early code and submit
large contributions in smaller, independent patches
that build on each other.
• Track the code you choose to not upstream: Re-
evaluate at every opportunity. If you spot an
upward trend in the internal maintained code’s size,
this calls for a discussion and reevaluation of prior
decisions.
17. The Linux Foundation 17
Technical Debt and Open Source Development
Conclusion
Open source has a significant role, and aligning your
development efforts with upstream open source
projects can result in a direct positive impact on the
amount of the technical debt an organization carries.
Just as financial debt involves paying interest, technical
debt has a different kind of interest that needs to be
carried: It’s not interest-free!
In many cases, technical debt is unavoidable short
term. Carrying technical debt is mostly a decision that
developers need to make all the time. The long term
goals of any engineering effort should be to minimize
and eliminate technical debt resulting from any
development effort. With proper policies, processes,
training, and tooling, organizations can help mitigate
and guide the engineering efforts towards lowering
technical debt.
18. The Linux Foundation 18
Technical Debt and Open Source Development
Feedback
Suggestions for improvement will be appreciated. Please send comments to the authors directly.
About the authors
Cedric Bail (M.Sc.) is a senior software engineer currently contracting with EASi specializing in embedded Linux.
Cedric has worked as a software engineer for various embedded Linux platforms at a mobile operator, an Internet
service provider, and, most recently, one of the largest consumer electronics companies. His focus has always
been to optimize software for constrained environments, improving their API, and introducing new components as
needed in upstream software to match business requirements.
Twitter: @cedric_bail
LinkedIn: linkedin.com/in/cedricbail/
Email: cedric.bail@free.fr
Ibrahim Haddad (Ph.D.) is the Executive Director of the LF AI Foundation. Haddad has held technology and
portfolio management roles at Ericsson Research, the Open Source Development Labs, Motorola, Palm, Hewlett-
Packard, the Linux Foundation, and Samsung Research.
Twitter: @IbrahimAtLinux
Web: IbrahimAtLinux.com
LinkedIn: linkedin.com/in/ibrahimhaddad
Email: ibrahim@linuxfoundation.org
19. The Linux Foundation promotes, protects and
standardizes Linux by providing unified resources
and services needed for open source to successfully
compete with closed platforms.
To learn more about The Linux Foundation or our other
initiatives please visit us at www.linuxfoundation.org