Advocacy
Dojo (HowTo)
Reference
Markets
Museum
News
Other
Myths
Press
General
Hack
Hardware
Interface
Software
Standards
People
Forensics
Web
CodeNames
Easter Eggs
History
Innovation
Sightings
Opinion
Martial Arts
ITIL
Thought
|
Brief History
The Internet started as a bunch of network theory papers in the early 60's -- which grew into some Government projects (DARPA and the ARPANET) on building the network and early concepts. While good stuff, this is more the theoretical beginnings. There was a lot of early networking stuff but what had happened (quite by accident) was that these guys had created a foundation of a standard that built momentum. By the 1980's the commercial companies that all had built their own private network solutions started adding these standard Internet Protocols to their proprietary network solutions as a feature. Before the late 80's there were thousands of electronic bulletin boards, and independent networks -- lots of little "intranets" -- but the Internet became a way for them to talk to each other. The standard protocol eventually replaced almost all of those proprietary solutions and the momentum of the Internet (as a network) built a life of it's own.
But talking the same protocol didn't mean that everyone could read the same information. All that meant was that the networks could talk to each other, if you agreed on what language (and applications) you were going to use to share information. There was no standard way to present and navigate around. That is what really changed the net -- not standardizing the networking protocols -- but how you would present that information to users.
Many people love to start telling the story of HTML in 1989 with (Tim Berners-Lee) doing work at the European Center for Particle Research (CERN) in Switzerland. The story is how Lee couldn't exchange information with other researchers easily, so created HTML (Hyper Text) on a NeXT cube as a way to share navigable information and documents with other researchers. Later, (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 (all platforms) to read HTML, and the "Web" exploded. All this is true -- but it like telling the story of Cinderella by starting with the Prince finding some chick whose foot fit in the glass slipper -- there is a lot of story that happened before that. 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 (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 some combination of the two, to let the language (or a part of the computer language called the parser) know what it was operating on. In fact, these concepts go back much further in history to basic mechanics, basic math, and even basic language.
In the 70s and 80s people were playing with "tagged" text for many things. Word Processing (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 -- like:
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 to being printing with bold characters -- and of course when to stop. What a brilliant idea -- tags denote the way something would look or what operations were being done on some text, just like a computer language.
The concept took off, and soon there were lots of text/word processors for making documents that looked better that a typewriter. Tagged text became the basis for word processors for a while. But their life span was fairly short. Many programs were using these tags to denote the start and end of something -- but they were not displaying the pages in way that you could see what things were going to look like (because you had these tags littered throughout your document). WordPerfect came along, and created modes where it would sometimes interpret (see) bold text as bold, and italic text as italic. You still had to edit in tagged mode (or know the tags were there) but you could imagine more how things were going to look on the printer. (The printer and computer still used different fonts and formatted differently, but it is was a good start). Around this same time, the Lisa (and soon Mac) were doing real WYSIWYG (What You See Is What You Get) by using the same fonts and styles on screen and off (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, since you didn't need the tags anymore -- you could just see what things looked like. The tags were still in the documents (in order to save the file and remember where formatting changes occurred) -- but users never saw them anymore, and never knew about them at all. Users didn't have to worry about tags, since the presentation showed them what things should like.
Hyperlinks
Another concepts that is very old (from the 70s) was hyperlinks. The idea was that in some cases, you could use something inside of a particular tag, to point to something else -- another file or page. Why have everything as this long linear document, when you could more logically break things into little documents, using these tags/links to bind them all together. In fact, since word-processors couldn't work on huge documents and books all at once (they just didn't have the memory for it), you had to link chapters (and parts of chapters) together, in order to make them work. Then you could work with one small segment at a time -- but still navigate the whole book.
For the most part, this linking in word processors was linear -- a "continued in file xxx" link at the end of section. But people were smart and catching on -- why not allow indexes and table of contents to have bunches of links to take people to anywhere in their document group? Soon almost all serious word processors were allowing links and hypertext (in a primitive form).
The next big change happened in the mid 80s, there was a bit of a scuffle over BASIC on the Mac. Apple (specifically a guy named Donn Denman) had created a neat Object-based BASIC for the Mac with graphics and lots of cool stuff which was called MacBASIC. Microsoft made BASIC and didn't like the competition -- in their usual monopolistic way (even back in the early 80's), Microsoft threatened Apple with all sorts of ugly things (like Apple wouldn't be able to re-license Microsoft BASIC for the Apple][ ) if Apple didn't stop all development on MacBASIC. Apple stupidly capitulated and killed the superior MacBASIC, and Microsoft responded by soon killing their version of BASIC for the Mac as well -- leaving entry level programmers out of luck on the Mac. But like ripples in a pond, this had ramifications felt long and far.
The gap of not having an entry level programming solution really annoyed the hell out of one of the Mac programmers (Bill Atkinson). So on his own, he created an even easier to use (than basic) way of programming visually. He created HyperCard. What was HyperCard? It was a scripting environment that allowed you to embed tags that would bind pages (screens) together. Those screens could have graphics, and controls and buttons -- that could also link you to other pages. Some of this "hyper link" stuff had been done with text before -- but not to the degree, and not with all the graphics and controls and new aspects of little language built in. So HyperText as a concept really started to sink into the computer publics psyche. Which years later lead us to HTML.
So what is HTML?
HTML was just a way to borrow all the older concepts of tags and hypertext (with embedded graphics and controls) together, and apply it to this problem of no good standard way to read or browse files directly on the Internet. The way things worked was that you had to download files, then read them -- so browse (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 simple tagged text computer language, that could have primitive formatting in tags, and it could also have links to other files, and embed graphics. Other people in a group could edit and change those documents (and link them to more related information for research) in a process that we call "markup" (because they mark-up what you have given them). So what was this new things to be called? How about Hyper-Text Markup Language -- since that is what it did? Or HTML for short as we now call it.
So it all works pretty simply -- there is just a text file, and you wrap some commands (tags) around areas for various types of formatting. Tags are wrapped with "<>" -- so a tag looks like this <tag>. Beginning tags are the name, and ending tags have a "/". So some block of html text might look like:
This is a <b>test</b>!
Where <b> means "boldface", and </b> means end bolding.
From an HTML viewer (Browser) the file is automatically downloaded when you click a link, then the commands are interpreted to look like what they are supposed to. Of course there are many more commands, and some commands (tags) can be pretty complex -- but it is all just that easy. You make a request for a file, it gets sent to your machine and interpreted. Some files point to other files, or have other files (like images) included in them.
This simple concept was so hot, and so needed, that everyone leapt on board the bandwagon. It just exploded in popularity and ate all the previous formats in a matter of a few years. Everyone was enabled to use the same file format, and tag their text to link it all together, into one huge web of information. And the World-Wide-Web went from being a bunch of disjointed file servers and network services, into something so easy that a child could use to lookup porn. Heck, it was so easy that even adults could use it.
Now you know not only what HTML is, how it works, and also where it came from.
|
