We already have this idea of "classes", thanks to CSS and how it interacts with HTML. Future specs of javascript (and many current js libraries) already include a getElementsByClass function that work with this as well as the getElementsById that already exists.

So we're already to an extent treating these elements as "instances" (with a unique ID in the DOM) of one or more "Classes". So why doesn't the Javascript conform to this?

What I'd love to see is for something like this:

HTML:

<div id="article-1" class="article">
<h3>Article Header</h3>
<p>Paragraph 1</p>
<p>Paragraph 2</p>
</div>
<div id="article-2" class="article">
<h3>Article Header</h3>
<p>Paragraph 1</p>
<p>Paragraph 2</p>
</div>

Nothing new there.

new CSS:

.article {
  h2 {
    padding-bottom:10px;
    border-bottom: 1px solid black;
  }
  p {
    padding: 5px;
  }
}

See what I did there? It's actually not that far a stretch. Typically this would be done by using ".article h2" and ".article p". This format mostly just allows for greater clarity in the CSS--at a glance--for what your style really expects elements to look like. Let's face it, styling has a dependancy on content--you can't theme a webpage unless you have some vague idea of what's going to be represented.

The next part is where I get serious:

Javascript:

class article {
  var header = this.getElementsByTagName("h3")[0]; // We expect only one of these
  var paragraphs = this.getElementsByTagName("p");
  var hidden = false;

  function onContentReady() {
    this.header.addlistener('onClick',this.hideShowContent);
  }
  function hideShowContent() {
    for ( var i in paragraphs)
    {
      if (this.hidden) { paragraphs[i].style.display = ''; }
      else { paragraphs[i].style.display = 'none'; }
    }
    this.hidden=!this.hidden;
  }
}

You get the idea, I think. Your non-class CSS defines what to do with elements occurring outside of classes, and gives styles that will cascade into classes unless overridden. Your non-class Javascript would include basic functionality used in many classes, and some of your classes might even require helper javascript classes that would be pulled in at need, and only once. (say, a date picker class that is required by several parent classes).

You could even separate your class-based js and css out, storing them locally, and providing "glue" in your base-level javascript, so that whenever the browser loaded a class it had not already seen in the DOM, it would look at that glue, and go and fetch the necessary JS and CSS if necessary.

This means that unless there's an Article on the page, you'd never load the Article css and javascript. The javascript and CSS would never be loaded more than once.

Clearly, my example is not incredibly good--the idea could probably use a lot more work, but what strikes me as funny is that when I look at it this way, it seems like it's almost meant to be. Javascript/ECMAScript is constantly improving and is at this point a full-fledged programming language in its own right, albeit one without a canonical interpreter. HTML and CSS specs are constantly improving as well, but there is a divide sharply between the two. I wonder if perhaps Javascript not being under the purview of the W3C has something to do with how separate it is from the HTML/CSS setup, and why they don't seem to be converging, aware of each other, toward something cleaner.

As I was stumbling through the internet a moment ago I came across an interesting photo of an underwater restaurant that is enclosed entirely in glass such that the diners have a constantly changing view of underwater life while they eat. Looked really cool. There was the obligatory comment as the third or so on the page:

"Definitely photoshopped. I can tell by the pixels, and I've seen a lot of 'shops in my time."

Given the fact that goons are known for stockpiling clubs and hunting dead horses for years at a time, the comment should come as no surprise to anyone. But I just thought of something, three little letters that are like gold to any business: "EAV".

EAV stands for Equivalent Ad Value. When companies get positive face time on large networks such as a news network or paper or a highly trafficked website, they are essentially getting ad space for free. And it's extremely valuable ad space, because it is placed in content spaces where people are actually looking to read the content. Here's an example: My company, TripAdvisor, got mentioned a couple months back in the show "The Office". If anyone remembers, it's the episode where Dwight Schrute opens an Agrotourism Bed and Breakfast at Schrute Farms. Its page is still at tripadvisor, and the clip is up at both tripadvisor and youtube. The mention cost us very little, but the value of it is exceptionally high, since it is in front of millions of people across the US who watch the show.

for an even better, slightly less biased example, Research In Motion says it estimates that it had millions of dollars of EAV from the whole "Barackberry" debacle, and I'd believe it. Think of him what you will, there is no denying our President's intelligence and simultaneous stardom, and if he uses a RiM smartphone, then hell, shouldn't I look into it. They paid nothing for that plug, and they didn't even expect or look for it. The fact that Obama didn't actually use a blackberry doesn't matter at all.

So now we go back to this meme: it seems there are like 20 goons or farkers or the like who spend hours a day going across thousands of websites and delivering equivalent ad value to Adobe with this tired joke, and you know what? They hit all the highest trafficked images first. I'll bet it's worth tons.

They wrote that these machines are supposed to select and aim at a target, and "[wait] only for a human to pull the trigger." Except that sometimes, "these machines start firing mysteriously on their own."

They call it a software glitch. A malfunction. The problem I have with these terms is that, similar to the term "accident" in a traffic collision, they tend to imply no one is to blame.

I submit that somewhere, some programmer is to blame. If you write code, no matter how trivial, your job is to ensure the efficiency, consistency, and most of all the accuracy of your code. To fail in this regard can be tantamount to negligent homicide.

Coding errors can cause great cost; in the simplest of projects, this cost may only be in time, but soon that cost becomes money. In greater projects, it might be personal possessions, or public relations, or in still greater projects, lives.

This is not the first time something like this has happened. I am reminded of the infamous Therac-25, which between 1985 and 1987 was involved in at least five deaths due to poor interface design and failure to sanitize inputs. The Northeast Blackout of 2003, caused by a race condition in power monitoring software. The MIM-104 Patriot whose failure resulted in the deaths of 28 soldiers in Saudi Arabia in 1991 due to an error in time synchronization.

These are our responsibilities, laid upon us by virtue of our interest in the technologies which run our world today and those that will tomorrow: To provide value through technology by relieving stresses in tasks, or by relieving those tasks altogether, and to protect ourselves and our fellow man from those very technologies we create, and to the best of our abilities, from himself.

~Pigsflew

According to Reisinger, linux has either three directions from here: 1. Become super user-friendly at the expense of the tweakability and under-the-hood capacity of linux, 2. go back to "linux' roots" and follow Linus Torvalds, or (and here I quote) 3. "face a "civil war" that could lead to total Linux annihilation."

I'd like to present something to you. In the good old days of the Microsoft world, we had MSDOS, a relabeled version of the "Quick and Dirty Operating System", QDOS. In this world, everything was configurable. You could do anything you wanted. Unfortunately, because doing anything complicated took too many steps, people didn't often do much. This is why they developed (following Apple), Windows. Now Windows didn't do much, but what it did do was easier and more honed to human beings than was the command prompt.

Windows took a step further from that with WinXP and Vista, wherein the command prompt, while still there, is crippled to the point of being barely usable.

On the other hand, Apple's newest, OSX, is a BSD-derivative operating system, and while it has a fully functional and exceptionally usable GUI, it also has a complete shell available to the user, with approximately all the tools from Linux/BSD available.

This "civil war" Reisinger presents is a fear that's ungrounded. I am an Ubuntu user. This is because the simple tasks that I perform on a daily basis, as well as the setup tasks that prepare the machine to meet my standards, are made extremely easy for me, and with minimal interference. It's important to me that the terminal remain always available to me, that I can still write and run bash scripts, that, when it's faster to do so, I can still fire up a shell.

But I shouldn't be forced to.

This is where the dichotomy becomes entirely flawed. There is nothing that says an operating system can not be both oriented toward usability, and fundamentally malleable. A person should be able to fire up an application and have it, within reasonable tolerances, do what he or she expects. This is a mark of a conscientious programmer; any code which is not designed with, or with the ability to have, a GUI attached should be viewed as nearly wasted code.

Linux' roots are the same place that any other operating system's roots are: a collection of applications and machine code which enables the user to utilize the capabilities of the machine. An operating system which does not do this is an unfinished operating system.

Unlike any other operating system, we can keep working together to finish Linux.

I want other people to use Ubuntu. I've been putting up posters, wearing stickers, giving out burned copies, telling people about it, I've been evangelizing this because as an OS, Ubuntu is almost finished. It's friendly, it's usable, and I don't have to hold a newcomer's hand quite as hard to get them into it. It's not about money, because I can't, don't, and won't ask for any--and I don't think Canonical ever will either.

What I want is users. I want a whole boatload of us. I want enough of us out there that choose Linux over non-*nix that open source libraries start getting used to reach us. I want games designed by corporations in OpenGL2, rather than DirectX. I want applications to be released using Mono instead of .Net; I want these things to happen so that anyone, anywhere, on any operating system--Even Windows!--can use everyone else's software. And that's only plausible if we get attention.

So I applaud Mozilla for providing the best cross-platform browser and email client, Canonical for the easiest Linux distribution, HP for their open printer drivers, System76 and Dell for providing preinstalled machines, Blizzard for already releasing OpenGL games (like World of Warcraft), and all other companies that stand behind the choice of the user.

A song by The Verve, with a fairly large sample from an orchestral song by the Rolling Stones, this song was in the end the Verve's downfall, as they can no longer play it without the Mick Jagger's permission.

The song is most notable for the Bittersweet Hypothesis, outlined below. The phenomenon was noted by the University of Awesome's own Professor Adrian during his research on Jesus' iPod

The Bittersweet Hypothesis

The hypothesis states that, for all music players, as the time of ownership of said music player increases, the probability of that player containing The Verve's Bittersweet Symphony approaches one.

Exhibit A: Topical graph outlining the basis of the hypothesis

Supporting Evidence

1. If you have a music playing device, take it out.
2. Turn it on and look for Bittersweet Symphony.
3. If it's there, I told you so.
4. If it isn't, it'll probably be there soon. Also, you're an outlying data point.

Consequences

The consequences of the Bittersweet Hypothesis are dire. The most important one is that this song may cause severe clogging of the tubes.

There are over 7 billion people in the world. if one in 20 people have portable music devices, that makes 350 million such devices. Each one will in all probability eventually cause a download of Bittersweet Symphony, which is approximately 4 MB, or megabytes, or million bytes. This turns into 1.4 Billion megabytes, or 1400 Terabytes of the same song repeated over and over. Now, remember that for most portable devices, the song is also repeated on a personal computer, doubling the number to 2800 TB of the Bittersweet Symphony.

Just for good measure, that number is roughly 2,800,000,000,000,000 Bytes, which are 8 bits each, 11,200,000,000,000,000 bits (Eleven thousand two hundred million bajillion infinity).

Solutions

Several solutions have been proposed to resolve this issue. One is to create a central data center to store a single copy of the 4 MB file, and then every music playing device would have to stream it from there, but unfortunately this does not resolve the problem of clogging the tubes, it only reduces the places it ends up stored.

According to Joshua, the supercomputer from War Games, it is "an interesting game. The only winning move is not to play." It has been suggested that the song be banned from the tubes in order to protect them from this magnitude of clogging.

That said, lets talk about the application designs in these systems. In Windows, it seems that everything is about integration. We have a mail application--oh wait, no, it's also a calendar, and a contact management system. In fact, if we're Netscape, let's go ahead and throw an html editor and a browser in there for good measure. They have a file browser that also understands HTML, CSS, Javascript, embedded applets, and of course the dreaded ActiveX, which allows a "trusted" web site (say, microsoftupdate.com) to modify your operating system.

This is not a bad thing, it's a frame of mind called "Integration" that is fairly pervasive in both the Windows world, and the Open Source world. For a linux/OSS example, Ximian Evolution is in fact almost an exact one-to-one equivalent of Microsoft Outlook. They had the Mozilla Suite, which was effectively exactly what Netscape was. KDE's Konqueror Browser is every bit as stupid as Microsoft for throwing an integral operating system piece -- the file browser -- at the unpredictable internet.

But OSX has something new, something everybody is quickly realizing is a good idea, and something other companies have been reproducing ad nauseum to varying effect: Widgets. The widget is a small program that does exactly one thing, but when doing that one thing it runs like the wind.

Why is this good? Let me explain the concept of Disintegration. If I want to browse the internet, I open firefox, not because it's the greatest web browser ever, but because it's just a web browser. It opens quickly, and if something on the internet breaks it, Oh no! I might have to reinstall it. Nothing else can be easily affected by its failure. The fact is, I don't want to wait for my email server before I can quickly add a new homework assignment to my Gnome Calendar, because I'm forced to use Ximian Evolution to update it.

OSX doesn't only do this in widgets, it separates everything. Mac Mail is a mail client, nothing more. iCal is a calendar, with no nonsense. Safari is a web browser that does one thing extremely well. Why can't we learn from them? All of these programs are light, fast, and do exactly what you want without doing anything you don't: I'll tell my computer if I want my mail. Right now all I want is my calendar.

Integration is okay when it's modularly integrated. An application that works with another application to use data from it is a good idea. An application that shares libraries in order to access common information from the Operating System is a good idea. But a single application that controls everything is not.

Let me finish with a cry for help: Ximian Evolution sucks. I want Gnome-calendar to let me update those extremely useful calendar views on the system clock without it. Pretty please?

Row 01: 1  0  0  0  0  0  0  0  0  0  0  0  0
Row 02: 0  1  0  0  0  0  0  0  0  0  0  0  0
Row 03: 0  0  1  0  0  0  0  0  0  0  0  0  0
Row 04: 0  0  0  1  0  0  0  0  0  0  0  0  0
Row 05: 0  0  0  0  1  0  0  0  0  0  0  0  0
Row 06: 0  0  0  0  0  1  0  0  0  0  0  0  0
Row 07: 0  0  0  0  0  0  1  0  0  0  0  0  0
Row 08: 0  0  0  0  0  0  0  1  0  0  0  0  0
Row 09: 0  0  0  0  0  0  0  0  1  0  0  0  0
Row 10: 0  0  0  0  0  0  0  0  0  1  0  0  0
Row 11: 0  0  0  0  0  0  0  0  0  0  1  0  0
Row 12: 0  0  0  0  0  0  0  0  0  0  0  1  0
Row 13: 0  0  0  0  0  0  0  0  0  0  0  0  1

Formatting and much of text was borrowed (But from an uncopyrighted document which is in the public domain!), and the original can be found here