https://henrikwarne.com/2023/01/07/there-is-no-software-maintenance/ Henrik Warne's blog Thoughts on programming... Skip to content * Home * About [cropped-desk1] - Switching to Go - First Impressions There Is No Software Maintenance Posted on January 7, 2023 | Leave a comment Every time I hear about software maintenance as a distinct activity, I cringe. That's because it is based on the outdated notion that first software is developed, then it is maintained. But that is not how software development works today. Software development does not have the two phases development and maintenance - it is a continuous process. Software maintenance is simply software development. [img_202301] It is fairly common to come across the concept of software maintenance. Recently I have seen it in posts on LinkedIn (how developers leave if they have to do maintenance), in books ("it is well known that the majority of the cost of software is not in its initial development, but in its ongoing maintenance"), and in surveys (do you develop new features, or do you maintain existing features). But this is based on the false premise of the software project. Project vs. Product In the project model, you set out to develop a system. So you create a project, gather requirements, develop the software, and deliver the result. Any changes after this delivery are considered maintenance, be it changes to functionality or bug fixes. This is how I was taught software development works when I went to university a long time ago. There are two big problems with the project view of software development. The first is that it is almost impossible to decide how the system should work before you try it. As soon as you start using the system, you learn more about how it should work. This inevitably leads to changed requirements. Secondly, once the system works, you start to think of additional uses for it. In other words, the problem you are solving is open-ended (expanding uses), rather than clearly defined. In a sense, you are never finished, because what you want the system to do keeps expanding. This may seem counterintuitive, but for all systems I have worked on, I have been surprised at how we never ran out of features to add. The expansion is also fractal - you add new big features, but you also keep tweaking and expanding the behavior of existing features. So, the project model (build the system once and for all, the rest is maintenance) does not match how software systems evolve. A better model for software development is the product model. Here you consider the software system to be a product that is continually developed. There is a permanent team of developers working on the system, and you continuously add features to it. In the product model it doesn't make sense to distinguish between development and maintenance, because you are constantly changing and developing the system. This includes fixing bugs. Over my career in software development, I have seen a shift from project to product. This makes sense, since the product model aligns much better with how systems are used. There are other advantages with the product model too. The developers working on the product stay with the same product. They see how it is used, and understand how it has evolved. In the project model it is more common to have people develop the initial system, then leave for the next project. They don't have to live with the decisions they made, and they don't get the benefit of learning how the customers are using the system. Happily, many (or most) companies have realized that the product model is better than the project model for software development. This means that it doesn't make sense to talk about software maintenance. Changing and improving the systems is software development. What About "Pure" Maintenance? Maintenance in the traditional sense includes lubricating moving parts, changing filters, or mending broken pieces (like sewing on a loose button). In software, fixing bugs is the equivalent of repairing broken parts. What about preventing wear and tear? Well, in this sense software is the opposite of physical objects. The more you use it (if by that we also include bug fixing), the better it gets. I like this quote: "Hardware eventually fails. Software eventually works." - Michael Hartung However, if you consider that the environment the program works in can change (library or OS upgrades for example), then you could compare this to handling wear and tear. There are systems that are maintained only in this sense: fixing bugs, and making sure that it can keep running. But I would argue that this is a very small part of all software development work being done. Furthermore, when it comes to fixing bugs, there can be ambiguity. Is this really a bug, or is it in fact a request for new functionality? And why fix the bug at all, if it has worked up until now, and the only objective is to keep the system running. So, in some sense, this form of maintenance is also just ordinary software development. Conclusion In any form of software development, you always have to read and understand existing code, even when you mostly add new features. As the system grows, this becomes even more common. Newly written code becomes "legacy" very quickly. Furthermore, you always have to fix bugs. So, let's stop talking about software maintenance is if it were a separate activity. It is not. It is just software development. Share this: * Twitter * Facebook * LinkedIn * Like this: Like Loading... Related This entry was posted in Programming and tagged software development, software maintenance. Bookmark the permalink. - Switching to Go - First Impressions Leave a Reply Cancel reply Enter your comment here... [ ] Fill in your details below or click an icon to log in: * * * * Gravatar Email (required) (Address never made public) [ ] Name (required) [ ] Website [ ] WordPress.com Logo You are commenting using your WordPress.com account. ( Log Out / Change ) Twitter picture You are commenting using your Twitter account. ( Log Out / Change ) Facebook photo You are commenting using your Facebook account. ( Log Out / Change ) Cancel Connecting to %s [ ] Notify me of new comments via email. [ ] Notify me of new posts via email. [Post Comment] [ ] [ ] [ ] [ ] [ ] [ ] [ ] D[ ] * MOST POPULAR + Lessons Learned in Software Development + Top 5 Surprises When Starting Out as a Software Developer + Working as a Software Developer + Great Programmers Write Debuggable Code + What Makes a Good Programmer * RECENT POSTS + There Is No Software Maintenance + Switching to Go - First Impressions + Effective Software Testing - A Developer's Guide + On Code Reviews + Book Review: A Philosophy of Software Design + On Comments in Code + 4 Things I Like About Microservices + Recruiting Software Developers - Coding Tests + More Good Programming Quotes, Part 5 + 6 Small Unit Testing Tips + Mathematical Modelling of Football + Deployed To Production Is Not Enough + Good Logging + Working From Home - Cons and Pros + Artificial Intelligence - A Guide for Thinking Humans + 20.5 Years of XP and Agile + Secure by Design + More Good Programming Quotes, Part 4 + Grokking Deep Learning + EuroSTAR Testing Conference Prague 2019 + Classic Computer Science Problems in Python + When TDD Is Not a Good Fit + Recruiting Software Developers - Checking Out a Company + Book Review: Designing Data-Intensive Applications + Nordic Testing Days Tallinn 2019 + Book review: Accelerate + More Good Programming Quotes, Part 3 + Programming: Math or Writing? + Developer On Call + My Favorite Command-Line Shortcuts + 6 Git Aha Moments + Is Manual Testing Needed? + Exercises in Programming Style + Programming for Grade 8 + 6 Years of Thoughts on Programming + Benefits of Continuous Delivery + More Good Programming Quotes, Part 2 + Developer Testing + Programming Conference - QCon New York 2017 + Developers - Talk To People + Code Rot + Programmer Career Planning + Software Development and the Gig Economy + Book Review: The Effective Engineer + Things Programmers Say + Developer Book Club + Book Review: Release It! + 18 Lessons From 13 Years of Tricky Bugs + Learning From Your Bugs + More Good Programming Quotes + The Wisdom of Programming Quotes + Ph.D. or Professional Programmer? + Social Engineering from Kevin Mitnick + Recruiting Software Developers - Initial Contact + Coursera Course Review: Software Security + Lessons Learned in Software Development + Book Review: Clean Code + Coursera Course Review: Computational Investing Part 1 + Programmer Knowledge + 5 Reasons Why Software Developer is a Great Career Choice + A Response to "Why Most Unit Testing is Waste" + What Makes a Good Programmer? + Switching from Java to Python - First Impressions + Antifragility and Software Development + 5 Unit Testing Mistakes + Unit Testing Private Methods + A Bug, a Trace, a Test, a Twist + Session-based Logging + Finding Bugs: Debugger versus Logging + TDD, Unit Tests and the Passage of Time + Automatically Include Revision in Log Statement + 7 Ways More Methods Can Improve Your Program + LinkedIn - Good or Bad? + Great Programmers Write Debuggable Code + SET Card Game Variation - Complementary Pairs + Programmer Productivity - Interruptions, Meetings and Working Remotely + What Do Programmers Want? + Coursera course review: Algorithms: Design and Analysis, Part 2 + Blog stats for 2012 (by WordPress) + Working as a Software Developer + 4 Reasons Why Bugs Are Good For You + Book Review: How Google Tests Software + Top 5 Surprises When Starting Out as a Software Developer + Programmer Productivity: Emacs versus IntelliJ IDEA + Why I Love Coding + Coursera course review: Design and Analysis of Algorithms I + Mac OS X Break Programs Review + Favorite Programming Quotes + How I Beat Repetitive Stress Injury + Introduction to Databases - On-line Learning Done Well + 10 million SET games simulated using "Random among 'most similar' Sets" + 10 million SET games simulated using "Random among available Sets" + 10 million SET games simulated using "First found Set" + SET(r) Probabilities Revisited * TAG CLOUD algorithms book book review break program bugs career code coding conference coursera creativity databases debugging developer testing DevOps emacs ergonomics face to face Google hiring ide idea integration testing intellij interruption job knowledge learning linkedin logging love machine learning Mac OS X meeting meta methods office on-line course probabilities production software productivity professional software development programmer programming programming course programming job python quotes recruiting refactoring Repetitive Stress Injury review revision RSI security SET game simulation software development statistics stats stretches subversion surprises svn tdd test-driven development testing time trouble-shooting unit-test unit testing university version work working * RSS + RSS - Posts + RSS - Comments * Follow Blog via Email Enter your email address to follow this blog and receive notifications of new posts by email. Email Address: [ ] Follow Join 348 other subscribers Create a free website or blog at WordPress.com. * Follow Following + [wpcom-] Henrik Warne's blog Join 348 other followers [ ] Sign me up + Already have a WordPress.com account? Log in now. * + [wpcom-] Henrik Warne's blog + Customize + Follow Following + Sign up + Log in + Copy shortlink + Report this content + View post in Reader + Manage subscriptions + Collapse this bar Loading Comments... Write a Comment... [ ] Email (Required) [ ] Name (Required) [ ] Website [ ] [Post Comment] %d bloggers like this: [b]