Is software ever finished?

Some applications (and operating systems) like Windows, Oracle or Microsoft Word seem to never reach a final state.

Microsoft Word is a word processor, which is on the market for more than 10 years now. Why is it that an application like a word processor is still improved and changed after all these years? One would assume that at a certain point in time, the application would be finished, but it’s not. The same goes for applications like Oracle's database or the Apache webserver. There are three reasons for this: Bugs, adapting and improvements.


Some software is built on an old, and sometimes unstable basis, like Microsoft Windows. Windows has it's base in MS-DOS, a command-line based operating system without multi-user or networking capabilities. Because people want Windows Vista to still run MS-DOS application from 20 years ago, much work must be done to keep everything working in every new release of Windows. This makes software very complex and error-prone. Therefore many bugfixes are inevitable.

Because software made by commercial companies can only be sold when it is market-ready, commercial drivers set release dates for software. Even if the software is not 100% bullet-proof, or if not all features are completely tested, the software must be released. This causes bugfixing after the software is released, sometimes for a considerable amount of time.

Since the widespread adoption of the Internet, much attention is given to security. Securitybugs nowadays are a large source of bugfixes.


Some software is dependent of other software to function. This causes software that was originally finished, to be upgraded all the time. A good example of this is the Apache webserver. One could say that a webserver can be a simple program, serving HTML pages over a TCP port. And the original Apache webserver was indeed as simple as that.

But developers from for instance PHP wanted to have Apache run PHP programs that were embedded in webpages. This caused Apache to be extended. The same happened when support for databases was needed, or secure connections, or webservices. Apache became bigger and bigger.

Improvements and new versions

For commercial software vendors, it is not attractive to finish software completely. This would dry up the revenue stream. It is much more profitable to have a new release of the software every two years. Even if this new version contains new features that few people want or need. At some point in time, upgrading software just to have some new features nobody really wants or needs is just not interesting for customers anymore. This is what is happening to Microsoft Word for example. Few people want to upgrade to a new version after Word 2000, because this products is actually really finished.

To avoid the problem of customers not upgrading to the latest software release, software vendors came up with another strategy: support. While not many people (let alone companies) want to upgrade to Windows Vista, many are forced to. Microsoft will stop selling Windows XP, it is not installed on new computers anymore and the support for it will also stop in the near future, although Windows XP is still a fine product, that works perfectly for 95% of the customers,


Because of the constant "improvements" and bugfixing, many applications will never be finished. This makes software very hard to manage for programmers. It would be much easier to build software using smaller components, that will be finished and never touched again. This is the design philosophy of UNIX. UNIX consists of a fairly small kernel, with addons as small components (drivers, modules and shell-commands). The philosophy of UNIX (and later Linux) was to have small tools that do one thing, but do it very well. Commands like tar, grep and ls are finished for many years, but are still used all the time. Very few people feel tar has too little functionality or bugs.

This works also for the Windows environment. For instance, Winzip is around for many years, without improvements or bugfixing. It works and it is finished. The same goes for paint and notepad for instance.

I feel it would be a good choice for software development companies to slit-up applications and let them consist of smaller components. These components could be completed and finished, while the main application can still be improved. It works. Look at the GNU/Linux operating system for example.

This entry was posted on Thursday 13 December 2007

Earlier articles

The cloud is as insecure as its configuration

Infrastructure as code

My Book

DevOps for infrastructure

Infrastructure as a Service (IaaS)

(Hyper) Converged Infrastructure

Object storage

Software Defined Networking (SDN) and Network Function Virtualization (NFV)

Software Defined Storage (SDS)

What's the point of using Docker containers?

Identity and Access Management

Using user profiles to determine infrastructure load

Public wireless networks

Supercomputer architecture

Desktop virtualization

Stakeholder management

x86 platform architecture

Midrange systems architecture

Mainframe Architecture

Software Defined Data Center - SDDC

The Virtualization Model

What are concurrent users?

Performance and availability monitoring in levels

UX/UI has no business rules

Technical debt: a time related issue

Solution shaping workshops

Architecture life cycle

Project managers and architects

Using ArchiMate for describing infrastructures

Kruchten’s 4+1 views for solution architecture

The SEI stack of solution architecture frameworks

TOGAF and infrastructure architecture

The Zachman framework

An introduction to architecture frameworks

How to handle a Distributed Denial of Service (DDoS) attack

Architecture Principles

Views and viewpoints explained

Stakeholders and their concerns

Skills of a solution architect architect

Solution architects versus enterprise architects

Definition of IT Architecture

What is Big Data?

How to make your IT "Greener"

What is Cloud computing and IaaS?

Purchasing of IT infrastructure technologies and services

IDS/IPS systems

IP Protocol (IPv4) classes and subnets

Infrastructure Architecture - Course materials

Introduction to Bring Your Own Device (BYOD)

IT Infrastructure Architecture model

Fire prevention in the datacenter

Where to build your datacenter

Availability - Fall-back, hot site, warm site

Reliabilty of infrastructure components

Human factors in availability of systems

Business Continuity Management (BCM) and Disaster Recovery Plan (DRP)

Performance - Design for use

Performance concepts - Load balancing

Performance concepts - Scaling

Performance concept - Caching

Perceived performance

Ethical hacking

The first computers

Open group ITAC /Open CA Certification

Sjaak Laan

Recommended links

Ruth Malan
Gaudi site
Esther Barthel's site on virtualization
Eltjo Poort's site on architecture


XML: RSS Feed 
XML: Atom Feed 


The postings on this site are my opinions and do not necessarily represent CGI’s strategies, views or opinions.


Copyright Sjaak Laan