Weblog Without Honor or Humanity

Programmers don’t steal enough.

Now that I have your attention: what I really mean is that software designer do
not take advantage of the Giants as much as they could.

It’s sad that the act
of building on the works of others, a necessity for progress, is labeled as
stealing by those who are blinded by dreams of easy money so much that they fail
to recognize that everyone, including themselves, is better off in a world where
we can freely build on ideas of others. Unfortunately those people have enough
money, bad taste and political savvy to force upon us copyright terms of insane
lengths and damaging patent policies.

Wise people recognized long ago that we all owe a big debt to those who came
before us for their ideas and whatever our contribution to the pool of knowledge
might be, it’ll be miniscule compared to collective knowledge gathered so far
that we were able to build upon.

If I have seen further it is by standing on the shoulders of Giants.
- Isaac Newton

It’s scary to think what will happen if patent system will degenerate to the point when
it’ll allow monopolizing fairly obvious yet crucial ideas. What would happen if
someone secured a patent for text editing system, making it impossible to create
a competing text editor. What would happen if someone secured a patent for
client-server communication making it impossible to create web (or one of
hundreds useful applications)? Everybody would suffer because the whole computer
industry would freeze. One lucky soul could charge monopolistic prices for the
only implementation of text editing idea but it would lack the incentive to
improve it. Both high-prices and lack of features would lead to meager adoption.
The vendor might think that he’s in heaven but everyone else would be much worse
off than in an alternative universe where thriving competition drives the prices
down and quickly improves the software making it useful and affordable for more
people, indirectly stimulating hardware purchases which in turn stimulates
creating more kinds of software. Ironically, the vendor would also end up with
smaller revenues than in the alternative universe because free competition would
create a market much bigger and one lucky winner that would dominate this market
would earn profits unheard of in any other kind of enterprise.

So let’s take
advantage of the fact that we’re not yet in a world like that. Thousand flowers
can still bloom and your mission is to take existing flowers and make them
slightly better. Let’s rip off each other’s ideas, let’s build on each other’s
work, let’s compete - that’s the way to make users happy. I claim that we don’t
do it nearly enough. You would think that because of fierce competition good
ideas in software would immediately get replicated but my observations rather lead me
to nod with understanding when I’m reminded of those words:

Don’t worry about people stealing your ideas. If your ideas are any
good, you’ll have to ram them down people’s throats
- Howard Aiken

Below are a few examples of neat software ideas that I’ve seen in at least once
and would like everyone else to copy in their products.

1. Emacs has a great
implementation of the "intelligent auto-completion" feature. While it’s a
standard feature in many (although not all) IDEs those days it usually only
works for a specific kinds of text e.g. it might auto-complete C/Java
function/method names and parameters and it requires pre-population of the
auto-completion data. Emacs will build the list of suggestions by parsing the
current text so it learns from what you’ve already typed. Works wonders - I
became depended on this feature a few hours after discovering it. Now every
editor that doesn’t have it is painful to use. Please, o unknown programmer,
steal this idea.

2. There are 2 popular ways to implement spell-checking:

• user has to invoke a menu item, gets a dialog box and is forced to
  sequentially go through every misspelled word in the document and decide
  whether it should be replaced, ignored, added to dictionary etc. Gets annoying
  if you spell-check the same  part multiple times and have to ignore the
  same words over and over again.
• pointing out misspelled words directly on the screen by e.g. putting read
  squiggly lines underneath and letting user to correct spelling using
  mouse-activated context-menus

The second method has been with us for quite some time and is obviously
better that the first one yet there are still programs that do it the hard-way
(e.g. Macromedia Dreamweaver).

3. There are more than 2 ways to implement searching in a text editor. One
popular way is to have a permanent Find dialog box with a field to enter text
we’re searching for and a button for Find Next. The dialog box will sometimes
obscure the text we’re working on requiring us to move it around. Some pervert
designers also force us to use mouse in order to switch the search directions
(i.e. either forward or backward) by making this option a drop-box or a radio
button. Why this design is still in use while there is a superior solution:
pop-up the dialog only for entering the text to search, pressing enter dismisses
the dialog and navigates to first match. We also have key strokes for Find
Previous and Find Next actions (I like to map them to F3/F4 keys). That way
there’s no need to use the mouse, no need to take your hand away from the
keyboard - that’s important for all the touch-typists out there.

Additionally Emacs has a small improvement of this idiom: it highlights all
the matches in the currently visible portion of the document.

4. Bookmarks in a text editor are quite useful when writing code. For example
imagine that you just wrote the .h file with function declarations and you’re
writing the implementation in a corresponding .c file. I usually find myself
unable to remember the exact details of what is the name of the parameter x or
what exactly is the name of a function etc. so I have to frequently switch
back-and-forth between the files to refresh my memory. If that’s only two files,
you can usually get by with other methods (just switching between buffers in
Emacs or arranging the display to see both files at the same time) but I found
that if the feature is well implemented then I prefer to use it even in two
files case and the more places you need to bookmark the more valuable it
becomes. But here’s the tricky part: "well implemented". It’s crucial that
navigating to bookmarked places is quick. I’ve seen only one editor that
implements it well: Source Insight. With a single keystroke (Ctrl-M) you can
both set a bookmark and navigate to a bookmarked place (don’t just believe me,
download free evaluation version of Source Insight and play with it). Sadly,
Emacs implements bookmarks poorly - key sequences are too long that managing
bookmarks is more trouble than it’s worth it. So if you implement a text editor,
here’s an idea for you: steal Source Insight’s bookmarks management. It’s
excellent.

5. People who use third party file managers (instead of built-in Explorer)
are usually power users. They might need to drop into command line to do things
that are not easy to do from GUI like grep through files, launch compilation
etc. I first saw this feature in Total Commander: there’s additional text edit
field at the bottom of the window. If you type something there and press enter,
it’ll be executed as a command in the directory that is shown in the active
pane. It’s a great feature that saved me a lot of time (as compared to
explicitly launching cmd window and mindlessly navigating to the directory that
I already have selected in my file manager). Yet not every file manager has it.
The result is that I won’t be using those file managers: once I’ve tasted the
usefulness of it, I refuse to use a tool that doesn’t give it to me.

Maybe we should have a collection of such "best design for doing foo"
somewhere on the web. Then if, for example, someone created a new text editor
and it lacked some of the useful features or implemented them in a way inferior
to existing implementation, we could send him a link to this page and say: dude,
we’re not gonna use your software until you implement all those features.
Please, do implement all the great ideas you have that make your text editor
better than others, but this is your baseline. Anything worse than that is not
gonna cut it.

Software can always be better.

I told you that Frigate is the best file manager I know but it doesn’t mean that
I think that it couldn’t be better. Recently I wrote about the need for being
consistent. Ironically, there’s another, opposite side to this story: it seems
that usually people just stick with the tried ideas which makes for suboptimal
progress in software. The best place to observe that is in a category with lots
of competition e.g. file manager, simple text editors or, to use a recent
example, Wikis or RSS aggregators. It looks like the first entrants create such
a strong precedent that the followers are usually content with copying them and
adding just a few, relatively small features. I rarely see a radical
improvements or a significant number of new features in any given applications.
They slowly grow as a whole because everyone copies other people’s features
(which is good) but when I look at the difference between Frigate and Norton
Commander I’m really disappointed by the progress in the state-of-the-art of
file management apps in more than 10 years. There’s probably more than one
reason for that:

• writing software, in general, is hard
• there’s probably not much money in the "just another file manager"
  business (given the insane competition from free stuff (including Explorer
  built into Windows) and other file managers) so it’s probably fairly easy to
  whip up something that is comparable to existing stuff but much harder to
  justify investing into making it much better

I’ll make a claim that part of the problem is software designer’s mental
block caused by existing implementations that are good enough. The solution to
that problem? A conscious effort on finding and implementing new, useful
features. (Here I have to note that Apple, with their iApps, is doing a good job
by significantly improving upon tired (you would think) concepts like music
player or chat.)

Here are my ideas for a few features that I haven’t seen in existing file
managers.

Build a database of files. It’s not, by any means, a novel idea but I haven’t
seen anyone doing it. The reason is that it makes it possible to improve some
features. For example, finding files by name on a hard-drive is still painfully
slow because scanning the file system of a large hard-drive is slow. If we had
names and other vital properties indexed in a database it would be very fast
(probably even possible to provide interactive performance). The same holds for
calculating the size of a directory: it’s slow if you re-scan all files in a
directory with lots of files. If we had this data pre-calculated, there’s no
reason to have it always displayed. Of course, there are problems with this
approach: you have re-scan the hard-drive periodically and you cannot guarantee
being always in perfect sync with the hard-drive but those disadvantages are
minor compared to what they enable.

Virtual folders. In a way virtual folders are already in: most file managers
enable you too treat a zip file as a directory but I want more. Once we have
file names, their sizes and other important meta-data in a database, why
shouldn’t I be able to create virtual folder that shows the files matching an
arbitrary SQL query. That’s ultimate flexibility. How would it be useful? For
example I frequently view PDF files, create text files or Excel spreadsheets,
view Word files, PowerPoint files etc. The files are never in the same directory
so when I want to switch from within Adobe Acrobat Reader between a currently
viewed PDF files in my d:downloads directory
to a PDF file in "My Documents" directory I have some folder navigation to do.
Annoying if you do it often. Applications usually try to make my life easier by
providing a list of a few recently used documents but those are
application-specific fixes and I usually find myself accessing more documents
than the length of this list. If I had my imaginary friend I could create a
virtual folder with 10 (or 20 or whatever is the appropriate limit for me)
recently accessed Excel spreadsheets or Word documents or PDF documents. Or I
could have one folder for all those types of documents. Or I could have a folder
with manually maintained list of files that I access most frequently (program
could even help me choose which files are those by watching which files I access
most frequently). Or I could have a virtual folder than only shows jpeg files
from all my hard-drives. I could view the files in this folder in a traditional,
hierarchical view or as a flat list. I could also sort them as in a regular
folder i.e. by name or data. Or I could search for files matching given name but
only restricted to the folder with jpeg files. And it all would be fast. Think
how easy would it be to browse through my collection of digital photos, how easy
would it be to find recently taken pictures.

Integrated ssh/sftp. It’s the Internet era, god damn it. I’ve seen ftp
integration but not ssh/sftp (there’s WinSCP,
which is mostly about ssh but it’s a lousy file manager - I want first-class
file manager with first-class support for ssh).

Break out with 2-pane tradition. Here I’m not convinced that it’s even a good
idea but it’s certainly something that could be tried. Why do we usually have 2+
panes: because that’s makes it easy to move files between directories (we see
both the files we selected in the source directory and the destination
directory). Explorer has only one pane and you can copy files by selecting them
in source directory, doing Ctrl-C, navigating to destination directory and doing
Ctrl-V. Possible but inferior to the 2-pane way because we might loose track of
what is it that we’re copying and it’s not possible to select files from
multiple directories at once. Can we improve upon that? Imagine that we only
have one pane but it gets split vertically when you select files. The bottom
shows currently selected files (you unselect files by removing them from that
bottom view). This allows us to select files from multiple directories at once,
we always know what files are selected and to copy/move files to a different
directory we just navigate there and press F5/F6. We could improve upon that by
adding tabs so we can easily navigate between frequently accessed folders (the
bottom view with selected files wouldn’t change).

Good software, bad buying experience.

Now that I told you that
Frigate is the best file manager I know, I’ll tell you that
Frigate - the company sucks.
My 30-day trial period just ended so I went on-line and bought "Frigate
Professional" ($59.90 but if you know the right URL you can get it for $39.94)
via RegSoft. That was 3 days ago and I still don’t have the registration info
and as a result can’t use the software. When I ordered I received a confirmation
e-mail with a link to a web page with my order status. That’s all good except
that the status still is "unprocessed". I don’t know if it’s RegSoft that sucks
or is it Frigate so uninterested in my money but I’m pissed, I don’t care and
I’ll never buy from them again (and would cancel my order if I could).

The
thing is: the Internet creates an expectation of instant gratification. I pay
and I expect to have the goods within minutes given that what I’m buying is a
link where I can download a few megabytes of code or an unlock code for the
software that I already have. I expect that because it’s possible and everyone
else gives me that. The guys selling Frigate violated this expectation. The
result: no more money from me and this post where I tell everyone that they
suck.

Lessons:

• when you sell software, provide instant gratification
• when you sell software, avoiding pissing  people off is even more
  important than delighting them (you should do both, of course)

Why consistency is important in software design.

I have a problem: none of the available file managers really meet my needs.
There’s always something that bothers me either because a feature is missing or
(I think) could work better. That’s why I’m constantly looking for something
better. I’ve tried many file managers: Salamander, Total Commander,
Frigate (and a few others that I cannot
recall so easily). Out of those I tried Frigate is the best but I keep looking
and that’s why recently I tried another one: Directory Opus. I remember
Directory Opus from my Amiga days: it was THE file manager on that platform,
packed with features and nice to use. Amiga went down and took the whole market
for Amiga software with it but it looks like Directory Opus folks averted the
disaster by porting their software to Windows. This post is about how they lost
a potential costumer (me) because of lack of consistency with Windows.

File
managers have long history, dating back to DOS days and Norton Commander who
ruled that market (and was cloned multiple times). On Windows we have two
general styles of file management:

• one that works just like Explorer (built into Windows)
• second that works more or less like Norton Commander

By now we all expect some things to work a certain way: F5 is copy, F6 is
move, F2 is rename, Ins selects a single file, you have two panes, you can
drag-and-drop files between them using a mouse etc. There’s no particular reason
to use F2 instead of Ctrl-C except that everyone excepts Ctrl-C to mean "Copy
from a clipboard".

Every file managers seems to implement the golden standard set by Norton
Commander. That is: every except Directory Opus. You might think that this is a
small thing but it’s not. I was quickly infuriated by things not working the way
I was expected them to behave. Among other things:

• there’s not right-click-drag-and-drop (which usually allows me to choose
  move/copy/create shortcut when I perform drop)
• F5, F6 (and probably many others) aren’t mapped to the same operations as
  in NC
• Ins doesn’t select/deselect a file (in fact, there doesn’t seem to be
  possible to do it not using the mouse which renders keyboard navigation
  largely useless)

Customization is possible so I was able to fix at least some of the keyboard
mappings but I quickly gave up on Directory Opus even though it seems to be a
very solid product, has all the basic capabilities and maybe even has features
not available anywhere else.

The moral of the story: don’t be gratuitously different than anyone else. Be
as consistent with the platform as possible. There are cases where you simply
find a better way of doing things and that justifies being different, but
keyboard mappings aren’t the place to innovate.

My future is so bright that I’ll need to wear sunglasses.

I wonder how sympathetic people will be to Eric Kidd’s plea formulated in The Missing Future article. There’s a little bit for everyone: a bit of Microsoft bashing, a bit of love-and-hate relationship with open-source and a bit of nostalgia for the lost days
of the golden era of software entrepreneurship when you could change the world *and* make lots of money as a small software developer. As for me, the article tickles me the wrong way.

You see, I’m almost like Eric. I’m almost the same age, I’m a programmer too and have the same dream: create great software, make gobs of money and retire young on a sunny island. Eric sees a problem: the dream is no longer possible. He paints a bleak picture of the future.
To him only two versions of the future are possible:

• in first version Microsoft dominates the market so much that it’ll
  immediately crush any competition taking all the profits from all the possible
  software ideas
• in second version open-source dominates the market so much that it’ll
  replicate any good idea, leaving no profits at all (effectively crushing the
  "competition")

Eric hesitantly prefers the open-source-only future but isn’t entirely happy
with either, he prefers the glorious past (last 25 years which is 1978-2003)
where small software developers were the lifeblood of personal computer
revolution and were building great, innovative software making millions in
the process. Except that:

• neither of the 2 (completely opposite) futures is likely to develop
• there’s plenty of room to build software and make money without running head-first into Microsoft
• on the average, open-source is no competition at all
• the past wasn’t so glorious as Eric wants to believe
• what will Eric do?

Let’s take those one after one.

To paint the possible future Eric just extrapolates the most obvious present trends, which are: Microsoft’s dominant position on the market and the raise of open-source.
So either Microsoft will become even more dominant or open-source will raise to
total domination instead. Predicting the future was never easier. Let’s see what would happen if we applied the same logic 20 years ago. If we were to be so insightful:

• in 1982: VisiCorp would be the biggest software company today (they were the biggest then)
• still in 1982: today Digital Research would be bigger than Microsoft (Microsoft only overtook them in 1983)
• in 1984: today Lotus would rule them all (as it did then)

(Data courtesy of A history of software industry.) Looks like the algorithm didn’t work in the past and I see no reason why it should work today. Things change, paradigms shift, companies make mistakes, Roman empires fall. There’ll always be a number one and there’ll always be many whining that the existence of number one makes it impossible for them to create good software.
In the future there will be number one, but there will also be number two,
number three and number three thousand. There will be open-source and there
will be commercial software.

The other pop-cultural misconception in the software business is that if you develop anything good Microsoft will either crush you or buy you. Never mind that it can be proven to be untrue (Photoshop, Macromedia and Flash, Adobe Acrobat, Quicken) and that the existence of positive examples (like Borland or Netscape) proves not that you can’t compete with Microsoft but that you have to know how to compete and how to avoid making mistakes. Just like Adobe or Intuit or Macromedia managed so far. But wait, isn’t Eric talking about “small software developers”? Neither of the companies he mentioned to support his thesis were small (what that proves is that on the web you can get away with sloppy thinking and people might even agree with you or applaud it as excellent content).

I remember one sentence from Innovators
Dilemma: “small markets don’t serve the growth needs of big companies”. Translation: for Microsoft (or any big company) to even entertain entering a market it has to have a potential of bringing millions of dollars of yearly revenue. There aren’t that many markets/products that have that potential. On the downside:

• you’re not even entertaining entering a mature market like that (e.g. by writing another Great American Word Processor), are you?
• you’re unlikely to create such novel product anyway, so stop worrying about Microsoft eating your lunch when you do
• even if you create such novel product, you’re unlikely to stay the biggest player in the field for long, with or without Microsoft’s competition. That’s what happened with databases, spreadsheets, word-processors, C compilers, Unix clones etc. On the other hand, in the extremely unlikely case you do create a truly novel product with
  mass-market appeal, you’ll most likely retire to a sunny island anyway.

On the upside there’s plenty of products that one can build that while not bringing billions of dollar will still be useful for many people and will bring respectable amounts of money.

Let’s move on to competition from open-source. On average, there isn’t any. People are usually blinded by the staggering success of few open-source project like Linux (which is good enough to be a viable threat to Windows) or Apache (which still owns the web server market). But extrapolating from such data is like predicting how fast an average person can run by averaging the speed of
Olympic medalists. Let’s look at more realistic data: today the most active project on SourceForge is Gaim (activity is a rough guide of how actively a given project is developed.) Not only it has a closed-source “competitor” but it seems that the competition is doing well enough to pay the salaries of 7 people and Trillian is simply a better product (personal opinion based on trying to get Gaim running on Windows and
being annoyed by crashes and badly designed user interaction). Are you afraid of competition like that? This is pretty much cream of the crop open-source project and it only has 10 developers. That’s 30 times less than Eric’s hypothetical 300 developers bent
(still hypothetically) upon cloning your product. Most projects SourceForge have around one part-time developer and are in constant hunger for more
but there aren’t more developers willing (or being able) to code for free. The big wave of growth in open-source was due to internet. At some point there was an influx of new people exposed to the ideas of open-source and they got involved with it. I believe that we reached an equilibrium:
some new people come to open-source but others go and the overall number doesn’t change much. Open-source will be with us forever but it will never be the only way.
To put it another way: I’ll be very old when GIMP puts Photoshop out of
business.

The past wasn’t so much better for small software companies than present is. Eric is concerned about two things:

• ability to create innovative software
• ability to make money out of it

If we look at the ability to create great software present is better than the past and future will be better than present. The hardware can only become faster and more powerful making new
kinds of software possible (would you attempt to process 6 mega-pixel digital photo on an Apple II?)
and old kinds of software are getting faster and easier to use. As an industry, we gradually make small improvements and learn from others so the average quality of an application should improve. If we’re lucky from time to time we’ll get another great boost like the internet
one. Things can only get better.

If we look at the ability to make money, things are less clear. On the one hand, more computers mean bigger potential market. Better/faster computers mean a market for new kinds of software, kinds that didn’t exist before. Same for new technologies (e.g. because we got network, a market for web browsers or IM was created; because we got digital cameras, a market for
software for managing photos was created; because we have re-writeable CDs/DVDs, a market for CD/DVD burning software was created etc.) Thanks to the internet selling and promoting your software was never easier. On the other hand the competition increases. Competition coming from all sides: open-source, other small software companies, big software companies (if you’re lucky). It also gets harder to create a significant application i.e. it’s probably unrealistic to repeat VisiCalc and create a break-through product with only 2 people on the board).

So there are trade-offs but the important question is: if my goal was to create software and make a killing, would I rather be thrown 20 years back when a ridiculously under-powered computers cost ridiculous amounts of money and were available to a ridiculously small number of people? Would I rather be thrown in pre-internet days where making the software available to people was as hard as writing it? Or would I rather do it now? I choose now.

So what will Eric do? That’s the part where it gets surreal. He says:

The small companies offer me no visions. They can’t build platforms; they can’t challenge Microsoft…If you want my support, and the support of others like me, propose a vision.

Apparently, Eric will just wait for others to do the job for him and complain bitterly if they don’t. What started as an essay from the point of view of a software
entrepreneur ends up laying blame for the bad things on some vague, collective entity (”small companies”). Why anyone owes Eric a vision? Why any company needs to seek his support? Ever heard the wise words of Gandhi ?

As for me, my future will so bright that I’ll need sunglasses. I’m delighted to live in an era when all it takes to sell software I might (or might not) write is to spend few bucks on a web site and register with one of many e-commerce providers. I’m delighted that the availability of the Internet opened so many new opportunities that we only began to scratch the surface of what’s possible. I’m delighted that open-source provided me with a set of free tools to write software and lots of code to learn from (and in some cases to take and use in my own software).
I’m delighted that I live in times when new ideas/software/services/companies
are created daily, things like web, IM, eBay,
p2p, file sharing, BitTorrent,
blogs, MT and blogger,
google, Yahoo, Amazon.com,
Watson, Napster, iTunes,
Chandler, Palm,Pocket PC,Hiptop,perl,Python…
the list goes on and on. I’m delighted that I have a shot on Cold Stone.

The only thing standing between me and the mythical innovative software and gobs of money is my ability to have great ideas and to work hard to bring them to life.

Now, excuse me, I have some software to write…

Business lessons from Adobe.
This article cought my
attention. I think there are several important lessons about software business
that can be inferred from it.

Lesson one: seek out new products. Adobe is most famous for Photoshop but it turns
out that currently Acrobat makes more money for Adobe than any other product. It’s
easy to remain a one-product company, it’s hard to take a risk and fund new products.
If the new product fails, it might get you killed. But if you don’t take risk, you
might get killed anyway (history of computing is filled with dead bodies of once-succesful,
one-product companies like Ashton Tate (dBase) or WordPerfect). If you succeed at the hard thing, you might get handsomely rewarded (Microsoft is an example of a company that perfected
this strategy - they try almost anything that might be profitable).

Lessone two: have a vision. According to the article:

Warnock, who has retired from running the company, could say he told you so. From the early days when he tacked up fliers to “sort of sell it within the organization,'’ the gray-bearded intellectual was Acrobat’s biggest supporter. In its earliest stages he called the project “Camelot,'’ because it envisioned a perfect world where the incompatibilities of digital documents vanished; in a 1991 memo describing the project Warnock declared that “if this problem can be solved, then the fundamental way people work will change.'’

I don’t think PDF/Acrobat “changed the way people work” so it failed terribly at fulfilling its vision. However, it became fairly succesfull product creating gobs of cash for Adobe. What we can tell from that is that having ambition bigger that what actually was produced didn’t hurt and I do think that it helped them and that they wouldn’t be here if they just set out to create a boring software for viewing

Lesson three: be persistent.

“In the early days we were spending quite a bit of money on Acrobat development,'’ Warnock says. The project missed sales expectations every quarter for the first three years. “The board of directors at every board meeting would question whether it would amount to anything.'’
Warnock persevered.

This is a dangerous lesson (as every generalization from a one-time event is) but notice this: Microsoft became the biggest software company mostly by being persistent and funding DOS/Windows/Office as long as it took to make them the best and most popular. Same happen for Adobe and Acrobat. On the other hand, Corel also persists in competing with MS Office (Corel Office) and Adobe’s Photoshop/Illustrator (Corel Draw/Corel PhotoPaint) but more and more it looks like a path of self-destruction. So let’s amend that lesson.You should persist if:

• you’re deeply convinced you’re right
• it helps to have a unique product like Acrobat (as opposed to Corel’s also-rans)
• you can afford loosing (again Microsoft is a great example: they failed more times than they succeed and it works for them becaue they can afford the failures)

And finally a lesson that no-one is really able to follow: avoid bias. Avoid seeing everything as a nail just because all you have is a hammer.

Some at Adobe thought that Acrobat PDF should be the main language of the Web, rather than HTML (hypertext markup language), which has become standard. HTML is fickle, and will cause the same page to look differently depending on the computing platform.

It’s so easy to believe that they thought that even though it shows a gross misunderstanding of what makes web popular and valueable (hint: it’s not about publishing documents with perfect layout; it’s about the ease of publishing of documents even if they look shitty). Heavy bias is common. Microsoft had the same idea except they wanted to replace HTML with Word’s file format. Netscape was telling anyone who would listen how their browser is a new platform that makes the OS irrelevant. If you want to know why you shouldn’t believe your own hype and avoid bias just look who’s irrelevant now.

Another ArsDigita story. Another one in the series.

Color theory 101. Knowing how to choose good colors might be useful in web design.

More Treo 600 news. Info about new Treo 600 is now all over the place. Previously missing information: it’ll have 32 MB of RAM and ship in October. According to this Handspring shipped 330 k of Treos so far (but 100k might be unsold).

Treo 600 - more info. CNET has more information on upcoming Treo 600. On the picture looks very nice. It’ll have OS 5.2, (finally) SD slot, (unfortunately only) 160×160 color screen, a keyboard and will be available through Sprint and Orange.