Will Web 3.0 Bring the End of the Web Browser?

Man Using a Digital Tablet
Yongyuan Dai / Getty Images

I don't think web browsers will go away with the next big evolution of the web, but I wouldn't be surprised if browsers are re-invented at some point to better fit with how we surf the Internet.

Not that web browsers haven't changed since they first appeared. They have gone through massive changes, but it has been a gradual process with new ideas like Java, Javascript, ActiveX, Flash, and other add-ons creeping into the browser.

One thing I learned as a programmer was that when an application evolves in ways that it wasn't originally developed for, it starts to get clunky. At this point, it's often best to just start over from scratch and design something that takes into account everything you want it to do.

And it's high time this was done for the web browser. In fact, when I first started programming web applications back in the late 90's, I thought it was high time back then to create a totally new web browser. And the web has gotten a lot more sophisticated since then.

Web Browsers Are Ill-equipped To Do What We Want

It's true. Web browsers are horribly designed when you consider what we ask them to do these days. To understand this, you have to first understand that web browsers were originally designed to be, essentially, a word processor for the web. The markup language for the web is strikingly similar to markup languages for word processors. While Microsoft Word uses special character to designate to bold certain text or to change its font, it is doing basically the same thing: Start Bold. Text. End Bold. Which is the same thing we do with HTML.

What has happened over the last twenty years is that this word processor for the web has been modified to account for everything we want it to do. It's like a house where we've turned the garage into a den, and the attic into a spare bedroom, and the basement into a parlor, and now we want to connect the storage room out back and make it into a new room in the house -- but, we are going to run into all kinds of problems providing electricity and plumbing because all of our wires and pipes have gotten so crazy with all the other additions we've made.

That's what has happened to web browsers. Today, we want to use our web browsers as a client for a web application, but they really weren't meant to do that.

The fundamental issue I had with web programming, and one of the main reasons why browsers made poor clients for web applications, is that there was no good way to communicate with the web server. In fact, back then, the only way you could get information from the user was for them to click something. Essentially, information could only be passed when a new page was loaded.

As you can imagine, this made it very difficult to have a truly interactive application. You couldn't have someone type something into a text box and check information on the server while they typed. You'd have to wait for them to press a button.

The solution: Ajax.

Ajax stands for Asynchronous JavaScript and XML. Essentially, it is a way of doing what those older web browsers could not do: communicate with the web server without needing the client to reload the page. This is accomplished through an XMLHTTP ActiveX object in Internet Explorer or an XMLHttpRequest in almost every other browser.

Basically, what this allows a web programmer to do is exchange information between the client and server as if the user had reloaded the page without the user ever actually reloading the page.

Sounds great, right? It is a big step forward, and it is the key reason why Web 2.0 applications are so much more interactive and easy-to-use than previous web applications. But, it is still a Band-Aid. Basically, the client sends the server some information, and it sends a block of text back, leaving the client with the work of interpreting that text. And then, the client uses something called Dynamic HTML to make the page seem interactive.

This is quite a bit different than how normal client-server applications work. With no restrictions on data passing back and forth, and with the entire architecture built with an eye on letting the client manipulate the screen on the fly, using Ajax techniques to accomplish this on the web is like jumping through hoops to get there.

Web Browsers are the Operating Systems of the Future

Microsoft knew it back in the 90's. That's why they got into that browser war with Netscape, and that's why Microsoft pulled no punches in winning that war. Unfortunately -- at least for Microsoft -- a new browser war exists, and it is being fought on many different platforms. Mozilla Firefox is now being used by roughly 30% of Internet users, while Internet Explorer has seen its market share drop from over 80% to just over 50% in the past five years.

With current web trends like Web 2.0 and Office 2.0 bringing what were historically desktop applications to the web, there becomes more independence in the choice of operating systems, and more importance on standardized browsers. Both of which isn't good news to Microsoft whose Internet Explorer browser tends to do things differently than what most every other browser does. Again, not very good news for Microsoft.

But one great thing about using development tools on an operating system is that you can use standardized objects to create your interface. You also have a lot of control over how you interact with those objects, and can even create your own replacements. With web programming, it is more difficult to achieve this level of control, mainly because web browsers were not initially intended to be sophisticated clients for a large application -- much less be the operating system of the future.

But, more and more, that is what they are becoming. Google Docs already provides a word processor, spreadsheet, and presentation software. Combine this with Google's mail client, and you have your basic office software productivity package. We are slowly, but surely, getting to that point where most of our applications will be available online.

The increasing popularity of Smartphones and PocketPCs is creating a whole new frontier for the Internet. And, while the current trend is for the Mobile Internet to merge with the 'real' Internet, this doesn't discount the mobile landscape as a key player in shaping how the "Internet of the Future" will look.

One key aspect is that it creates a new front in the web browser wars. If Microsoft is to remain dominant with its Internet Explorer browser, it will have to achieve dominance on mobile devices with "Pocket IE," Microsoft's Internet Explorer for Mobile browser.

Another interesting aspect of how mobile devices are accessing the Internet is the use of Java applications replacing traditional web portals. Instead of going to Microsoft Live or Yahoo, mobile users can download Java versions of these websites. This creates an interactive experience that is the same as any client-server application without all the pitfalls experienced by web browsers.

It also shows that major web players are willing to design their sites for a new application development platform.

The Browser of the Future

I wouldn't place any bets that we'll see a major change in how web browsers are designed anytime in the near future. Whether or not Web 3.0 will usher in a new type of browser or go in a completely different direction is anyone's guess at this point.

But, at the same time, I wouldn't be surprised to see a brand new type of browser completely rewritten with web applications in mind revolutionize the web. It might take a major player designing it, and major players like Google and Yahoo and others getting behind it, which isn't the easiest thing to accomplish, but it is possible.

What would this browser of the future be like? I imagine it would be like merging our current browsers, ActiveX, and Java to create something that can be both a mini-operating system and a development platform.

For you and me, it would be like loading up our office application, seamlessly switching between a word processor and a spreadsheet, and just as seamlessly switching to a massively multiplayer online roleplaying game.

Essentially, each website would be an application of its own, and we could easily go from one website/application to the next.

What do you think Web 3.0 will bring?