[NMLUG] Linux (and Open Source in general) vs. Windows Design Philosiphy

[brians.outfit at gmail.com (Brian Rodgers)]

Hi Brian,

 This is the first of what will hopefully be several Linux related
notes.  I figure you can pass them on to whoever might benifit from
them, or use them to create a F.A.Q. once the users group's website is
up.


Linux (and Open Source in general) vs. Windows Design Philosiphy

Windows:  A software package should be complete in and of itself.  It
must include all supporting packages to make it work.

Linux:  Do one thing, and do it well.  Link programs together to do
many things well.

The Windows philosophy is nessecitated by the closed source mindset. 
You can not expect a user to have another software package installed,
because it most likely costs money.  Also, you may not be able to use
another program's code because of licensing issues.  So, for example,
a word processing program has to include it's own dictionary, it's own
grammer checker, it's own thesaurus, it's own export filters, etc.

Open Source developers have to think differently.  First, most of them
are working for free.  They don't get paid for their work, so they
have less time and resources to devote to a project.  Also, they tend
to focus on their area of expertise.  So they make their software
modular.  If they are designing a word processor, they focus on the
word processor.  If they want to add spell checking, they simply pass
the data out to a different program (aspell or ispell), and let it do
the spell checking and read the results.  They can do this because
they know that installing aspell is not a hardship on their users
(it's free, and it's small because it does just what it needs to -
check spelling).  If they want a dictionary, they don't write one,
they offer an interface to a dictionary program like dict.  If they
want it to be able to export to a pdf, they link to an existing pdf
library instead of designing their own.  Because the source code is
open, if someone needs a word processor with a specific feature, they
can just add that feature to an existing program instead of having to
write a totally new word processor.  They could then contribute their
changes back to the developer so the whole world could take advantage
of the new feature.  In this way, it is possible to create high
quality software with limited resources.  It also allows different
programs to develop and grow individually.

As an example of individual growth, think of the above senario.  With
a Windows word processor, if the dictionary needs to be expanded, that
company has to create the new one, and the user has to download and
install it.  If the user has several word processing programs
installed, they would have to download and install an updated
dictionary for each of those programs.

On the other hand, the Linux user would just install an updated
version of dict.  Immediately, every program on his system that
interfaces with dict would take advantage of the new dictionary.  This
also means that only 1 dictionary has to be installed on a computer,
instead of a seperate dictionary for every software program that needs
one.  Also, since the program does not require dict to be installed,
the user doesn't even have to install dict if he never intends to use
the dictionary feature.

This allows Linux utilize it's resources better.  Computers that could
never run a recent version of Windows, can run the latest Linux
kernel, and be put to productive use because of it's modularity.

Say you want to host a web page.  If you use Windows as a host,
windows loads first the kernel, then the Windows Desktop and all
supporting programs.  Even though you may never even touch that
computer, it is still using memory and hard drive space for all the
Windows icons, displaying the desktop, running several (unneeded)
services in the background, device drivers for your video card, sound
card, etc.  If you were using Linux, you would only load the kernel
and those programs needed to run a web server (apache, network
drivers).  You could even customize your kernel to remove support for
hardware that you don't have.

This aproach allows reduced memory, cpu speed, and storage
requirements.  It also allows you to customize your system so it does
what you need it to do, without excess cruft.  It increases stability
because there are fewer places for problems to occur.

All this flexibility does come with a price.  Because the user has
choices, they have to make some.  They need to be more familiar with
what is installed on their system, because by default, not everything
is.  They may need to install some programs that other programs rely
on.  There's a bigger chance that software won't "just work" without
some tweaking.