Posted in March 2009

It’s time for web 1.0 to die

Yes, this is going to be a controversial topic to write on and yes, I have a history of terribly messing up controversial topics. But I’m going to make an effort to keep my thoughts clear and justifiable. Without sounding too academic, let me first present my thesis:

The original internet and World Wide Web was one of the greatest technological innovations of human history. It has an interesting history fundamentally linked to many other developments in the past few decades. Any self-respecting computer geek should take a few hours and read about the start and growth of the net. However, in the 21st century, the old web is no longer enough. It is time for us to accept that the old days of plain HTML and static links are just that: old days. I’m going to show that important developments have made it necessary for us to look at the web in a new light and we must actively embrace these changes so that we can have a hope of shaping them into something as monumental as the original web.

Clarification: I’ve received my comments that made me realize that I should clarify what I mean by web 1.0. For the rest of this post I’ll take it to mean the web in terms of mostly human-generated, static pages with mostly static content. By contrast web 2.0 can be defined to be mostly auto-generated, constantly changing content where the main human role is to create the content, not manage its organization or delivery.

Trip down memory lane

In many ways the start of the internet can be traced back to Douglas Engelbart’s famous Mother of All Demos in 1968. This demo showed of the revolutionary NLS (oNLine System) which was years ahead of its time and presented important concepts such as voice and video conferencing, complex document formats and hyperlinks.

Fast forward a few decades and the internet was slightly more mainstream by the early 1990′s. Though the internet had implemented Engelbart’s vision to some extent, it was actually quite primitive by the standards of the demo. Hyperlinks were simple one-way roads instead of the ubiquitous and powerful cross-linking system that was part of the demo. Rich media communication was still years away. However, the key parts were in place. The early web was a rather simple place to live in. Mostly text, followed later by simple graphics. Pages were static and more often than not crafted by hand. For much of the 1990s the web bore the signs of the academic and somewhat austere and information dense culture that had spawned it.

That web is not the web of today. With low bandwidth, information density needs to be maximized, presentation is often an afterthought. While there are a small number of producers and a large number of viewers, it’s fairly simple to do things by hand. The drastic change of the internet in the past few years can be attributed to two main causes:

  1. The growth of scripting languages and applications built on them have allowed a massive explosion in the number of content producers. It’s possible to build a fairly high quality website without writing a single line of code.
  2. Bandwidth, storage and processing prices have fallen, opening the door for rich media applications, which can be distributed across the Internet.

Dynamism’s Day

The game of web development has changed at a fundamental level. You can no longer ship a website to a customer and expect it to stay the same way for months at a time. Dynamic content is the order of the day. Blogs are no longer creations of random individuals with too much time on their hands. Instead, if you want to have a viable web presence, you’d better have a blog and you’d better update it regularly. This goes for individuals as well as corporations (especially those whose business is the web). This in turns means that hand-rolling a website is impractical at best and downright stupid at worst. A recent article proclaimed that Dreamweaver is Dying, and I have to grudgingly agree. Over the past two years, I tried maintaining an old style website by hand with mostly static content, but it’s simply not worth it. I would rather spend 5 minutes working on a new post than fiddling around with HTML and CSS to get things to look right. And don’t even get me started with keeping links and navbars up to date. Dreamweaver and similar tools help. A lot. But they’re not enough.

Web 2.0 is showing us an important fact that we must not ignore: content creators do not need to be programmers as well. What that means for you and me is that if you want to create a content-focused site (and that’s what most of us want really) then an automated content management system like WordPress or Drupal combined with good themes and widgets should be our first pick. Only if the need for customization becomes overbearing (ie. you need to forge a brand image with a custom logo and theme) should you consider diving into the code.

For web developers, this means that you should pick a content platform or two and learn it back to front and inside out. Try porting some previous designs and suggest that customers take a more active role in creating their web presence. The web’s hallmark is that it is by definition a bidirectional medium. If anyone wants to be successful on the web, that bidirectionalim must be respected and utilized.

To generate the best content, you want to have good tools. Unfortunately HTML and CSS simply aren’t good tools for writers, journalists or artists. They want, no, they need WYSIWYG editors where they can see what their content will look like without worrying about the layers beneath. Cheap bandwidth means you can now use heavier technologies like Flash to build better looking tools. Cheap storage and processing power means that you can generate the webpages on the fly while keeping the actual content neatly stored in a backend database. HTML and CSS aren’t the core technologies of the web anymore; they’re a thin veneer that hides the raw power underneath and gives everyone a simpler, focused view of what they need to see.

Let’s face it, HTML is ugly. It’s angle-bracket hell and you know it!! No human should have to write that sort of thing by hand. CSS is better, but not by much. A lot of people complain that autogenerators create really bad, really redundant HTML and CSS. That’s true and I thought that was a bad thing and I hand crafted my code until not too long ago. But the fact is: no one cares!! No one is ever going to really read your generated code except browsers and they’re mostly pretty tolerant of what they’re fed as long as it’s not downright wrong. The massive boost in productiveness far outweighs any aesthetic qualms you may have. Sure you still need to do some amount of tweaking to get things just right, but it’s very easy to get good enough without doing any tweaking at all.

On another note, the database + dynamic code creates far better presentation/data separation than HTML/CSS ever could. You had to be really disciplined to not mix presentation consideration into your supposedly semantically structured HTML and you never got it quite right. Admit it, you know you bent the rules. But with web 2.0, such separation is natural. Theming is at the heart of almost every major CMS out there and the web is a better place thanks to it.

But wait, there’s more…

CMS’s are just the tip of the iceberg. Web 2.0 is becoming an application platform, much closer to Engelbart’s vision than to Web 1.0′s “information highway”. It’s not just content creation and delivery, it’s active interaction that is getting the spotlight. And HTML/CSS utterly fails at this. Text and graphics are ok, sound and video are good, but active interaction is even better. Web apps may not be as feature-rich as their desktop equivalents, but they’re not far behind either. I use Google Docs almost as much as I use Word and web-based IDEs are starting to become a reality. Take a look at the SproutCore and Cappuccino web frameworks for some examples of what’s on the horizon.

The limitations of Web 1.0 have spawned the developments of multiple ways around them. The web is a now a mix of different document formats and PDFs are gradually becoming the document interchange format of choice for many organizations and companies. Streaming media has proved to be a much more popular alternative than simply offering up files for download. The dynamic web is a much faster and more interesting place than 1.0 could ever be.

We’re only starting to explore the web as a core component of personal computing. Cloud computing is still a very nascent technology, but one that looks like will it progress by leaps and bounds in the years to come. Amazon S3 lets you store practically unlimited amounts of data for really cheap making it possible for any technologically savvy individual or group to roll their own webapp without investing in massive computing resources first. Why buy a external hard drive when you can pay a small monthly free for crash-proof, access-anywhere storage? (If you trust them with your data that is, but that’s for another post…

Web 1.0 is simple and for the past two decades it has served the needs of human society admirably. But we need more now. There is a massive amount of computing power in the world today, but we can’t use it properly if we stick to old fashioned HTML. The internet is no longer a web of statically linked pages. It’s a complex network of rapidly changing web applications interfacing with each other on a number of levels. It’s more like a growing, vibrant ecosystem than it is a spider-web. Web 2.0 is alive.

In the near future…

We must learn to start treating the web like a vast collection of interacting programs and not just as a simple file hierarchy. The author of the Dreamweaver is dying article says (quite rightly):

In the relatively near future every website will be a dynamically-generated web application and all of today’s sites built on multiple static pages will be ripped out and replaced.

I think that is pretty close to the truth. Sure there will be still be some holdovers, but any serious website will have no choice but to become a distributed webapp: part of it running on a server (or server farm) and part of it running as a scripted application in your browser. Sure you’ll still need a grasp of HTML/CSS and their descendants (for a while at least), but you’ll use them in much the same you people do baking nowadays: you make special treats now and then, but you’d hardly ever bake your own bread.

Web 1.0 is dying. It’s passing can be painful, but it doesn’t have to be. Start using content management systems. I would recommend open source systems like Drupal, WordPress and Joomla. If you’re a developer, learn PHP and JavaScript while keeping your HTML/CSS knowledge in fair shape. If you’re building a web application or framework, make it easier for non-browser clients like other webapps to access data and functionality. The easier it is to use your servive, the more people will use it. Twitter and Google Maps seem to do this quite well. Don’t worry about supporting every version or every browser ever built. Pick 2 or 3 modern browsers and make sure versions released in the last year or two work well. Above all, don’t do anything to turn away the early adopters.

It’s time for web 1.0 to die an honorable death. It’s time for the rest of us to move on.

Tagged , ,

Sunday Selection 2009-03-08

It’s Sunday again and that means the second installation of my selection of interesting things from around the web. Here goes:

Reading:

Learn to program in ten years: As someone who intends to make a living working with computers, it’s in my best interest to be the best programmer I can. And besides, I really do like it. This essay from computer scientist Peter Norvig, is a response to the abundance of book that claim to teach you programming in a few hours or days.

Does Java still suck? Ten years ago ace hacker Jamie Zawinski (of Mozilla and XEmacs fame) wrote an article about the problems of Java the language and the platform. In the ten years since then Java has seen a lot of change. This recent discussion on Stack Overflow offers an in-depth looks at those changes. Of course, you’ll have to make up your own mind as to whether or not Java sucks.

Media:

The Physics of Watchmen: Watchmen is one of the most anticipated movies to be released recently, especially for comic book buffs. This video gives an idea about the physics behind the movie, in particular some of the characters’ superpowers.

Software:

Safari 4 Beta: Safari hasn’t been getting mixed reception lately. There are some who think its interface sucks while others think it rocks. And predictions of its security breaking before that of other browsers isn’t exactly encouraging. But why not just make up your mind for yourself and take a look at the newest beta. Enjoy

Getting things done simply with Google

Ok, I’ll admit it, I’m a bit of a productivity nerd. I read some blogs on personal productivity and I like trying out the latest and greatest tools that claim to make me more productive. Over the last few years, I’ve tried out a number of different tools and techniques, but I’ve never managed to stick to anything for more than a few weeks.

My latest attempt involved using Google Calendar to keep track of events that I needed to attend and Todoist as a task manager. The setup worked pretty well for a while, but some it wasn’t quite right. For example, I liked to make a weekly plan at the start of the week. I used Todoist’s projects feature to set up a project for each week and added a bunch of tasks. I’d make a toplevel task for each major work area for the week and put eveything I needed to do under that. This worked well for a while, but problems started to crop up. If I couldn’t get things done in a certain week, I had to move them from one week-project to the next. While this was ok for one or two tasks, it would become a pain for anything more. Being the tech enthusiast that I am, I started looking around for other solutions. I tried Remember the Milk and the Things application for the Mac. I rejected Things because it costs a pretty penny and I can’t afford to be tied to my desktop. Remember the Milk looked like a good possibility, but I just couldn’t agree with the interface. I couldn’t find an easy way to see all the tasks and I was afraid that unless I meticulously tagged and timed them, I would quickly start losing things.

Then I realized…

That the only thing that I really needed to keep myself organized was… lists. So I needed a simple list tool. Something that would easily let me see all available tasks, group them, move them about and add new ones. I also wanted that was thin on ‘features’ so that I wouldn’t get tempted to be all fancy. What was the bare minimum task manager I could get that was still fairly usable?

The simplest app I could find was Tadalist. It lets you make multiple lists and reorder them. That was close to what I wanted. But I did want a grouping mechanism, so that wouldn’t work. The answer, it turned out, was right under my door. Google recently integrated a simple task management app into Gmail. It’s simple and smoothly integrated into the Gmail interface. It has simple lists. No tagging, or labels or projects or any other bells and whistles. However, it does have a simple indentation feature that lets you indent lists one level in from the task above it. That’s good enough to help me distinguish groups of tasks.

To efficiently use Tasks, I set up two separate lists. One is the ‘current’ list, which contains all the things that I will be doing within the week. It has toplevel tasks for homework, this blog, other work and other projects. Anything that needs to be done goes into one of these categories. If needed, I can quickly create another category and put things down under it. I check off things once they’re done and clear the list of completed items when it gets too full (and I don’t need to remember what I’ve done). Every morning, I look through this list and try to schedule things using Google calendar. Calendar is then set up to set me reminders at times if I feel I need them.

The second list is my ‘inbox’ (GTD style). This is for everything that I might need or want to do, but know that I won’t have time for in the near future. Once a week I’ll be going through this list and moving things to current if need be.

This setup seems to be working quite well for now. There are some distinct advantages to this: it’s right in my email and I’ve learned to look it up every time I log in. Anything that comes in by email can be turned into a task easily. There is also a simple scheduling feature though I don’t really use it that much.

In the near future…

I hope that Tasks doesn’t go the way of some other promising Google products (such as Notebook). I would certainly like to see just a few more features added. Moving tasks between lists would be appreciated, even if it’s not drag-and-drop. Indentation is nice, but folding indented items would be nice to have. I also hope that they let Tasks talk to Calendar. It would be awesome if I could take a task, set a time for it and have it show up in my Calendar automatically.

Google Tasks provides a very lightweight task management tool. If you already have a comfortable setup with another tool, there really isn’t a compelling reason to change. Most tools have much more features. In all fairness, I could probably use Todoist the same way I use Tasks now. Also if you spend most of your time on one machine, a desktop app would be a choice worth looking into. What Tasks has going for it most at the moment is integration with Gmail and the possibility of tying into Calendar at some point in the future. Though I quite enjoy the setup, it’s certainly a set up most suited to minimalists.

Now get The Bytebaker by email

If you don’t use a feed reader and would still like to be reminded about new posts on the Bytebaker, you can now get new posts by email. Just the click the “Get The Bytebaker by Email” link in the right sidebar and you’ll be taken to a page where you can put in your email. After that you should soon receive a confirmation email and once you click the confirm link in that, you’ll start receiving an update whenever something new gets posted. Of course, you are also wel

The RSS feed for this site is handled by Feedburner (recently acquired by Google) and I’ve tried to have a regular email feature up before. However, I never quite managed to get it to work. As far as I can remember, emailing was offloaded to multiple third party providers, but I always had problems setting things up right. Now the process has become much simpler, with emailing becoming a part of the publication options.

No matter how many new communication electronic technologies  pop up, basic email is still one of the most widespread and most convenient forms. I hope this addition helps some of my readers stay on top things with just a little less stress. Let me know if you have any problems.

Languages, markup and quote unquote

I was at a lecture the other day and I heard the speaker say ‘quote … something something … end quote’. I don’t like it when people say ‘quote … end quote’ to show that they are quoting another source. I think it’s a very ugly way of talking. It seems that if you need to actually say ‘quote … unquote’ to let your listener when a quotation starts or stops, then you might as well start saying your commas and full stops out loud. Human to human communication is very interesting, especially when it is live. When two or more people speak there’s a lot more going on than simple interchange of meaningful words. The speakers tone of voice, inflection, the presence and duration of pauses, all combine to give a lot more information than the words on their own could. Good speakers use all these properties of verbal communication to make their words more effective and meaningful. I think that a proper use of vocal tone, rhythm and pausing can make it clear when a quote starts and when it ends. Unfortunately, it seems that most people don’t really think about this. There seems to be a thought that the presence of quotation marks in text means that there needs to be an equivalent expression when speaking. But this idea stems in part from an important fact being forgotten: spoken and written language are not the same thing.

Take a look at any piece of text. This post that you are now reading will do perfectly. When a language is written down, there is a lot more information than goes down than is actually spoken. Punctuation marks are the prime example. They’re special symbols that represent the elements of natural speech that don’t correspond to actual words. Periods and commas represent pauses. Apostrophes represent the omissions that are made as two words are merged to make speech easier or faster. They’re efforts to better approximate the non-factual parts of speech. But of course they don’t go the whole. Rhythm, speed and tone are hard to put in written form, at least for a language like English. Humans have been communicating with other humans for thousands of years now and we’re still not perfect at it.

This imperfection isn’t just limited to natural speaking or riding though. Computerized communication and information have their own set of problems. As an example, take the history of markup languages. Wikipedia defines a markup language as “a set of codes that give instructions regarding the structure of a text or how it is to be displayed”. Plain text has always been a sort of ‘natural’ medium for computers to information data. However simply recording the contents of the text is often not good enough. You want some information to tell different parts of the text apart. You can use this information to control how the text is displayed, or whether it has some special meaning to the computer. The TeX typesetting uses a markup language to give very precise instructions to a program (called tex) on how different parts of a document should be arranged when printed. The printing can be to paper as originally intended or some electronic format like PDF.

While Tex is focused on presentation, SGML and it’s popular derivatives HTML and XML target a different problem: what does the text actually mean ? How it looks is handled by stylesheets (CSS for HTML, XSLT for XML), which match the semantic components of the text to corresponding presentation style. This means that the meaning of the text can be kept separate from presentation and that multiple styles can be applied to the same content. And lest anyone tell you otherwise, presentation is important. Really important. The first iterations of HTML lacked any clearly thought-out presentation rules, leading to a proliferation of custom HTML pseudo-tags and the proliferation of table based layouts. CSS helped the situation at the cost of layering on yet another language with it’s own set of standardization requirements. XML is becoming very popular as popular data interchange format, however it is not without it’s share of flaws. Firstly, it’s very verbose. Writing any form of XML by hand is not an enjoyable task. It’s hard to throw together a quick regular expression to make sense of a large XML structure, but this is mitigated in part by the presence of some really good XML manipulation tools.

So much for the acronyms. Where were we? Information interchange. We still haven’t figured out the best way to do it, or even agreed on a good way to do it. Inert static data is one thing, but changing active data is quite another. Computer programs are in essence information. In the Lisp programming language there is no need for any differentiation between code and data. Code can be represented very easily as tree-like data structures and manipulated just as easily. This gives Lisp a level of expressive power that is orders of magnitude above any other programming language. Going the other way, you can just as easily transform your data into code. If you can find a way to store your information as Lisp-style S-expressions, then you can turn them into self-manipulating programs later. Of course, no one said it would be easy. Steve Yegge has a slightly dated but very appropriate article on just this topic.

So how does all this affect you and me? Honesly, I don’t really know. I know that many of the tools we have (both in terms of natural and computer language) are very good, but there certainly isn’t one size that fits all. You really shouldn’t be saying “quote … endquote” when you can change the way your voice sounds to signify the same thing. You shouldn’t be using XML when a simple regexp parseable solution. But you shouldn’t avoid XML if the alternative is writing your own deterministic finite automata that is soon going to rival an enterprise-strength XML parser in complexity. The problem, as they say, is choice. Make yours carefully.

Tagged , , ,
Follow

Get every new post delivered to your Inbox.

Join 331 other followers