From MacWeek, March 9, 2000http://macweek.zdnet.com/2000/03/05/0309dke3.html
The history and basics of HTML
By David K. Every
What is HTML, how does it work and why did it cause the Web to explode in popularity? HTML was preceded by the Internet, word processing programs and a batch of servers and many internal networks..
The story began almost 40 years ago. The Internet began life in the early 1960s as a bunch of network theory papers which grew into some government projects (the Defense Advanced Research Projects Agency, or DARPA, and the ARPANET, the Advanced Research Projects Agency Network) on building the network and early concepts. While the papers were good, they were more the theoretical than the practical beginning of the Internet. There was a lot of early networking -- but what had happened, quite by accident, was that these people had created the foundation of a standard that built momentum.
By the 1980s, commercial companies had built private networks and started adding these standard Internet Protocols as a feature to their proprietary networks. Before the late 1980s, there were thousands of electronic bulletin boards and independent networks--lots of little intranets--that could talk to each other using the Internet.
The standard protocol eventually replaced most of those proprietary solutions. The momentum of the Internet as a network built a life of its own.
However, using the same protocol didn't mean that everyone could read the same information. It meant that the networks could talk to each other as long as they agreed on the language and applications being used to share information. There was no standard way to present information and navigate around it.
What really changed the Internet was not standardizing the networking protocols, but changing how that information was presented to users.
The birth of HTML
Many people love to tell the story of HTML beginning in 1989, when Tim Berners-Lee was working at the European Center for Particle Research (CERN) in Switzerland. Lee couldn't exchange information with other researchers easily, so he used a NeXT Cube to create HTML, or HyperText Markup Language. That way, he could share navigable information and documents with other researchers.
In the early 1990s, the National Center for Supercomputing Applications (NCSA) at the University of Illinois enhanced and bastardized the protocol using their Mosaic browser, to add more features and to allow anyone on any all computing platform to read HTML, causing the Web to explode in popularity.
While all this is true, it's like telling the story of Cinderella by starting with the Prince finding a woman whose foot fit in the glass slipper. There is a lot more to the story that happened earlier. The real key to opening the Internet is hypertext and how it works.
Tagged text
Computer languages, all the way back to the beginning, started using a syntax or list of commands and rules to explain what a computer should do -- in painful detail. Many of those languages used beginning and ending tags to explicitly state what you were supposed to do something to.
Imagine:
Do something to everything contained [from here]
-- lots of other instructions or text in here --
[to here]
The beginning and ending tags could be words, symbols or a combination of the two. The tags would let the language, or a part of the computer language called the parser, know what it was operating on. These concepts go back much further in history to basic mechanics, basic math and even basic language.
In the 1970s and 1980s, people were playing with tagged text for many things. Word processing, which was originally called text processing, was an early application of these concepts. Instead of just text on a page, what if a person could put tags in a page?
For example:
This is a [begin bold] test [end bold]
Then when someone printed out the page, the print engine could know that some commands "[begin bold]" could be mapped to special characters (that only a printer could love) to tell the printer when to begin printing with bold characters and when to stop. What a brilliant idea -- tags denote the way something would look or which operations were being done on some text, just like a computer language.
The concept took off. Soon there were lots of text or word processors that could make documents look better that a typewriter could. Although tagged text became the basis for word processors for a while, their life span was fairly short. Many programs were using these tags to denote the start and end of something, but were not displaying the pages in a way that allowed users to see what they were going to look like because tags were littered throughout the document.
WordPerfect came along and created modes that would sometimes interpret bold text as bold and italic text as italic. Although users still had to edit in tagged mode or know the tags were there, they could imagine how a printed document would look. (The printer and computer still used different fonts and formatted differently, but it was a good start).
The arrival of WYSIWYG
Around the same time, the Lisa -- and soon the Mac -- were offering real WYSIWYG (What You See Is What You Get) by using the same fonts and styles on- and off-screen. (Xerox had done this in labs for years, but Apple expanded many of the ideas and brought them to market.)
True WYSIWYG viewing almost immediately killed tagged text for word processors. Users you didn't need the tags anymore; they could see what things looked like. The tags were still in the documents, to save the file and remember where formatting changes occurred, but users never saw or knew about them any more. The presentation showed them what things should like, so users didn't have to worry about tags.
Hyperlinks
As with tags, the concept of hyperlinks dates from the 1970s. The idea was that in some cases, you could use something inside of a particular tag to point to something else, such as another file or page. Why have everything as one long linear document, when you could more logically break things into little documents, using these tags/links to bind them all together?
After all, word-processors couldn't work on huge documents and books all at once -- they just didn't have the memory for it. That meant users had to link chapters and parts of chapters together to make them work. Then you could work with one small segment at a time, but still navigate the whole book.
Linking in word processors was usually linear; for example a link at the end of section might read: "continued in file xxx."
But people caught on and asked: Why not allow indexes and table of contents to have bunches of links to take people to anywhere in their document group? Soon most serious word processors were allowing links and hypertext, if in a primitive form.
The BASIC scuffle
The next big change happened in the middle 1980s, when was a scuffle erupted over BASIC on the Mac. Donn Denman at Apple had created MacBASIC, a neat object-based BASIC for the Mac with graphics and lots of cool stuff.
Microsoft, which made BASIC, didn't like the competition. In its usual monopolistic way (even back in the early 1980s), Microsoft threatened Apple with all sorts of ugly things (for example, Apple wouldn't be able to re-license Microsoft BASIC for the Apple, if Apple didn't stop all development on MacBASIC). Apple then killed the superior MacBASIC, and Microsoft responded by soon killing its own version of BASIC for the Mac, leaving entry-level Mac programmers out of luck.
Ramifications of the BASIC scuffle, like ripples in a pond, were felt far and wide.
The birth of HyperCard
The lack of an entry-level programming solution really annoyed Bill Atkinson, one of the Mac programmers. So on his own, he created HyperCard, which was a way of programming visually that was even easier to use than BASIC.
HyperCard was a scripting system that allowed programmers to embed tags that would bind pages, or screens, together. Those screens could have graphics, controls and buttons that could also link to other pages.
Some of this hyperlinking had been done with text before -- but not to the same degree, and not with all the graphics and controls and new aspects of little language built in. HyperText as a concept started to sink into the computer public's psyche, leading years later to HMTL.
What is HTML?
HTML was a way to borrow all the older concepts of tags and hypertext (with embedded graphics and controls) together, and apply it to the problem of the absence of a good, standard way to read or browse files directly on the Internet.
Users had to download files and then read them, so browse, or read, in place was one of the most important changes they could make. They used the simple old-style word processing document format of a tagged text computer language. It could have primitive formatting in tags and it could also have links to other files, and embedded graphics.
In addition, other people in a group could edit and change those documents and link them to more related information for research in a process called markup, because they mark up what you have given them. This new method was called HTML, or HyperText Markup Language, since that is what it did.
It all works pretty simply. There is a text file with some commands (tags) wrapped around areas for various types of formatting. Tags are surrounded by angle brackets (Ðð) -- so a tag looks like this Ðtagð.
Beginning tags are the name, and ending tags have a "/". So a block of HTML text with bold tags, where Ðbð means "boldface", and Ð/bð means end bolding. might look like this:
This is a ÐbðtestÐ/bð!
The file is automatically downloaded from an HTML viewer, or browser, when a user clicks on a link. Then the commands are interpreted to look as they are supposed to.
Of course there are many more tags, and some can be pretty complex -- but it is that easy. After a user makes a request for a file, it gets sent to the machine and interpreted. Some files point to other files, or have other files such as images included in them.
This simple concept was so hot -- and so needed -- that everyone jumped on the bandwagon. HTML exploded in popularity and ate all the previous formats in only a few years. Everyone could use the same file format and tag their text to link it all together, making a huge web of information.
The World Wide Web went from being a bunch of disjointed file servers and network services into something everyone can use.
It's so easy a child can use the Web to look up something, including porn. The Web became so easy that even adults could use it.
Contributing Editor David K. Every is a software engineer and editor of the MacKiDo Web site. He's been playing with and programming Macs since 1984 and can be reached at dke@mackido.com.