Guido van Rossum Quotes

Actually, I didn't make the claim that Ruby follows the principle of least surprise. Someone felt the design of Ruby follows that philosophy, so they started saying that. I didn't bring that up, actually.

Adding functionality is not just a matter of adding code.

Trivia rarely affect efficiency. Are all the machinations worth it, when their primary effect is to make the code less readable?

A 'goto' in Perl falls into the category of hard things that should be possible, not easy things that should be easy.

Rushing to optimize before the bottlenecks are known may be the only error to have ruined more designs than feature creep. From tortured code to incomprehensible data layouts, the results of obsessing about speed or memory or disk usage at the expense of transparency and simplicity are everywhere. They spawn innumerable bugs and cost millions of man-hours - often, just to get marginal gains in the use of some resource much less expensive than debugging time

I used to be enamored of object-oriented programming. I'm now finding myself leaning toward believing that it is a plot designed to destroy joy.

We flew down weekly to meet with IBM, but they thought the way to measure software was the amount of code we wrote, when really the better the software, the fewer lines of code.

The important point is that the cost of adding a feature isn't just the time it takes to code it. The cost also includes the addition of an obstacle to future expansion. Sure, any given feature list can be implemented, given enough coding time. But in addition to coming out late, you will usually wind up with a codebase that is so fragile that new ideas that should be dead-simple wind up taking longer and longer to work into the tangled existing web. The trick is to pick the features that don't fight each other.

Programmers are always surrounded by complexity; we cannot avoid it.... If our basic tool, the language in which we design and code our programs, is also complicated, the language itself becomes part of the problem rather than part of its solution.

There's only one trick in software, and that is using a piece of software that's already been written.

Show me your flowcharts and conceal your tables, and I shall continue to be mystified. Show me your tables, and I won't usually need your flowcharts; they'll be obvious.

Programs should be written and polished until they acquire publication quality.

There is a point in your life when you realize that you have written enough destructors.

Modern programs must handle Unicode —Python has excellent support for Unicode, and will keep getting better.

There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.

Learning to program has no more to do with designing interactive software than learning to touch type has to do with writing poetry

People are building the software and so having the pieces be such that a single person understands all the tradeoffs and everything that's going on in a piece is extremely valuable. It avoids getting into an experimental mode where you're just trying things out. That never works.

I note that the Python folks still think they like JPython. I wonder how long that will last?

Java and C++ make you think that the new ideas are like the old ones. Java is the most distressing thing to hit computing since MS-DOS.

I'm reminded of the day my daughter came in, looked over my shoulder at some Perl 4 code, and said, 'What is that, swearing?

I made up the term "object-oriented," and I can tell you I did not have C++ in mind.

Another trick in software is to avoid rewriting the software by using a piece that's already been written, so called component approach which the latest term for this in the most advanced form is what's called Object Oriented Programming.

The flip side of the coin was that even good programmers and language designers tended to do terrible extensions when they were in the heat of programming, because design is something that is best done slowly and carefully.

Even if you aren't in doubt, consider the mental welfare of the person who has to maintain the code after you, and who will probably put parens in the wrong place.