Some of the blame might rest with the job title: “technical editor” is no match for web industry jobs with titles that include the word wizard, genius, guru, or ninja. The title technical editor makes the role sound like it’s for the resident apostrophe nazi. Banish that thought; we already have a word nerd. What we need is a real web nerd.

If you are someone, or know of someone, who enjoys tinkering with stuff on the web just for the fun of it, and then sharing your knowhow, this might just be the perfect job — getting paid for staying up to date with web technology and working with a bunch of hardcore web geeks who share the passion.

The 16GB 3G iPhone is still up for grabs for a successful referral too!

The biggest news this week was that Adobe have finalized their educational licensing and ColdFusion 8 is now available to students and educators free of charge. Government agencies in the US can get a 20% discount on ColdFusion 8 at the moment as well.

Coding

A couple of security posts this week – hat tip to Steve Bryant’s CF_BlogPicks for these links:

• Joshua Cyr reminds us to make sure we’re not giving away too much information on our production servers
• Jason Dean continues his security series (9th installment) with Request Forgeries and ColdFusion

In more general code-related news, Stephen Withington has out together a big list of Java Servlet equivalents to CGI scoped variables – so instead of CGI.PATH_INFO for example, you can use getPageContext().getRequest().getPathInfo(). The comments on the post explain a little about why you might find the Java Servlet alternatives more useful.

Paul Marcotte explains his approach to test driven development in detail – part 1 (Application Structure and Apache) and part 2 (MXUnit, ColdSpring and ColdMock) are available.

Ben Nadel, always one to share his learning experiences, has posted about his first experiences using ColdFusion 8 secure CFFTP. Brad Wood explains what the de() function actually does. And Raymond Camden still hates CFFEED.

Frameworks

Mach-II news: Matt Woodward reports that the alpha of the Mach-II Dashboard has been released. According to Matt, the dashboard “gives you a ton of insight into and control over your Mach-II applications, letting you reload the application or individual modules, reload the base or child ColdSpring bean factories, manage logging, and manage caching.”

An on the Fusebox front: Sean Corfield reports that Jeff Peters’ book How to Drive Fusebox 5.5 is now available for purchase. Being a Fuseboxer myself, I’ve ordered my copy already – Jeff’s previous Fusebook books were great.

Community

Brian Rinaldi took a week off his Open Source Update last week – I don’t know if you missed him, but I certainly did. This week he’s back with four new projects, 12 updates, and a whole ton of announcements, tutorials, presentations and reviews.

After a bit of a hiatus, I’m getting back into the swing of my CF-TALK mailing list roundups. Last week’s summary included discussion threads on SQL Injection, Web Services, Academic Licensing and Career Advice.

A Wee Dram of Scotch – the mini Scotch On The Rocks conference being held in London on September 25 – now has a full program and is open for registration (hat tips to Andy Allan and Sean Corfield). With the stars in the lineup and at only £10, I dare say it’s going to sell out quickly.

Alternative CFML Engines

Gary Gilbert has posted his impressions of Railo 3, after meeting Gert Franz and Michi Streit at the Munich CFUG. Gary was impressed by the “strict” variable scoping setting in the Administrator, the Amazon S3 resource, and the extension framework.

Michael Sprague has released a beta of CFjqAjax, a library of custom tags to replicate ColdFusion 8’s Ajax UI controls CFGRID, CFWINDOW, and CFTOOLTIP with jQuery equivalents. This is great news, not only for people who prefer to work with the jQuery JavaScript than ExtJS or YUI… but also for those using alternative CFML engines like Railo and Open BlueDragon.

Okey dokes kids, that’s all for now. Got a tip? Email kay at smoljak dot com, leave a comment or tag at delicious.com with for:kay.smoljak. Til next time…

Now, demos involving circles and squares are fine, but I wanted to create an example that demonstrated a legitimate, practical use of vector graphics. So how about real-time statistics measurement? Here’s a screenshot of my Current Sprocket Usage line graph that plots real-time “sprocket” usage levels. Best of all, it was a snap to make.

The HTML is simple; we just need a heading and container to hold our canvas — a div element:

<h1>Current Sprocket Usage: <span id="readout"></span></h1>
<div id="graph"></div>

To start we have to generate a new graphics canvas. I always like to place all my code within an object definition in order to create a separate namespace, so we’ll start with the following code:

var SpGraph = {
  init : function(){
    SpGraph.graph = Raphael("graph", 400, 200);
    SpGraph.graph.rect(0, 0, 390, 110, 10).attr("fill", "#000");
  }
}

window.onload = function () {
  SpGraph.init();
};

Using the window.onload event we call our SpGraph.init method. Within this method we create our canvas using Raphael("graph", 400, 200). The first argument is the ID of our container element, the other two represent width and height. We store the returned canvas object in our SpGraph.graph property. With the next line we create a rectangle and set some attributes:

SpGraph.graph.rect(0, 0, 390, 110, 10).attr("fill", "#000");

The rect method allows us to draw a rectangle specifying the x coordinate, y coordinate, width, height, and optionally a corner radius. Notice that we’ve also chained a call to the attr method to set the fill color. All Raphaël graphic objects support the attr method and there’s a range of attributes you can set. Raphaël supports chaining all its methods, which we will take advantage of soon. Our effort so far has resulted in this lovely black rectangle with rounded corners.

Now lets add stripes! To do this we add the following loop to the SpGraph.init method:

for(var x = 10; x < 110; x += 10) {
  var c = (x > 10) ? "#333" : "#f00";
  SpGraph.graph.path({stroke: c}).moveTo(0, x).lineTo(390,x);
}

The loop executes 10 times drawing a line each time; a red line for the first one and a gray line for the others. The Raphaël path method initializes the path mode of drawing, returning a path object. It doesn’t actually draw anything itself; you have to use the path object methods, which are chainable. The moveTo method moves the drawing cursor to the specified x and y coordinates and the lineTo method draws a line from the cursor point to the point specified. The result is the stripey background below:

So now we have to draw the actual graph line. The vertical axis (represented by the stripes) is the percentage usage level. The horizontal axis will represent time in 10 pixel increments. In the real world each update of the graph would be obtained via an Ajax call, say every 5 seconds, but here I just create random values and update the graph every second. Once again, we use the path method to draw a 5 pixel wide line.

We initialise the path and store the reference to it in the SpGraph.path property like so:

SpGraph.path = SpGraph.graph.path({
    stroke: "#0f0",
    "stroke-width": 5, 
    "fill-opacity": 0
}).moveTo(20, 110);

Every update, we extend the line using the lineTo method like so:

SpGraph.path.lineTo(20+SpGraph.updates*10, 110-perf);

perf is a random value between 0 and 100. The SpGraph.updates property is a simple counter that allows us to control how many updates before the line is reset. The counter value is also used to plot the location of the line on the horizontal axis. After 35 updates the line is reset by removing it, using the SpGraph.path.remove method, and starting a new one.

So the whole script looks like this:

var SpGraph = {
  init : function(){
    SpGraph.graph = Raphael("graph", 400, 200);
    SpGraph.graph.rect(0, 0, 390, 110, 10).attr("fill", "#000");

    for(var x = 10; x < 110; x += 10) {
      var c = (x > 10) ? "#333" : "#f00";
      SpGraph.graph.path({stroke: c}).moveTo(0, x).lineTo(390,x);
    }
    SpGraph.startPath();
    SpGraph.updateGraph();
  },
  startPath : function() {
    if(SpGraph.path) {
      SpGraph.path.remove();
    }
    SpGraph.path = SpGraph.graph.path({
        stroke: "#0f0",
        "stroke-width": 5, 
        "fill-opacity": 0
    }).moveTo(20, 110);
  },
  updateGraph : function() {
    if(SpGraph.updates++ < 36) {
      // imagine this value comes from an ajax request
      var perf = Math.floor(Math.random() * 100);
      SpGraph.path.lineTo(20+SpGraph.updates*10, 110-perf);
      document.getElementById('readout').innerHTML = perf+'%';
    } else {
      SpGraph.updates = 0;
      SpGraph.startPath();
    }
    SpGraph.timer = setTimeout("SpGraph.updateGraph();",1000);
  },
  updates : 0
}
window.onload = function () {
  SpGraph.init();
};

Don’t forget to see it working in the demo. OK, so maybe a sprocket usage graph isn’t exactly the legitimate, practical example I promised, but at least you got a look at what you can achieve with Raphaël with only a little effort. The documentation on the site isn’t complete, but it’s not too difficult to work out anyway. Why don’t you have a go yourself? Quick, Simple, cross-browser compatible, vector graphics on the web has never been easier.

We all know what tags are in web terms, right? (If not, check out this Wikipedia article on the subject.) Tags are almost exclusively used to associate subject matter with content; you tag something like a photo or a blog post with a number of keywords that describe it, so that you can build semantic relationships — search criteria, content-by-subject lists, that kind of thing.

But it occurred to me that tagging can also be used as the basis of an authentication system. (To give props — I came up with this idea a while ago but I didn’t think of it in terms of tagging; it was Lachlan Hardy who made that connection for me.)

The idea is very simple: you create a system in which you define a number of tags that indicate permission groups, so you might have tags like guest, friend, moderator and me. Individual users also have one or more tags associated with their user account.

Then for each piece of content, you assign tags that indicate who’s allowed to see it — if a post is tagged me, moderator then only you and mods can see it. Or to put it more generally, whenever a permission tag for a piece of content and a permission tags for a user coincide, that user is allowed to see that content.

The real point here is that it’s infinitely extensible. You can define any number of tags — from tags that apply to everyone, right down to individual users — and create a user/permissions system that’s as granular as you need. (One of the problems with XFN is that it’s too broad — I can’t encompass all my personal relationships as friend or acquaintance.)

You could describe this as a kind of role-based authentication, and in those terms it’s not a new idea; you might also see it as inverted role-based authentication — instead of defining user groups that have attributes (such as the member groups in vBulletin), we’re defining attributes directly, and therefore bypassing the need to define groups. Either way, by putting it in terms of tagging it somehow seemed more interesting, and more relevant to modern web development practices.

And it makes me wonder — where else could we extend the idea of tagging, beyond its current uses? Let me know your thoughts in the comments.

Image credit: juandesant

Just a short background, Rasmus Lerdorf is the creator of PHP and still continues as a core developer to the PHP project.

PHP frameworks

In his address he choose to highlight PHP frameworks (Drupal was not spared) and how poor they are at performance. Not only are they slow, but their "jack-of-all-trades" attitude leads developers down the wrong path by not using what is best for the job. He continues on by stating that PHP developers really need to think about performance for not only scalability reasons but for green reasons. If programs were more efficient it would cut the number of data centres and would reduce energy needs as a result. In our newly emerging age of energy awareness this does become an important aspect and I am glad that he is raising awareness.

Back to frameworks, he started by discussing a database heavy Twitter mashup that he created. This does a lot of database calls and a lot of behind the scenes work. By hand-tuning it he was able to get on the order of 280 req/sec. By comparison and simple HTML page with nothing but "Hello World" served by Apache is just over 600 req/sec. Okay, stage is set (by the way, this was tested on his local machine).

Hello World

How do PHP frameworks score on the "Hello World" test? No database calls, just the framework being used in its native tongue to output Hello World. The results were not too good, one of the fastest got just over 120 req/sec, the slowest was 8 req/sec. This is a dramatic difference and of course highlights his argument for performance. Where did Drupal score? Right above 50 req/sec. So not the greatest, but he did make the point that Drupal is not really a framework in the traditional sense. It is a web content management system that can be quickly extended.

So, are there any frameworks that don’t suck? Rasmus did mention that he liked CodeIgniter because it is faster, lighter and the least like a framework.

How to make PHP fast

"Well, you can’t" was his quick answer. PHP is simply not fast enough to scale to Yahoo levels. PHP was never meant for those sorts of tasks. "Any script based language is simply not fast enough". To get the speed that is necessary for truly massive web systems you have to use compiled C++ extensions to get true, scaleable architecture. That is what Yahoo does and so do many other PHP heavyweights.

RDF, Semantic Web and the Monkey

RDF in Drupal. Rasmus made a special point of highlighting the importance of embedding structured metadata into the page. RDFa allows you to embed data into your web pages and also lets you create custom vocabularies, or even better, reuse existing vocabularies. Why would you want to do this? Searchmonkey will go out and index this content and open up a rich search API to allow you to do intelligent queries. Well beyond what is possible with traditional search.

Along with rich search you also get enhanced search results. I have blogged about this previously so take a look. It is really cool stuff and I will be discussing it in much more detail over the course of the conference.

Pitching the Semantic Web

What if all Drupal sites had embedded RDFa tags? Well, for one, Yahoo would be very happy. It would play directly into the strengths of Yahoo’s new Semantic Web strategy. They are trying to do interesting things with semantic data but of course they need data — the classic chicken and egg thing.

Rasmus mentioned that Yahoo’s semantic data store can scale to the size of the web so the invitation is open.

The future of Drupal

This is where my focus at Drupalcon is, driving the adoption of semantic technologies within Drupal — I feel that the momentum here will make that a reality. There is a lot of interest, a Semantic Web BoF session was stacked with people with some cool ideas…

More to come.

Code n’ Concepts

• Adobe have released a technote briefly demonstrating how images can be streamed. And if you’re working with CFIMAGE, Scott Pinkston reminds you to make sure you apply all the patches lest you find yourself pulling your hair out unnecessarily
• Ben Nadel’s OOPhoto project is still progressing – the latest installment is Encapsulating Form Processing In The Service / Facade Layer
• Raymond Camden answers a reader’s query about populating tooltips with a CFC and beats up on the CFFEED tag
• Following up from his ruminations on Business Logic, Doug Boude attempts to define just what is Application Logic
• Doug Hughes introduces the CFANT project, a toolkit for scripting remote CF deployments
• The MXUnit unit testing framework has been updated to 1.0.2

Are you a fan of nested sets to represent tree structures in your database? Nested Set Trees – a ColdFusion library for managing the various operations involved - has hit version 0.8.

SQL Injection attacks still bugging you? Simon Whatley has posted on how to fix an SQL Injection hack, and also how to protect against a malicious attack in the first place (hat tip to Steve Bryant). You know what they say about prevention being better than cure… Peter Boughton has released an Eclipse IDE plugin called QueryParam Scanner which looks through code to find and report on queries with unprotected input parameters. No excuses now – lock down that code!

Conferences

Some bad news UK developers: UK conference CFDevCon has been canned.

Some good news for UK developers: A Wee Dram of Scotch – a one day conference from the Scotch on the Rocks team - has been announced for September 25 in London (hat tip to Andy Jarrett).

While we’re on conferences, the four tracks for cf.Objective() 2009 have been announced (hat tip to Nic Tunney).

So that’s it? Really? Tell me people, did I miss something? Leave a comment, tag for:kay.smoljak on delicious.com or email kay at smoljak dot com with all the juicy goss.

I find myself here to track what is the current state of the art in Drupal land. I have been using Drupal extensively for a number of community based and science publishing systems and have been very happy with the results. So I am keen to learn what else I can add to my toolkit — after all, Drupal has something like a billion contributed modules and I have only gone through a hundred or so ;)

The other key reason I am here is to see the uptake of Semantic Web technologies inside of Drupal. There are a few sessions directly addressing semantic tech, but I wanted to have the fireside chats with the core Drupal folk and see what is out there. Yesterday I was heartened to hear in a keynote by Rasmus Lerdorf (inventor of PHP) that the Semantic Web is near and dear to his heart and that of Yahoo. I will write more on that later…

Okay, so that is enough lead up. I plan on getting a good nights rest (yeah right) and kick into full gear tomorrow. Over the last three days I have had about 3 hours of sleep per night so I am cutting this post a bit short.

If you missed your opportunity last week to pick up a copy of the excellent pocket guide, Adobe AIR For JavaScript Developers (that’s the dead-tree version), then now’s your chance to grab a copy again.

We just set live the second of Akash Mehta’s tutorials on building applications with AIR, Learn Adobe AIR, Part 2: Build A Customer Management App. This time round, Akash looks at expanding the user interface of an AIR-powered app, by exploring how to implement drag-and-drop and window management features. He also touches on menu construction and native window interaction. It’s all useful stuff if you’re experimenting with Adobe AIR development.

And once again, we have a quiz, so you can test how much of the article you absorbed. The first 100 people to complete the quiz will receive a free copy of the pocket guide, Adobe AIR For JavaScript Developers (once again, that’s the print version) delivered to your door.

Plus the book is still available as a free PDF download, so if you miss out on the print version, be sure to grab it in digital form. This free PDF offer is available until the end of October.

If you haven’t installed the AIR SDK, that’s probably a good place to start. Then once you’ve read the article, take the quiz and leave your details to score a freebie. Only the first 100 people!

Take the quiz!

See other framework interviews: Geoff Bowers on FarCry, John Farrar on COOP and Mark Mandel on Transfer ORM.

1. Hi Ike! Give us your elevator pitch: summarize the essence of onTap in a sentence or two.

Sales Pitchy Version: The onTap framework does for ColdFusion what ColdFusion did for the web: simplify a lot of powerful tools.

Not so Sales Pitchy Version: The onTap framework is an SOA approach to ColdFusion development.

2. Let’s dig a little deeper: tell us more about the main features.

Version 3.2 has converted all its config files from flat CFML includes now to CFCs and includes a new IoC Manager. The IoC Manager and the Plugin Manager provides a structure for developers to distribute or sell pluggable, smartly integrated applications and services that can be installed within a browser. In the not too distant future, the framework site will host a webservice which allows those “plugin” applications to be installed directly from within the framework in much the same way that add-ons can be installed in Eclipse or FireFox 3 without leaving the IDE.

If that sounds intimidating, don’t worry. None of that is actually necessary for developing applications with the onTap framework. The framework itself is agnostic about OO, the same way that the Fusebox framework is agnostic. You can choose to develop your application in an “extreme OO” manner, using an IoC framework, etc. or you can just build pages if that’s your preference. My preference is for the OO/SOA approach.

The framework includes a powerful XHTML library: a powerful and extensible templating engine which gives you access to a variety of form building and Ajax tools.

I use these XHTML tools in combination with a unique core architecture I’ve been calling “tiered inclusion”. Where Fusebox has circuits and fuseactions, the onTap framework has a “process”, which resembles and actually maps to both a URL and a file path. This tiered inclusion also provides some additional directory-based hooks for powerful branding/customization features as well as a host of very comprehensive internationalization (i18n) features for anyone who needs or wants them.

And that’s not even getting into a variety of other odds and ends you’ll find in the framework like content caching, section-508 compliant Ajax widgets, an XML-based rule-manager tool for providing powerfully configurable business logic that users can manage (not found in other frameworks), etc.

3. How did onTap come about and what was the reason for creating it? How are you involved?

I’m the original author. About the time I started working on the tiered inclusion technique, I had been doing a lot of work with Fusebox 3. Sure it was a decent framework, and initially I was a big fan of it… over time I found myself growing increasingly disenchanted by the amount of repetition involved in the switch files in Fusebox 3.

The tiered inclusion concept was something that just occurred to me spur of the moment one day and I worked on it for a long time to perfect it. For myself, it’s always provided an excellent way of reducing the amount of code I write. The rest of the framework came later and has always just been an endless pursuit of tools to make my own development work easier - if I found a way to create a generic tool that would be useful later, I included it in the distribution.

4. When should a developer seek out onTap? What has it got going for it?

The onTap framework’s biggest strength is in its ability to allow seamless branding and customization as well as seamless, automated integration between plugin applications (both using the same techniques).

I worked for a lot of ASP companies over the years and one thing that has been a consistent problem at every ASP I’ve worked for has been client customization requests. Clients invariably want tools the system wasn’t designed to provide and then finding a way to provide them is consistently problematic for the company providing the service, often actually hurting the company financially. The onTap framework provides a comprehensive set of tools that work very well for mitigating the problems caused by implementing client customization requests.

5. What are the pre-requisites for using onTap? Is there any prior knowledge that would help new users? Does it use any other frameworks that could simplify or complicate things?

Knowing some ColdFusion obviously would help! The only real requirement is ColdFusion 7 and it should run on both Windows and Unix operating systems. I haven’t tried with more recent versions of BlueDragon or with Railo yet. It doesn’t require any additional frameworks, although it does include built-in integration for ColdSpring or Lightwire if that’s your preference.

The core architecture behind the onTap framework is honestly not very complicated and is intentionally designed to be very simple to use, however it is unlike most other ColdFusion frameworks in its approach. So if you come to it expecting it to behave just like Mach-II, Model-Glue, ColdBox or even FuseBox you might have to unlearn some complexity to understand how simple and powerful the onTap framework is.

When I work on my own projects, I spend no more than a few minutes on things that normally, even with a good framework like ColdBox, would take several hours of my time. I spend those extra hours working on new problems instead of working on problems that I’ve already solved a bazillion times, like laying out or validating a form. And when I work on projects at my day job I essentially consider much of my time spent working as “time wasted” because I know how much faster things could be done.

6. What sets onTap apart from other frameworks?

Three things especially:
- Its SOA Approach to ColdFusion development
- Powerful tools for customization and branding (very useful for ASPs)
- Its simplicity

Actually something I find interesting is that several years ago I had done a comparison of several ColdFusion frameworks - there weren’t very many at the time, so I had just Fusebox 3 and 4, Mach-II and the onTap framework. At the time I was really disenchanted by the extra work required by the other frameworks, particularly the many, many lines of XML required for Mach-II.

In the intervening years, not just Mach-II and Fusebox have adopted my approaches, but other frameworks like ColdBox have cropped up in various places all touting as their advantages techniques that I’d been using for a long time. I’m not just saying this to pat myself on the back (in spite of the fact that I do take pride in it), but to point out that nearly everything that’s in the onTap framework has always been “ahead of its time”. I think that should speak to the longevity of the framework, which I know a few people have worried about.

In truth I like to think that the onTap framework functions in many ways a lot more like ColdFusion than most of the other ColdFusion frameworks that have been created in recent years.

7. Are there any great examples of onTap “in the wild”?

I have to be honest here and say nobody’s informed me of any yet. I really wish I could say “ahh yeah, XXX Bank is using it”, but I can’t.

Several years ago I implemented a solution using it for a defense contractor called Raytheon. I hesitate to say that’s an example of the framework in the wild because it was such an early version.

I’m excited to get the news though!

8. What about licensing, community, support and documentation?

It’s released with an OpenBSD style license, which is a little less restrictive than LGPL2 in that, not only are you allowed to create commercial software using it (lord knows I’ve had my own plans), but you can also encrypt your own software based on the onTap framework if you want to. It only requires that you include the notice that your distribution includes the onTap framework and that it’s not endorsed by the framework authors (which as of today is just me).

I’m currently working rather hard to try and grow the framework community. I’m trying to find better ways to encourage feedback and participation. I’m just not good at the marketing and people skills. I am however very interested in growing a more active community around this framework like the Fusebox or FarCry communities which have actual dev. teams and active forums and mailing lists. I’d like the framework to have a dev team at some point, not just me. I’d like for it to include code reviews / critiques and code contributions from other members of the community. I just recently published a blog about this specifically asking for people to write about their experiences with the framework, good bad or ugly.

Documentation for the framework has always been… well, verbose. I have actually removed some of the documentation in this latest release because I found that not only was a lot of it not read, but I’d had a number of developers over the years voice … well they weren’t complaints, but they would say things like Jeff Peters from the Fusebox community when I met him at cf.Objective had related an anecdote about having looked at the documentation a few days before and having a conversation with someone else in which the phrase “Do I have to read ALL this?!” was used.

The author of Model-Glue, Joe Rinehart once made a comment on the cf-talk list to the effect of “thanks for setting the bar so high for documentation” because he found my documentation to be so thorough (read LONG).

9. What’s coming up in the future for onTap?

Right now I’m working on getting it back onto its own domain. I just registered tapogee.com … Soon I hope it will be hosting the webservice I mentioned before for instantly finding and downloading plugin applications. My hope is that with a more active community there will be many plugin-based services and applications that can all work together to create a suite that truly leverages the collective talents of the ColdFusion community at large in a way that’s not been seen with other frameworks thus far (yes even FarCry, I’m that bold). Work less, accomplish more.

To that end I’m also considering self-publishing a small book on how to develop applications using the framework, and possibly t-shirts and other guerilla-marketing techniques.

10. Where can people find more information about onTap?

http://on.tapogee.com and check out the framework blog on RIAForge.

The throw statement is particularly useful for APIs developers, as a way to warn its user-developers about runtime issues, such as missing or invalid input data. Its use should be generally preferable to alert() because it makes best use of the browser’s native functionality (and it’s less annoying):

if(typeof input == 'undefined')
{
	throw('Missing input');
}
else if(parseFloat(input) != input)
{
	throw('Input must be a number');
}

Using throw() with a string argument will throw a general error. However you can also create and pass an Error object, with which you can specify more details about the error:

var err = new Error();
err.name = 'My API Input Error';
err.message = 'Input must be a number';
throw(err);

The example above produces this output in Opera’s error console:

Firefox’s console doesn’t show the error name, only the message; but it’s still almost as useful:

The important thing to note is that anywhere you use throw() will halt the execution of the script (not just the enclosing scope). So you should arrange your code so that any throw() statement comes at the end of an execution block:

function err(type, message)
{
	var err = new Error();
	err.name = 'My API ' + type + ' Error';
	err.message = message;
	throw(err);
}

// the delete in this example won't happen
if(typeof this.input == 'undefined')
{
	err('Input', 'Missing input');
	delete this.input;
}

// but this delete will happen fine
if(typeof this.input == 'undefined')
{
	delete this.input;
	err('Input', 'Missing input');
}

Of course, a single language statement — however useful — can never replace a fully-featured debugging tool like Firebug; a proper debugger lets you set breakpoints, watchpoints, step-through execution … all kinds of goodness. Firebug even lets you log messages to its own console.

But Firebug is a browser-specific tool, where this is a cross-browser language feature, so it can be safely integrated into the heart of a script without any chance of unsatisfied dependencies.