blog.gvm-it.eu

Introduction to the node.js EventEmitter

Mon, 28 May 2012 14:10:52 +0200

When you start learning node.js you soon stumble upon something called EventEmitter. The following post covers how the built-in EventEmitter works, how you can use and why it is so useful.

EventEmitter basics

There is no magic. The EventEmitter is pure JavaScript and the code of it can be found here on GitHub. The following holds true for the base EventEmitter class:

Typically the EventEmitter class is included in a node module like this (“events” is a node.js core module that has only one export, the EventEmitter):
```
var EventEmitter = require("events").EventEmitter;
```
To create a simple EventEmitter instance, just instantiate a new EventEmitter:
```
var myEventEmitter = new EventEmitter();
```
This is a common pattern that is used to inherit from the EventEmitter class; If you create an instance of myClass it will have EventEmitter functionality:
```
function myClass() { /* constructor */ }
myClass.prototype = new EventEmitter();
```
The EventEmitter allows you to hook event listeners onto the emitter that can listen for any arbitrary event using the following syntax:
```
myEventEmitter.on("event_name", fnListener);
```
Event listeners are functions that are called once a specific event is emitted. You can always emit any event like this:
```
myEventEmitter.emit("event_name", "arg1", "arg2");
```
When you .emit() an event, any arguments that you pass after the event_name will be passed to the attached event listeners.
Also, when you have multiple event listeners attached to an event, all of those event listeners will be called in the order that they were attached to it.
Event names are completely arbitrary; If you create your own EventEmitter, you decide which events your EventEmitter emits. If you don’t emit your events, the listeners will never be fired.

Special event: error

There is one exception to the behaviour of events which is not found in the official documentation: When you .emit() an “error” event and you don’t have any event listeners attached to it, an uncaughtException event is raised.

This means that your node.js process - it itself is based on the EventEmitter - will emit an event called “uncaughtException”. This in turn will, if you don’t have a listener for it, make your node process exit.

Note that if you throw an error that is not caught using try .. catch, this will also raise an “uncaughtException”.

The take-away message is that if you raise “error” events, be sure to listen for them or be aware that they will crash your program.

Further functionality

The above explains the basic, most important, basic functionality. But of course, there does exist further functionality that can be of use:

Listen exactly one time to an event, then remove the listener:
```
myEventEmitter.once("event_name", fnListener);
```

Remove one specific listener from an event:

myEventEmitter.removeListener("event_name", fnListener);

Remove all listeners from an event

myEventEmitter.removeAllListeners("event_name")

Retrieve all listener functions that are listening to an event, as an array:
```
var arListeners = myEventEmitter.listeners("event_name");
```
A special event “newListener” is fired whenever you attach a new event listener. If you attach a listener to this “newListener” event, it gets the events name and the function reference of the newly added listener:
```
function fnNewListener (eventName, fnListener) { }
myEventEmitter.on("newListener", fnNewListener );
```
Note that if you .emit() an event, its listener code is being executed synchroneously and then control goes back to the point where the event was emitted. Here is an example:
https://gist.github.com/2818766
Also note that within your event listener function, this refers to the EventEmitter object.
https://gist.github.com/2818810

Why the EventEmitter is awesome

You may ask yourself, why go through this trouble?

The EventEmitter base functionality lets you easily create a commonly used interface for other code to hook into. You can abstract much of the logic and only need to expose the events.

Besides, many of the node.js core objects are based upon the EventEmitter, i.e. streams, the tcp/ip server and client, the http server and child processes. That alone should enable you to look further into it.

Feel free to ask questions or comment below!

Extract newline seperated messages from a stream

Sat, 26 May 2012 14:04:00 +0200

In node.js, you are often confronted with streams that you may want to send and recieve data over. The following post provides and explains a small helper function that allows you to extract newline-separated messages from a node.js stream.

Why use this?

The problem with a stream is that you never know how much of a message has arrived. A common problem is that either only a part of the message arrived or multiple messages arrive at once. Therefore we separate each message with a newline character so we know when a message ends and when the next one begins.

Here are a two example use cases for when you want to handle newline separated messages from a stream:

You want to send strings or JSON-objects over a TCP/IP net connection.
You want to handle the stdout stream from a child process, thus i.e. each console.log statement.
You want to stream a file line by line.

The helper function

First the code, then the explanation:

https://gist.github.com/2793677

A stream emits a data event whenever a chunk of data arrives. The chunk is added to a buffer which in turn is check whether it includes our newline delimiter \n. If so, a piece of the buffer is extracted, which now holds a complete message that is being sent to the callback function. If no delimiter is found, wait until the next chunk arrives and check again.

Afterwards the buffer is shortened by the length of the piece and check whether it holds another complete message. If so, repeat, if not, wait for next chunk and start again.

It must be noted that this function returns an EventListener function, it itself is not the function that listens for data events. So be sure to actually call the helper function.

Callback conventions in node.js, how and why

Sun, 29 Apr 2012 12:26:00 +0200

When first confronted with node.js, you are not only presented with a completely new programming environment. You also encounter what is often referred to as callback hell accompanied by weird unfamiliar programming patterns. One of these is the way node treats callback functions.

The following post explains the conventions that node.js uses for its callback patterns (referred to as Continuation-passing style) and how you should implement them in order to comply.

The first argument is an error object

Node expects - almost - all callback functions to accept an Error object as the first argument. If no error occurred, the first argument should be null. If you use inline anonymous functions, this is a typical code snippet that you will encounter using node:

https://gist.github.com/2548942

There is a reason why this is a usefull pattern: Imagine, you have a chain of asynchroneous functions that were to execute one after the other. I.e. read a file, get something out of a database, write something into the database and output the results to a callback function.

Now think something went wrong in the first function, i.e. the file cannot be read. You don’t want to blindly execute the other functions next in line. Instead, you skip the other functions and directly return to your callback function and let it choose how to handle the error. When no error occurred, continue with the next step.

https://gist.github.com/2549029

This pattern lets you waterfall through function chains and leaves handling the error it up to the original invoking function. It is likely that you do not want to throw uncaught errors all the time.

Pass error objects, not strings

While we’re at it, when you create errors, you should create actual Error objects that are passed around. When Error objects are created, the JavaScript engine inserts additional information into them (i.e. the stack trace, file name, line number) that you can be useful for debugging.

https://gist.github.com/2549052

The last argument is the callback function

If your function expects a callback function as an argument, it should be the last argument. That callback function in turn should also accept an Error object or null as the first argument, as described above.

Note that if you do not need a callback function, i.e. when you just don’t perform asynchroneous actions, you don’t forcefully need to demand one.

Additional and optional arguments go in between

Any more arguments, required or optional, should go in between the error and the callback parameter. Below is an example how you could retrieve the optional arguments:

https://gist.github.com/2549131

Note that there other ways to check whether the optional arguments were supplied. This is just a very broad pattern that you can reuse.

When to apply these pattern fully

You don’t always need to follow this pattern in detail. Use common sense to find out where to omit certain arguments.

When your function is the first in line of a longer chain of asynchroneous calls, it does not need to accept an Error object. The next in line should though.
When your function does not perform any asynchroneous calls and you can simply return your result, you don’t need to take a callback function.
If your function returns multiple arguments and may fail, even though it is not asynchroneous, you may very well feed them to a callback function instead of stuffing them into a return statement. This way your code is more readable - to node developers.

The more node.js style code and API’s you encounter, the more you will see that these patterns are used broadly among node libraries and modules and that it makes sense to use these.

Register all routes in a folder for your express server

Sat, 07 Apr 2012 11:01:31 +0200

Given the following problem: You have an express based webserver and you have stored all your routes in seperate files in one folder, perhaps even organized into several subfolders. You now want an easy way to apply all routes with as little effort as possible..

Meet node-walker: This little module let’s you crawl a subfolder and perform a callback on each filename that it encounters, including files in subdirectories.

The module can be installed through npm using npm install node-walker or downloaded via the GitHub page. Then just require it and use it as documented on the GitHub page.

You then pass node-walker the directory which it should crawl and a callback function, which takes an error object (in node fashion), the file name and a next function as arguments. This callback function will be called for every filename it encounters, which you then can simply require.

The example below shows the main script file that registers all routes that are stored in a subfolder called /routes and an example /routes/test.js file, that exports a function register( [app] ) in order to register itself with the express server instance.

https://gist.github.com/2320816

Iterate over all files in a folder in node.js: node-walker

Fri, 06 Apr 2012 16:18:30 +0200

Iterate over all files in a folder in node.js: node-walker:

Use node-walker to recursively walk over a directory and all its files. You can then iterate over all filenames to i.e. require them all one after the other. Can be installed through npm as well: npm install node-walker

Getting started with MongoDB and node.js on Windows

Wed, 04 Apr 2012 13:42:00 +0200

Earlier I wrote a little tutorial on how to get started with node.js on windows, which I now want to continue by explaining how to setup and use MongoDB with node.js in a Windows environment. This tutorial will cover:

Brief introduction to MongoDB
Installation and setup of a MongoDB database server.
Connecting to MongoDB using node and node-mongodb-native
Basic database operations through node

What is MongoDB?

MongoDB is a non-relational database, a key-value store, also known as a NoSQL database, meaning that it strongly differs from traditional SQL databases.

Data is stored as a JSON-like object in a collection. Collections are the equivalent of SQL tables, but they are different.
Unlike SQL databases, MongoDB is schema-free, meaning that you don’t have to = cannot define a schema of your data in a particular collection. You programmatically choose to follow a certain format - or not.
MongoDBs data format and command syntax is heavily based on JavaScript and JSON, meaning that you do not really need to learn a new query language, if you know JavaScript.
NoSQL databases in general are a hot topic right now, both in a positive and a negative way. Keywords like scalability, reliability, stability and performance are discussed a lot, so it may or may not be the next big thing.
Since MongoDBs interface is based on JavaScript and it takes and returns JSON-like objects, it works really well with node.

MongoDB offers a very great online tutorial which gives you a taste of how MongoDB works and what it feels like. Just hit the Try it out! button on the MongoDB site.

Installation and setup

Installing MongoDB is ridiculously easy: Go to the Downloads section and grab either the 32bit or the 64bit distribution of MongoDB. It is served as a .zip file, which you just need to unzip into a folder of your liking.

For demonstration purposes, let’s assume that we unzipped everything into a folder D:\mongodb. In order to launch MongoDB, we will use the command prompt (Start -> Run .. -> cmd.exe). To run the database server, you need to start mongod.exe which you find in your D:\mongodb\bin folder.

By default, a database is being created automatically in a \mongodb\data subfolder, but let’s assume that we want to choose our own database file which I recommend if you use multiple databases for different projects.

For that, we need to pass a —dbpath argument. If we had our node.js app in D:\node\myapp, we might want to save our data there in a subfolder called data, so we need to launch MongoDB like this: mongod —dbpath D:\node\myapp\data which will look like this:

Note: In order to shut down the database server, press CTRL + C in the command prompt or just close it.

You can simplify your database startup by writing your own little batch file like this: Open up your favorite code editor and create a new file run_database.bat and fill it with these contents:

D:\mongodb\bin\mongod.exe --dbpath D:\node\myapp\data

Now you can double-click on that file to launch the database server conveniently. There are more startup options which can be seen if you type mongod —help

Note: By default, the MongoDB server does only accept connections from your local machine, but does not require any authentification. You can change these settings as shown in the official MongoDB documentation. For your local installation, we will stick to the defaults.

Connecting to MongoDB using node.js

Now for the fun part: In order to connect to a MongoDB-server, you need a database driver, which defaults to node-mongodb-native. Fire up your command prompt again, switch to your node.js app folder and install it using npm: npm install mongodb

Next, we will try and connect to the database. Copy the code below (taken from here) into your node program. Make sure the database server is running before you run it:

var mongo = require('mongodb'),
  Server = mongo.Server,
  Db = mongo.Db;

var server = new Server('localhost', 27017, {auto_reconnect: true});
var db = new Db('exampleDb', server);

db.open(function(err, db) {
  if(!err) {
    console.log("We are connected");
  }
});

If everything worked out, you will see the We are connected! message in the node command prompt. After you are connected, you can then perform your database operations. Note that any commands are buffered until a connection is established or while the connection is interrupted.

Basic operations

Here I will introduce the most basic operations needed for your database tasks. For more specific information on operations and queries, you will need to read the official documentation on querying.

Connecting and disconnecting

// include the mongodb module
var mongo = require('mongodb');

// create a server instance
var serverInstance = new mongo.Server('localhost', 27017, {auto_reconnect: true});

// retrieve a database reference
var dbref = new mongo.Db('myDatabaseName', serverInstance);

// connect to database server
dbref.open(function(err, dbref) {
    // now a connection is established
});

// close a database connection
dbref.close();

// retrieve a collection reference
dbref.collection('myCollectionName', function(err, collectionref) { 
    // this is an asynchroneous operation
});

Note: If you try and use a collection that does not exist, an empty collection is automatically being created.

Insert documents

// insert a document into a collection
var myDoc = {"some":"data", "foo":"bar"};
collectionref.insert(myDoc, function (err, result) {
    // this is an asynchroneous operation
});
// insert multiple documents
var myDocs = [{"foo":"bar"}, {"foo":"bar2"}, {"foo":"bar3"}];
collectionref.insert(myDocs, function (err, result) {
    // this is an asynchroneous operation
});

Note: ObjectID’s are generated automatically, you don’t need to do that manually.

Querying documents

// find all documents in a collection
var cursor = collectionref.find();
cursor.toArray(function(err, docs) {
    // gets executed once all items are retrieved
});

// find all documents in a collection that have foo: "bar"
var cursor = collectionref.find({foo:"bar"});
cursor.toArray(function(err, docs) {
    // gets executed once all items are retrieved
});

// find exactly one item in a collection which has foo:"bar"
collectionref.findOne({foo:"bar"}, function(err, doc) {
    // no cursor object is needed
});

Returning partial results: sort, skip, limit

// find all documents in a collection
var cursor = collectionref.find();

// sort the result by the "foo" field, ascending
cursor.sort([["foo", 1]]);

// skip any amount of results, i.e. for pagination
cursor.skip(10);

// only retrieve a specified amount of results
cursor.limit(10, function (err, cursor) {
    // no documents are provided, that must follow afterwards
});

// then retrieve results as an array
cursor.toArray(function(err, docs) {
    // gets executed once all items are sorted and retrieved
});

// .. or retrieve results one after the other
cursor.each( function (err, doc) {
    // doc === null when this function has shown all documents
    // otherwise doc will hold the current document
});

// count the number of results
cursor.count(function (err, amount) {
    // amount will hold the number of results
});

// if you only need the count and no results, use this instead
collectionref.count({foo:"bar"}, function (err, amount) {
    // amount will hold the number of matches
});

Removing documents

// Remove all the documents in a collection
collectionref.remove();

// remove all documents that match a condition
collectionref.remove({foo:"bar"});

// execute a callback afterwards
collectionref.remove(function (err) {
    // all documents have been removed
});

Updating documents

The syntax is update(selector, document[, options][, callback]), where you need to specify multi in the options to true if you wish to update all matched documents. You may also specify upsert to true if you want to create a new document if none is found to update.

// replace the foo field on all objects where foo:"bar"
collectionref.update({foo:"bar", {foo:"zoo"}, {multi:true}, function (err) {
    // operation has been performed
});

Getting started with node.js on Windows

Tue, 03 Apr 2012 14:09:00 +0200

The following tutorial will give you a very brief guide on how to get started with node.js on Windows. This tutorial will not tell you which third-party tools to use, this is just a plain introduction to the node.js ecosystem. This includes:

Install and setup node.js on windows.
Run a “Hello world!”-program.
Create a webserver program.
Use npm to install a module.

Installation

Recently it has become much easier to install node.js on Windows. Forget cygwin and virtual linux boxes or anything else. Just go to nodejs.org and hit the Download link. You will be presented with different packages as shown below; Pick the Microsoft Installer.

After downloading, simply run the .msi file which will guide you through the installation pretty straightforward. There are no options to check; Node installs into C:\Program Files (x86)\nodejs and adds itself to the PATH variable.

Note that since we’re running on a Microsoft operating system, the obligatory reboot is necessary to make the change to the PATH variable take effect, meaning you can just type node into your command prompt instead of having to type the full path. So.. reboot now.

After the installation and an annoying reboot, we will test whether the installation worked. Open up a command prompt (Start -> Run .. -> cmd.exe), type node and hit enter.

If the installation succeeded, you are now in the command line mode of node.js, meaning you can code on the fly. We are not going to do that right now, we just wanted to see whether it worked. For now, press CTRL + C twice to quit.

Note: You can exit any running node process by pressing CTRL + C in the corresponding command window.

Congratulation, you successfully installed node.js on your Windows computer.

Hello world?!

Any text file can be interpreted by node, so fire up your favorite text / code editor and create a new file helloworld.js. In that file, put the following contents:

// our very first node program
console.log("Hello world!");

Note: console.log( [string] ) let’s you write messages to stdout, meaning they show up in your command prompt. This is useful for debugging.

Next we of course need to run our script using node. Open up your command prompt again as shown before and go to the directory in which you placed your helloworld.js file. Then type node helloworld.js and hit enter.

If your file was placed in D:\node\helloworld.js, type the following commands one after the other:

d:
cd node
node helloworld.js

Note: Any node program quits as soon as there is nothing left to compute or there is no event left to wait for. In this case, after writing the Hello world! message, there is nothing left to do.

Note: You need to restart your node program whenever you change something in the source code.

Next we will try out the Hello world! example from the nodejs.org website. Replace the contents of the helloworld.js file with the following code:

// include the http module
var http = require('http');

// create a webserver
http.createServer(function (req, res) {

    // respond to any incoming http request
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');

}).listen(1337, '127.0.0.1');

// log what that we started listening on localhost:1337
console.log('Server running at 127.0.0.1:1337');

In the command prompt, type node helloworld.js again and hit enter again, which will present you with the following:

Note: At this point, your firewall will propably tell you that node is trying to access network functionality.

This means that your newly created webserver is listening on http://localhost:1337/, so type that adres in your browser and see the following:

Congratulations, again! You just wrote your very own webserver in node!

Note: Type CTRL + C to shut down the node program.

Using npm on windows

Node comes with a packages manager, node package manager (npm), which is automatically installed along node. To use npm, you need to open a command prompt, switch to the directory in which you want to use it, and type npm plus the command you with to execute.

Node’s core functionality is very slim, but there is a very large number of libraries - in node they are called modules - which you can use. Npm is a very powerfull tool and the libraries which you may use are countless, so I will just show how to locally install a module for your current project.

cd to your program directory (as shown above).
type: npm install express to install the express web framework.
Hit enter.

You should see something like the following:

A new folder node_modules has been created in your D:\node directory. It will also hold all future modules that you install for your current project using npm.

You may now use the express module by requiring it, as shown in this simple example:

var express = require('express');

var app = express.createServer();

app.get('/', function(req, res){
    res.send('Hello World');
});

app.listen(1337);

You can run this code in the same way as the other Hello world! - examples. For more practical uses and a whole explanation of the express-framework, visit its site at expressjs.com or google for some examples.

Summary

You are now able to use node.js and npm on your Windows-computer. You can now skip ahead to more advanced tutorials or you can start reading the node code api documentation, which I strongly recommend before learning any framework.

Plain Text Copy And Paste - Google Chrome Extension

Fri, 30 Dec 2011 00:33:55 +0100

I came to the realisation that I get mad whenever I accidently paste formatted text and that I am too lazy to use CTRL + SHIFT + V, so I wrote a tiny Google Chrome extension that removes formatting and markup information from text that you copy to your clipboard: Plain Text Copy And Paste

I recently have to do a lot of copy and paste work from websites to OpenOffice Calc and I lose my mind whenever the table cells contain styling that I did not mean to paste. Again, I am too lazy to use CTRL + SHIFT + V to “paste special” without formatting - especially since OpenOffice shows another selection dialogue (rant: Why on earth show a selection dialogue if there is only one item to choose from?!).

The source code of this extension can be found on GitHub: klovadis / Plain-Text-Copy-And-Paste.

How this extension works

Here’s the technical explanation on how the extension works: After the initialisation of the document the script.js file gets injected into each and every page that you visit. See the manifest.json file, lines 5 through 12. Also note that the script file is executed in its own scope, as explained here, that’s why the injection does not take place in an anonymous function.

When the script is run, it adds an event listener to the body that listens for the “keydown” event, thus when a keyboard key is pressed. If CTRL + C is pressed, the magic happens: A hidden textarea is created and selected, which holds the plain text version of the currently selected text. After about 100ms the textarea is being hidden again.

After executing the event listener function, Chrome proceeds to do what it is supposed to do, when CTRL + C is pressed: Copying the selected text to the clipboard. However, we changed the selection before this could happen. So by selecting text in a textarea, we got rid of any style information

Bookmark Buttons Startpage update 1.2.2

Thu, 03 Nov 2011 14:36:04 +0100

Bookmark Buttons Startpage update 1.2.2:

I just updated the Bookmark Buttons Startpage to version 1.2.2 which fixes a problem that is recognized by the current version of Google Chrome, but not by the previous ones. Also the webstore presentation was updated in order to comply with the new formats.

The extension should update automatically over the next days, but you can manually update it if you go to the extension management window and hit the “Update all extensions” button.

As a sidenote: Chrome 15 does now throw a fatal error when a new RegExp object is created with unrecognized / invalid flags. Turns out that JavaScript does not support the /s flag.

Simple template wrapper for NodeJS

Sun, 09 Oct 2011 16:29:13 +0200

Simple template wrapper for NodeJS:

I rewrote a solution by John Resig to create simple templates in JavaScript to work with node.js and added support for file loading and inline templates. Check out the examples for more information.

Node.js 0.5.2 - Load JSON files with require

Thu, 28 Jul 2011 18:56:00 +0200

Just a brief post: With the latest release of node.js, it is now possible to load files that only contain JSON data directly into objects using the require( [path_to_file] ) function.

Before, you had to use a function like this to achieve the same:

// a function to load json data from a file
var fs = require('fs');
function loadJSONfile (filename, encoding) {
	try {
		// default encoding is utf8
		if (typeof (encoding) == 'undefined') encoding = 'utf8';
		
		// read file synchroneously
		var contents = fs.readFileSync(filename, encoding);

		// parse contents as JSON
		return JSON.parse(contents);
		
	} catch (err) {
		// an error occurred
		throw err;	
	}
} // loadJSONfile


// this is what we needed to do now
var myData = loadJSONfile(__dirname + '/data.json');
console.log('loadJSONfile:', myData);

As of node.js 0.5.2 we can simply do the following:

// this is possible as of node.js 0.5.2
var myData = require('./data.json');
console.log('Require:', myData);

It is also noteworthy that the require statement will also cache the result of loading that JSON file, meaning that you can refer to it from many files / modules without having to process it each and every time.

In other words, this will make storing static data in files locally much, much more attractive.

Full Changelog

For the full changelog, visit the node.js blog. As of node.js 0.5.0, there also is an official Windows node.exe file, which allows Windows users to use node without running a virtual machine or build it using CygWin.

Unfortunately, however, that executable comes withoutthe Node Package Manager, meaning that you painfully have to install libraries manually. For that reason, I’m still running an older version that includes NPM.

According to Ryan Dahl’s slides at OSCOM 2011, the next major release, node.js 0.6.0 is been schedulded to arrive within four weeks. NPM, however, was not mentioned.

My very own Flow Control module

Tue, 26 Jul 2011 01:55:10 +0200

My very own Flow Control module:

While toying around with Node.js, I ended up writing my own little flow control library. Check it out on GitHub and leave a comment!

Inspired by a link on Google+ that explained how to run Chrome...

Mon, 18 Jul 2011 22:52:00 +0200

Browsing did feel a little slow ..

Bookmark Buttons Startpage on Chromium

Inspired by a link on Google+ that explained how to run Chrome OS from a usb drive I gave Chromium a try. I did encounter a few glitches (y u no recognize my usb mouse?!) and browsing felt a little slow, but apart from that I really like Google Chrome OS on my laptop.

How to: Heredocs in JavaScript

Sat, 16 Jul 2011 14:54:42 +0200

The following code allows you to define multi line strings in your JavaScript code. However, it is not cross-browser compatible - some implementations will return empty strings. So why bother? Because the V8 engine - thus node.js - does support this dirty hack!

Include the following function somewhere in your code:

function heredoc(func) {
	// get function code as string
	var hd = func.toString();
	
	// remove { /* using a regular expression
	hd = hd.replace(/(^.*\{\s*\/\*\s*)/g, '');
	
	// remove */ } using a regular expression
	hd = hd.replace(/(\s*\*\/\s*\}.*)$/g, '');
	
	// return output
	return hd;
}

Define a template like this - note that we use an empty function where we put our heredoc string into a Javascript comment which gets stripped out:

var myTemplate = function() { /*

<html>
	<body>
		<h1>This is a template</h1>
	</body>
</html>

*/ }

Now you can get the heredocs contents using heredoc(myTemplate):

var myHeredocString = heredoc(myTemplate);
console.log(myHeredocString);

// output:

<html>
	<body>
		<h1>This is a template</h1>
	</body>
</html>

Enjoy!

HTML5 vs Native apps from the viewpoint of Diary.com

Fri, 15 Jul 2011 12:50:00 +0200

HTML5 vs Native apps from the viewpoint of Diary.com:

I’ve been doing some testing for Diary.com over the past few months. In this article, they describe their take on choosing between using HTML5 technologies over native code when creating their mobile app.

How to: Enable syntax highlighting on your Tumblr blog

Tue, 14 Jun 2011 21:25:00 +0200

How to: Enable syntax highlighting on your Tumblr blog:

Dr. Nic Williams has created a simple and easy to use plugin to Tumblr which allows coders to use syntax highlighting in their blog posts. Read his (4 year old) article on syntax highlighting in Tumblr.

Keyboard input module for node: node-prompt.js

Wed, 08 Jun 2011 20:17:00 +0200

I have been watching node.js very close over the past weeks and eventually got myself a working installation, so it was about time to code something. But what? Don’t ask why, but I ended up writing a simple module that allows you to prompt input in your node process window.

Basically, what I wanted to have was the possibility to start up a node.js program and manually enter data without having to pass it via the command line. For example, one might want to enter a server adres or a password when you fire up your script.

In the example below, the program asks for your favorite color and a secret, which does not display the text that you entered:

The corresponding code (example.js in the .zip package) looks something like this:

// include node-prompt.js
var nodePrompt = require('./node-prompt.js');

// open an input prompt
nodePrompt.prompt(
	"What is your favorite color?", 
	function(response) {
	
		// print the entered text
		console.log(response + " really is a nice color.");
		
		// example asking for a password
		nodePrompt.password(
			"Now tell me a secret!", 
			function(password) {
			
				// print out the entered text
				console.log("Did you hear that? " 
					+ password.toUpperCase() 
					+ "! That\'s just ridiculous!");
		});
});

The sourcecode for node-prompt.js is included in this node-prompt.js.zip (2.4kb) package. Extract it anywhere and run example.js with node. If this is something which node users find useful, I will eventually create a npm package for it, but for now I’ll rest with it.

Feedback is appreciated!

Creating my first iPhone webapp: Pulse Meter

Wed, 20 Apr 2011 14:56:14 +0200

I have finally found something to turn into a more or less usefull webapp for the iPhone: A pulse meter which allows to quickly fetch a persons pulse. You can try the app by opening this link. Below there is a brief introduction and a user manual.

The reason why I came up with this is the following: In the hospital, from time to time, you need to manually take a patients pulse. Usually you would take any watch and count the heartbeats that occur within fifteen seconds and multiply that number by four. For me as an intern, not having a wristwatch, this quick task is quite a hassle because I need to fire up the stopwatch on my iPhone.

The app I created simplifies this task:

Find a patients pulse.
Open the app.
With every heartbeat, tap on the screen.
After about 10 heartbeats, you get the patients pulse accurately displayed on the phone’s screen.

Here’s how you can get the app (free):

Open up Safari on your iPhone, iPod or iPad.
Go to the following adres: http://www.gvm-it.eu/apps/pulse.html
Start tapping!
You can add this app to your home screen by hitting the bookmark-icon in Safari and then choosing to ‘Add to home screen’.

As an intern, this app is really helpfull to me. Creating it was very simple with a little help from Matt Might’s tutorial HOWTO: Create native-looking iPhone/iPad applications from HTML, CSS and JavaScript.

Any feedback is appreciated!

Bookmark Buttons Startpage v1.2.1 released

Fri, 18 Mar 2011 16:23:42 +0100

I just released the new version of the Bookmark Buttons Startpage. This is a minor update which fixes an annoying glitch and provides a few new features. You may need to manually update the extension from the extensions menu, otherwise Google may take its time to do so automatically.

The following things have been changed:

The behaviour of opening links has changed and thereby fixes the issue that the bookmark URL would not appear in the adres bar of the extension. Thank you everyone for reporting this problem!
Folder can now be opened in new windows using middle-click and in most cases, you can use the browsers built-in back button to go browse back.
A donations section has been added. I am just curious to see if it does appeal to anyone, but of course I am not mad if it does not.
You can now disable the bottom or top box if through the options dialogue. Shout-out to BC-1986 for pointing this out.

This is what the page looks like if you disable the Bookmark bar or the Other bookmarks section:

As you can see, the top box is empty except for the Chrome links. This only works if you don’t use any apps.

This can also be done the other way around. Note that I picked an unsorted folder in order to show an example of a long list of bookmarks, that’s why the titles are so long. It will also display apps if there are any.

Like it? Hate it? Leave me a comment : ) Also, I appreciate any bug reports!

Coming soon: Version 1.2.1 of the Bookmark Button Startpage

Sun, 13 Mar 2011 19:04:52 +0100

I am about to release the next minor version of the Bookmark Button startpage which fixes an annoying bug which rose with version 10 of the Google Chrome webbrowser.

The problem was the following: Whenever you would open a bookmark, app or just any link on the page, the adres bar at the top of the tab would not display the adres where you were at. This is mostly a cosmetic problem, but still a nuisance. With the fix, the adresses should be shown properly again.

Also I added a new section in the extension options pages for donations. Apart from that, I fixed a small inconsistency in the page CSS and added a new theme which I labelled Plain Grey:

I will take my time to search and fix further bugs which I may have created afterwards. Over the next couple of days the update will take place and automatically roll to users.