We're programmers. Programmers are, in their hearts, architects, and the
first thing they want to do when they get to a site is to bulldoze the place
flat and build something grand. We're not excited by incremental renovation:
tinkering, improving, planting flower beds.

	Joel Spolsky
	"Things you Should Never Do, Part I"
%
Have you ever heard of SEMA? It's a fairly esoteric system for measuring how
good a software team is. No, wait! Don't follow that link! It will take you
about six years just to understand that stuff. So I've come up with my own,
highly irresponsible, sloppy test to rate the quality of a software team.
The great part about it is that it takes about 3 minutes. With all the time
you save, you can go to medical school.
	
	Joel Spolsky
	"The Joel Test: 12 Steps to Better Code"
%
To make people happy, you have to let them feel like they are in control of
their environment. To do this, you need to correctly interpret their
actions. The interface needs to behave in the way they are expecting it to
behave.

Thus, the cardinal axiom of all user interface design:

<<<
A user interface is well-designed when the program behaves exactly how the
user thought it would.
>>>

As Hillel said, everything else is commentary. All the other rules of good
UI design are just corollaries.

	Joel Spolsky
	"User Interface Design for Programmers - Chapter 1"
%
There's a subtle reason that programmers always want to throw away the code
and start over. The reason is that they think the old code is a mess. And
here is the interesting observation: they are probably wrong. The reason
that they think the old code is a mess is because of a cardinal, fundamental
law of programming:

<<<
It's harder to read code than to write it.
>>>

	Joel Spolsky
	"Things you Should Never Do, Part I"
%
TRS-80 Level-I BASIC could only store two string variables, A$ and B$.
Similarly, I was born with only two bug-storing-slots in my brain. At any
given time, I can only remember two bugs. If you ask me to remember three,
one of them will fall on the floor and get swept under the bed with the dust
bunnies, who will eat it.

	Joel Spolsky
	"Painless Bug Tracking"
%
A lot of software developers are seduced by the old "80/20" rule. It seems
to make a lot of sense: 80% of the people use 20% of the features. So you
convince yourself that you only need to implement 20% of the features, and
you can still sell 80% as many copies.

Unfortunately, it's never the same 20%. Everybody uses a different set of
features. In the last 10 years I have probably heard of dozens of companies
who, determined not to learn from each other, tried to release "lite" word
processors that only implement 20% of the features. This story is as old as
the PC. Most of the time, what happens is that they give their program to a
journalist to review, and the journalist reviews it by writing their review
using the new word processor, and then the journalist tries to find the
"word count" feature which they need because most journalists have precise
word count requirements, and it's not there, because it's in the "80% that
nobody uses," and the journalist ends up writing a story that attempts to
claim simultaneously that lite programs are good, bloat is bad, and I can't
use this damn thing 'cause it won't count my words. If I had a dollar for
every time this has happened I would be very happy.

	Joel Spolsky
	"Strategy Letter IV: Bloatware and the 80/20 Myth"
%
Whenever somebody gives you a spec for some new technology, if you can't
understand the spec, don't worry too much. Nobody else is going to
understand it, either, and it's probably not going to be important. This is
the lesson of SGML, which hardly anyone used, until Tim Berners-Lee dumbed
it down dramatically and suddenly people understood it. For the same reason
he simplified the file transfer protocol, creating HTTP to replace FTP.

You can see this phenomenon all over the place; even within a given
technology some things are easy enough to figure out and people use them
(like COM's IUnknown), while others are so morbidly complicated (IMonikers)
when they should be simple (what's wrong with URLs?) that they languish.

	Joel Spolsky
	Diary entry for April 2, 2002
%
When I was 6 and my dad brought home one of the world's first pocket
calculators, an HP-35, he tried to convince me that it had a computer inside
it. I thought that was unlikely. All the computers on Star Trek were the
size of a room and had big reel-to-reel tape recorders. I thought that there
was just a clever correlation between the keys on the keypad and the
individual elements of the LED display that happened to produce
mathematically correct results. (Hey, I was 6).

	Joel Spolsky
	"User Interface Design for Programmer - Chapter 2"
