From Wikipedia, the free encyclopedia

This article may require cleanup to meet Wikipedia's quality standards. Please improve this article if you can. (May 2007)

Software bloat, or bloatware, is a term used in both a neutral and disparaging sense, to describe the tendency of newer computer programs to be larger, or to use larger amounts of system resources (mass storage space, processing power or memory) than older versions of the same programs, without obvious benefit to end users.

Bloat is described as: the tendency to replace efficient and focused applications with less efficient enhanced versions, inefficiencies or unnecessary modules in program design and operation, and the incorporation of extended features which will be extraneous or low value for most users but slow down the program overall even if unused.^{[citation needed]} The latter is often blamed either on the prioritization of marketing and "headline feature-set" over quality and focus, or the need to be perceived as adding new functionality in the software market^{[citation needed]}, which for many products relies upon the existence of regular enhanced versions to be sold within the existing user base.

Contents 1 Background 2 Possible causes 2.1 Time-to-market 2.2 Rapid development 2.3 Disregarding older machines 2.4 Code bloat 2.5 Conspiracy theory 2.6 Feature competition 3 Reasons for existence 4 Examples 5 Alternatives to software bloat 6 See also 7 References

Software developers involved in the industry during the 1970s had severe limitations on disk space and memory. Every byte and clock cycle counted, and much work went into fitting the programs into available resources. The extra time spent by programmers translated directly into smaller, more efficient software products, and hence was seen to translate directly into sales revenue.

This situation has now reversed. Resources are perceived as cheap, and rapidity of coding and headline features for marketing are seen as priorities. ^[1] In part, this is because technological advances have since multiplied processing capacity and storage density by orders of magnitude, while reducing the relative costs by similar orders of magnitude (see Moore's Law). Additionally, the spread of computers through all levels of business and home life has produced a software industry many times larger than it was in the 1970s.

Finally software development tools and approaches often result in changes throughout a program to accommodate each feature, leading to a large scale inclusion of code which affects the main operation of the software, and is required in order to support functions that themselves may be only rarely used. In particular, the advances in resources available has led to tools which allow easiest development of code, with less priority given to end efficiency.

Niklaus Wirth has summed up the situation in Wirth's Law, which states that software speed is decreasing more quickly than hardware speed is increasing.

Some of the observed bloat is caused simply by the addition of new features and content, such as templates,^{[citation needed]} or by the use of higher-level programming languages. However, at other times the cause may be a programmer's lack of attention to optimization or design, often frowned upon by other programmers as a sign of carelessness, laziness, or lack of skill.^{[citation needed]}

The emphasis in software design could be argued to have shifted away from tightness of design, algorithms and resource.^{[citation needed]} Instead, time-to-market may be seen as becoming the key focus of developers.^{[citation needed]} The extra time needed to optimize software delays time-to-market, losing some potential sales and increasing labor costs.^{[citation needed]} The improvement in quality due to optimization was previously thought to more than make up for these costs, but with modern hardware, it is now more common that the payoff from optimization is too small to justify it, or at least is seen that way.

The software industry has responded to the changing trade-off of optimization in favor of time-to-market with emphasis on rapid code development, automating programming tasks that had previously been areas of fine craftsmanship and re-automating on top of that. The result is multiple layers of software abstraction resting on top of each other, and the task of the modern software programmer often consists more of administering automatic code generators and pre-written components to their will than in the fine handling of software to be completely optimized. With an establishment of well-founded, stable, optimized and dependable code libraries and well documented application programming interfaces (API), this enables functional code to be created much faster than coding up equivalents from scratch, where development time would be significantly longer. A case in point is NeXT's OpenStep Foundation Kit and Application Kit − a set of reusable objects that enabled developers to create functional and usable code faster than conventional methods.

Some hold that the result of modern rapid application development practices,^{[attribution needed]} forgoing the optimization practices of the past, make a point that modern software running on faster computers does not appear to be significantly faster; this is due to the consumption of underlying technical advances by layers of software abstraction in pursuit of time-to-market.^{[citation needed]} Unfortunately the abolition of this software abstraction can hamper the underlying development of the program. Software structures that are well crafted in place to allow for easy extensibility and maintenance will assist software developers in that upgrading existing code will be simpler and faster.

Since any single application is usually small enough to fit on any computer's hard disk or RAM, developers usually do not consider size implications for users, who often install many bloated products. Also, programmers tend to develop and test their programs on the biggest, fastest computers they can get their hands on and tend to optimize for speed only while there is a perceived lack of it, while most users' computers will be years older with a fraction of the space and speed.^{[citation needed]} Thus, unless efficiency is a specific goal, software tends to tailor itself to fit the dimensions of the most recent computers available to software developers. This is most true in the commercial sector where companies supply their programmers with the fastest computers they can, thinking to make them more productive. The result is an older computer biting off more than it can chew and ends up thrashing.

The optimization at the machine-code level need not be done by hand. Modern compilers often take optimization of code into consideration, and this forgoes the need for hand-manipulation of assembly code. Naturally, this software optimization is never one-hundred percent perfect, but then the resulting effect from a programmer making the optimized code fully optimized is negligible. Sometimes optimized assembly code produced by compilers flags results in bloated generated code like loop unrolling, which copies loop internals resulting in larger code to eliminate some branch testing for a pipelined processor.^[2]

The more cynical observer may remark that commercial products need to add more bloat with each version in order to sell those new versions to potential customers. Even greater cynics might also comment that any tie between commercial software houses and hardware corporations may result in the need to make sure that even the latest desktop PC will slow significantly when running their applications; thus creating the ever present need for buying new hardware.^[3]

The competitive nature of software breeds innovation. As software vendors fight over market share, they will copy features from competing products. For example, tab browsing not featured in 3.x browser generation has now been part of newer generation of every mainstream web browser even in text browser like ELinks. Software vendors will add features in order to gain competitive advantage.^[4]

In his 2001 essay Strategy Letter IV: Bloatware and the 80/20 Myth,[1] Joel Spolsky argues that while 80% of the users only use 20% of the features (a variant on the Pareto principle), each one uses different features. Thus, "lite" software editions turn out to be useless for most, as they miss that one or two special features that are present in the "bloated" version. Spolsky sums the article with a quote by Jamie Zawinski referring to Netscape:

"Convenient though it would be if it were true, Mozilla is not big because it's full of useless crap. Mozilla is big because your needs are big. Your needs are big because the Internet is big. There are lots of small, lean web browsers out there that, incidentally, do almost nothing useful. But being a shining jewel of perfection was not a goal when we wrote Mozilla."

A common example of software bloat is the evolution of word processing programs, which have for long been deemed especially resource-hungry in the range of typical productivity applications.^{[citation needed]} It can be argued that the basic tasks — writing and simple type-setting — have been possible since the first such programs were introduced around 1970, and that more advanced features bring needless weight to those who rarely need them.^{[citation needed]} On the other hand, users have since grown used to modern convenience features, and less feature-packed applications are still available for those who prefer them.^{[citation needed]}

Another example of bloat software is the operating system. During generations they have grown with an accelerating speed. This can be seen by comparing the requirements for running different versions of Microsoft Windows. Windows Vista has more features than Windows 95 had, but there is also more bloat.

Comparison of Microsoft Windows System requirements

Windows version	Processor	Memory	Hard disk
Windows 95[5]	25 MHz	8 MB	~50 MB
Windows 98[6]	66 MHz	24 MB	140 - 255 MB
Windows Me[7]	150 MHz	32 MB	320 MB
Windows 2000 Server[8]	133 MHz	64 MB	1 GB
Windows XP[9]	300 MHz	128 MB	1.5 GB
Windows Vista[10]	1 GHz	512 MB	15 GB

Drivers can also be a major source of bloat due to the addition of features which are not often needed. Printer and digital camera drivers are two good examples. These drivers can include rarely used functions like photo editing which can consume in excess of hundreds of megabytes.^{[citation needed]}

CD and DVD Burning applications such as Nero Burning ROM have become criticized for being bloated.^[11] Many software developing companies have started to bundle their burning software with various programs that might seem unnecessary, such as video player software, video editing software, CD/DVD cover editors, and as many other features that might not be what users require.^{[citation needed]} This has specially appeared on Nero Burning ROM version 7 and CNET reviewer Troy Dreier claimed in his review that:

"Nero is bigger than ever: the complete Nero 7 code requires a serious chunk of system memory--600MB--so make sure you have the room before installing. Users were already complaining about bloat on message boards even before launch. Nero can be a system resource hog, even when doing simple tasks, such as browsing files in the new Nero Home app."^[12]

"Bloatware" can also refer to distribution or installation programs that install unnecessary programs and can reduce the operating system's stability or speed.

Superfluous features not specifically tailored to the enduser are sometimes installed by default through express setups such as native language support (NLS). Support for Chinese, Japanese, and Arabic fonts and glyphs and associated rendering support and handling of unicode data are not an interest to those who are not intending to use those languages. Large program libraries with unnecessary features can also cause software to be larger and slower. For example, the Pango library used in some Firefox builds reduces rendering speed. An optimized version of Firefox that disables or does not use Pango renders pages significantly faster.^[13] Rendering beyond the 4 second rule amounts to abandonment of waiting for the page to be rendered or lost interest and frustration, hence lost business and a potential customers.^[14]

Some applications, such as Mozilla Firefox and Microsoft Office, package additional functionality in plug-ins, extensions or add-ons which are downloaded separately from the main application. These can be created by the software maker and often by third parties. This provides the user with all desired functionality, while reducing the file size and system requirements of the main software package.

• Obesity in Applications
• Code bloat
• Computing minimalism
• Featuritis
• Zawinski's Law of Software Envelopment