Once upon a time, in the late 20th century, we had rich desktop software patterns. Each program was creative and interesting in its structure and design. Programs like Winamp, Excel, Word, PowerPoint, Lotus Notes, Quicken, Act, and more all were as different as can be. There were designers specializing in “human factors”, but mostly these programs were designed by the software engineering department (or the original entrepreneur).

The patterns were not consistent, but most can be traced back to Xerox Parc and its invention of WIMP. (windows, icons, menus, and pointers) This design language was used in the making of the first GUI (graphical user interface) which was launched to consumers in the Apple Macintosh led by Steve Jobs.

If you would like to hear the crazy stories from this period, watch Triumph of the Nerds 1996. It’s crazy how all of this started.

All software updates were handled by installing a new version of the program. All logic was performed on the local machine which bulked up the programs. The software were called “thick” because of this. Upgrades were expensive to roll out because you had to get floppy disks to all of the computers.

Software at this time was developed using complex C++ programming.

The invention of the modem started a new kind of distribution. You could dial into a server and download software without a floppy disk. This new kind of service reached mass appeal with AOL. The amount of programs you could try exploded. So many interfaces were introduced by amateur software developers using the newer Visual Basic language. AOL itself was distributed with a flood of CDs embedded into every magazine and sent to your home. Updates though were handled through the modem itself. This was a new innovation. The AOL software had the local component and the server component. The local side did not have all of the logic and was smaller. It was dubbed a “thin” client.

The world wide web took off 1995 with the introduction of the Netscape browser. This was direct competition to AOL. It was AOL or the Internet. People thought AOL would win because they could control the experience. Obviously, they were wrong.

In 1995, Netscape had no CSS, no JavaScript, not even tables. It was honestly pathetic. The only thing you could do was make a web page. You could not make “software”. The best you could do was make linkable pages. The pages were modeled after scientific papers or help docs, which was the closest UI pattern. Text, bullets, links and a few images; that was a page. Every site had a complex sitemap, with no real information architecture.

Once JavaScript and CSS (or Macromedia Flash) were available, we could make more interesting interfaces. Unfortunately, something terrible happened.

The big mistake

In 1998, when this ultimate thin client could have been born, with unique interfaces in a browser, a choice was made. The choice was to conceive of web applications as “interactive web pages”, not as software.

Interactive web pages were still modeled after documents. They were still “pages”. It was all long scrolling pages with charts and tables embedded in the middle. All of the thick client UI patterns were lost to designers who had not been taught their rich history.

The “great forgetting” continues to this day as most designers are not taught the history of UI. They perpetuate the same stale patterns over and over again. They make enterprise applications that look like websites with many pages and a mega menu.

If you want to understand what is lost, you only need look at mobile and tablet software. Because the form factor and gestures are so different, the creativity is alive and well there. Because mobile is so much smaller than a desktop, new UI ideas had to be invented. On your phone, the software is much more diverse and interesting than enterprise software on the web.

Of course, there are exceptions. Google Maps was a breakthrough in UI design on the web. Google GSuite and GDrive are modeled after true software, not web pages. There are many examples of this. Unfortunately, enterprise software lags behind.

If you make enterprise software, think about the information architecture. Is it customizable? Are you allowing the user to define what they want or are you shipping your org chart with a mega menu? (Conway’s Law)

I remember a designer telling me a few years ago that a tree structure to organize a users experience is “old” and “outdated”. This is exactly what I think designers are missing. They don’t understand why a tree structure is so powerful. They don’t understand hierarchal abstractions. Meanwhile their Figma UI has a tree right there on the left! (Irony)

Anyway, this is probably a book, not a blog post. It just seemed interesting to me. Carry on and keep designing!