Will Web 3.0 Bring the End of the Web Browser?

 

pop_jop/Getty Images

It seems unlikely that the web browser will go away with the next big evolution of the web, but there's a chance that they could be re-invented at some point to better fit with how we surf the internet.

A Brief Look Back on the History of the Web Browser

Web browsers have certainly gone through some interesting changes since they first appeared, 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 many programmers learn as they go is 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.

Many programmers out there might agree that it's high time this was done for the web browser.

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 few decades 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.

Why This Is a Problem

A fundamental issue with web programming, and one of the main reasons why browsers make poor clients for web applications, is that there's no good way to communicate with the web server. In fact, back in the day, 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 Possible Solution

Ajax stands for Asynchronous JavaScript and XML. Essentially, it's 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's a big step forward, and it's the key reason why current applications are so much more interactive and easy-to-use compared to previous web applications. However, this is still just 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 90s. 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. Internet Explorer once had 80% of web users. In 2019, Google's Chrome browser is used by 60% of users.

With current web trends 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 & Edge 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 tablets is creating a whole new frontier for the internet. And, while the mobile internet continues 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.

The Browser of the Future

You probably shouldn'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, don't be surprised to see a brand new type of browser that's completely rewritten with web applications in mind revolutionize the web. It might take a major player designing it, and major players like Google and Apple 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? Well, it could involve 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.