What is node.js?

Node.js is a way of writing your web applications wholly in JavaScript, which sounds like a terrible idea.

However, it is also an asynchronous programming environment that has been proven to scale really well, and it’s a collection of libraries many of which are excitingly small and well-encapsulated.

Here we just cover the basics of what it is:

Slides: What is node.js?

Running Dojo DOH tests in a browser without a web server

Dojo’s DOH requires a web server to run tests in a browser. But never fear:

$ cd ~/code/dojo
$ ls
docs  dojo  util
$ python -m SimpleHTTPServer &
$ xdg-open http://localhost:8000/util/doh/runner.html

Note that you will see some test failures, because the python web server doesn’t do PHP.

When finished:

$ kill %1

to stop your web server.

On Python 3, use this instead of the SimpleHTTPServer line:

python3 -m http.server &

Yes, Python includes a little web server that serves files in your current directory. Batteries included. Thanks to Lyle Backenroth and commandlinefu for making me aware of this.

Running Dojo 1.7+ DOH unit tests on the command line with Rhino

To run your own DOH-based unit tests on the command line using Rhino:

NOTE: this is Dojo 1.7 and above. For 1.6, there was a whole other cryptic incantation.

Project layout

Imagine your code is somewhere different from dojo, and another library you use is somewhere else:

C:/code/mycode/org/me/mytests/
                             ...
                             mytestmodule.js
                             ...
C:/code/mycode/org/them/nicelib/
                             ...
C:/libs/dojo/dojo/
                 ...
                 dojo.js
                 ...
             dijit/
                 ...
             dojox/
                 ...
             util/doh/
                     ...
                     main.js
                     ...

Config file

Yes, you need a config file. Imagine it’s at C:/code/mycode/dohconfig.js and it looks like this:

require({
    paths: {
        "org/me" : "../../../code/mycode/org/me",
        "org/them" : "../../../code/mycode/org/them/nicelib"
    }
});

Command line

Now you can run your tests like this:

java -jar C:/libs/dojo/util/shrinksafe/js.jar C:/libs/dojo/dojo/dojo.js baseUrl=file:///C:/libs/dojo/dojo load=file:///C:/code/mycode/dohconfig.js load=doh test=org/me/mytests/mytestmodule

Explanation

  • java -jar – run Java and execute a JAR file.
  • C:/libs/dojo/util/shrinksafe/js.jar – path to the JAR file that is Rhino, a JavaScript interpreter written in Java (and included in Dojo’s source distribution).
  • C:/libs/dojo/dojo/dojo.js – the Dojo “loader” – unlike in 1.6 and earlier, you don’t run DOH’s runner.js. Instead you run dojo.js and pass “load=doh” as an argument.
  • baseUrl=file:///C:/libs/dojo/dojo – a URL form of the location of the directory that contains dojo.js.
  • load=file:///C:/code/mycode/dohconfig.js – the location of your config file, which defines the “paths” variable, previously (in 1.6) known as registerModulePaths. This variable helps Dojo find your code based on its module name (here “org/me”).
  • load=doh – after you’ve read (actually, executed) the config file, execute DOH.
  • test=org/me/mytests/mytestmodule – the module name of your test (not the path – a module name which can be found using the lookups in the paths defined in your config file).

Lambda functions timeline

I did a talk at work about lambda functions (anonymous functions), and something possessed me to make a timeline of when they were introduced into various languages. Some languages were born with them, and some grew them later – in the latter case I give the language version and date in which they were introduced.

It’s probably entirely wrong, but here it is:

Dates when lambda functions were introduced into various programming languages

Note that C# had varying levels of support for lambda functions in different versions. I used the version (3.0) in which Wikipedia describes its support as “full”.

Goodness in programming languages, part 3 – not doing the same thing more than once

Posts in this series: Syntax, Deployment, Metaprogramming, Ownership

I’m going to use a word here – don’t stop reading: Metaprogramming. Does the language provide what you need to avoid repeating yourself?

Repeating boilerplate code, algorithms and most importantly ideas, slows you down, makes maintenance difficult, and allows all kinds of mistakes to creep in. If a language provides the ability to abstract, name and re-use all the different types of structure it contains, you can avoid harmful repetition.

Here are some things I like:

  • Python, JavaScript and Scheme’s ability to treat functions like any other object. A massive step towards sharing code is being allowed to pass around something that can be called without worrying about what it is.
  • Scheme’s ability to define an algorithm independently of types. In Scheme, there is never a need to write another version of the same function because it deals with different types of thing.
  • Python’s ability to read and modify classes just like any other object. Want a class just like your current one, except it logs every method call? Write a function that copies and modifies the class definition.
  • Scheme’s ability write code about code. In Scheme, code is just some nested lists. It’s trivial to build and modify code without stepping out of the language.
  • C++’s ability to write code that runs at compile time. If you can stand the syntax and (lack of) debugging, C++ template metaprogramming allows you to build C++ code at compile time without stepping out of the compiler environment.
  • Scheme and C’s macro systems. Both Scheme and C (and C++) allow you to write macros that build commonly-repeated code. Scheme’s syntax for this is much easier to work with.

Until you’ve experienced the freedom of totally generic code in a language like Scheme it’s hard to explain why the “Generics” features of some languages are so lacking. Of course, static typed languages work under different constraints. Would it be possible to write a language with very strong generic programming features, but which still allows static typing and compiling to native, non-generic code? I think so.