Hackers & Painters: Big Ideas from the Computer Age

by Paul Graham

The ambitious are not content to imitate. The second phase in the growth of taste is a conscious attempt at originality.

think the greatest masters go on to achieve a kind of selflessness. They just want to get the right answer, and if part of the right answer has already been discovered by someone else, that’s no reason not to use it.

GOOD DESIGN IS OFTEN STRANGE.

Most of the qualities I’ve mentioned are things that can be cultivated, but I don’t think it works to cultivate strangeness.

The only style worth having is the one you can’t help. And this is especially true for strangeness.

GOOD DESIGN HAPPENS IN CHUNKS.

Nothing is more powerful than a community of talented people working on related problems.

At any given time there are a few hot topics and a few groups doing great work on them, and it’s nearly impossible to do good work yourself if you’re too far removed from one of these centers.

GOOD DESIGN IS OFTEN DARING.

Today’s experimental error is tomorrow’s new theory.

In practice I think it’s easier to see ugliness than to imagine beauty.

Intolerance for ugliness is not in itself enough. You have to understand a field well before you develop a good nose for what needs fixing.

The recipe for great work is: very exacting taste, plus the ability to gratify it.

The complete list of things a computer can do is its machine language.

In assembly language the list of commands is the same, but you get to use more programmer-friendly names. Instead of referring to the add instruction as 11001101, which is what the machine might call it, you get to say add.

A compiler is a program that translates programs written in a convenient form, like the one liner above, into the simple-minded language that the hardware understands.

The more convenient language that you feed to the compiler is called a high-level language.

When you get to build your programs out of bigger concepts, you don’t need to use as many of them. Written in our imaginary high-level language, our program is only a fifth as long. And if there were a mistake in it, it would be easy to see.

Another advantage of high-level languages is that they make your programs more portable.

If you wrote your programs in machine language, you’d have to rewrite them all to run them on a new computer. If you use a high-level language, all you have to rewrite is the compiler.

The high-level language that you feed to the compiler is also known as source code, and the machine language translation it generates is called object code.

But the advantage of open source isn’t just that you can fix it when you need to. It’s that everyone can.

Most programmers, most of the time, program in high-level languages. Few use assembly language now.

Fortran, Lisp, Cobol, Basic, C, Pascal, Smalltalk, C++, Java, Perl, and Python are all high-level languages.

Part of the problem is that if you use a language for long enough, you start to think in it. So any language that’s substantially different feels terribly awkward, even if there’s nothing intrinsically wrong with it.

extremes. Languages do differ, but it’s hard to say for certain which are best. The field is still evolving.

language, some high-level languages are more abstract than others. For example, C is quite low-level, almost a portable assembly language, whereas Lisp is very high-level.

always. A language can be very abstract, but offer the wrong abstractions. I

Another reason you might want to use a lower-level language is efficiency.

If you need code to be super fast, it’s better to stay close to the machine. Most operating systems are written in C, and it is not a coincidence.

Indeed, many historians believe that the wars were a byproduct of the forces that created the Renaissance.3

like species, languages will form evolutionary trees, with dead-ends branching off all over.

Java will turn out to be an evolutionary dead-end, like Cobol.

The evolution of languages differs from the evolution of species because branches can converge.

Convergence is more likely for languages partly because the space of possibilities is smaller, and partly because mutations are not random. Language designers deliberately incorporate ideas from other languages.

Any programming language can be divided into two parts: some set of fundamental operators that play the role of axioms, and the rest of the language,

It’s important not just that the axioms be well chosen, but that there be few of them. Mathematicians have always felt this way about axioms — the fewer, the better

The right way to solve that problem is to separate the meaning of a program from the implementation details.

The word “essay” comes from the French verb “essayer,” which means “to try.” An essay, in the original sense, is something you write to try to figure something out. This happens in software too. I think some of the best programs were essays, in the sense that the authors didn’t know when they started exactly what they were trying to write.

Inefficient software isn’t gross. What’s gross is a language that makes programmers do needless work.

This is the same argument you tend to hear for learning Latin. It won’t get you a job, except perhaps as a classics professor, but it will improve your mind, and make you a better writer in languages you do want to use, like English.

When you choose technology, you have to ignore what other people are doing, and consider only what will work best.

startup. In a big company, you can do what all the other big companies are doing. But a startup can’t do what all the other startups do. I don’t think a lot of people realize this, even in startups.

course. If you do everything the way the average startup does it, you should expect average performance. The problem here is, average performance means you’ll go out of business.

experiment. Our hypothesis was that if we wrote our software in Lisp, we’d be able to get features done faster than our competitors, and also to do things in our software that they couldn’t do.

No one was leaking news of their features to us. We were just able to develop software faster than anyone thought possible.

A startup should give its competitors as little information as possible.

in general, for application software, you want to be using the most powerful (reasonably efficient) language you can get, and using anything else is a mistake, of exactly the same kind, though possibly in a lesser degree, as programming in machine language.

After a certain age, programmers rarely switch languages voluntarily.

Programmers get very attached to their favorite languages,