techno.blog("Dion")

A lot of developers ‘poo poo’ any code that is written in JavaScript.

• “JavaScript isn’t a real programming language”
• “JavaScript is just about browser hacker scripts”
• “You can use it to focus(). Big deal.”
• “JavaScript is for the HTML designers, not for REAL coders”

Giving thought to your JavaScript code

As such, any JavaScript code in a project, doesn’t get the thought that it deserves. Why would you be anal about unit testing your Java code, and ignoring your JavaScript code?

You no longer need too, as we have JsUnit, and other tools.

Dependencies are dependencies

As soon as you stop thinking of your JavaScript code as a bastard step-child, you can apply the same practices that we have in our other worlds (e.g. Java).

One of the problems with Java web applications, is that you can often do a search for files on a developers hard drive, and see MANY of the same files.

For example, you search for struts.jar, and there are 23 instances of it on the file system. Of course, they are not all the same size, since they are various versions (but you don’t know).

We get around that problem by using a tool such as Maven, or Ivy.

Now, we can define our project dependencies, and the correct versions are tracked, and downloaded automatically. Very nice.

WEB-INF/lib == /scripts

Why don’t we do this with JavaScript code? We have the same problem with commonscript.js as we do with struts.jar. So why not manage it?

Maven JS type

Maven has the base framework that we need to make this quite trivial. First, we can just agree on the ‘type’ of dependency. I am using js. Then you can just add dependencies as per normal:

<dependency>
<groupId>adigio</groupId>
<artifactId>xhr-test</artifactId>
<version>0.1</version>
<type>js</type>
</dependency>

This means that maven will try to grab:

/[groupId]/[type]s/[artifactId]-[version].[type]

or in the example above:

/adigio/jss/xhr-text-0.1.js

from the various repositories that you have setup in your project.properties:

maven.repo.remote=http://adigio.com/maven,http://www.ibiblio.org/maven,http://www.codeczar.com/maven,http://xdoclet.sourceforge.net/repository,http://dist.codehaus.org

NOTE: ‘[type]s’ is hard-coded. There is no way to map “when you see type ‘js’ look in directory ’scripts’, or something like that. This means that ‘jss’ looks a lil’ silly :).

maven-war-javascript

So, we didn’t have to do anything to get Maven to start grabbing dependencies for us. But, in our projects we don’t just want to grab some JavaScript modules and put them in your local repository. We want to use them :)

Rather than writing some manual goals to handle this, I wrote a Maven plugin which piggy-backs on the war plugin.

The maven-war-javascript-plugin offers a war:js / war:js:copy-scripts goal. This manually looks through your dependencies, and copies any JavaScript modules to your web app (in the scripts directory by default. To change, use the maven.war.javascript.dir property).

However, although you have a goal in which you can kick off this task, in practice you don’t need to use it. The plugin registers itself with the war module, and whenever it is invoked, it sneaks in and does the copy. So, it is a seemless introduction!

Installation

To download and install the plugin, you can simply:

• Add: http://www.adigio.com/maven to maven.repo.remote
• Run the commmand: % maven -DartifactId=maven-war-javascript-plugin -DgroupId=adigio -Dversion=0.1 plugin:download

Conclusion

So, now I can take JavaScript more seriously, and can start managing my JS dependencies with the care and loving touch that I do with the immense amount of open source library bloat :)

From Ajaxian.com

A friend pointed me to a (seemingly old) project called XMLTerm. XMLTerm is a mozilla based “A graphical command line interface”.

At first you may laugh, and ignore some of the security implications for now, but this could actually be quite cool.

Ajax could also come in to really help this out.

Some thoughts:

• % du: When you do a ‘du’, wouldn’t it be cool to show a pie chart usage as well as the numbers?
• % ssh [TAB]: tcsh came up with the ‘complete’ command, which lets you get smart with your tabbing. We can take that to a new level with a bit of UI integration. If you hit TAB after typing a command that needs a host (e.g. ssh, scp) then a select list can appear with your list of hosts
• % history: Since we can place cool widgets in places, we could have a history bar which would allow you to click on an item to rerun it. Command Line Suggest could also get pulled up if you TAB at the beginning of a command, showing a drop down on history.

The XMLTerm site itself has ideas on graphical ls which shows thumbnails, and a special cat which groks HTML, images, etc.

In theory, this could be an interesting marriage of the command line interface (power), and richer functionality (not just text).

Ben and I have had great feedback from the presentations that we have given on Ajax, so we created Ajaxian.com, as a place to talk about all things Ajax.

For instance, today we wrote about Handling usability concerns, such as the back/forward buttons, and bookmarking in the browser.

The entry talks about the opensource Dojo Toolkit, and its new bind() mechanism.

Have you been to a Brazillian buffet house? At these restaurants, waiters come around constantly with some meat, and will slice it off for you if you are showing the green YES:

If you need some time to relax and digest you show red:

Sometimes it would be nice to show this card to management. For example, when you get into the programming zone, wouldn’t it be nice to say “please don’t come around with small talk right now?”

Back in the day, I put in a policy which meant that management couldn’t bug my dev team during certain hours (unless they planned a meeting in advance etc). It was amazing to see the productivity gains from this simple measure.

Don’t be scared to show the red card! :)

Brian McCallister wrote an interesting post (as per) explaining web containers.

One interesting point, is that although the topic is aimed at the Java spectrum, Brian uses Ruby as pseudocode in his tale.

The mix of Ruby/YAML is pretty clear, and does the job at getting the message across. This is because of the conciseness of the language. There is no extra crud that you have to put in there (static types, verbose APIs, etc).

So, if we want to write pseudocode in “language X”, I think that says a lot. Don’t we want our pseudocode to be as close to the metal as possible? Wouldn’t it be nice to take that pseudocode and just RUN it? We can :)

_why wrote about this too in Ruby as Coderspeak