Why?Why the event loop?The Event Loop is a software pattern that facilitates non-blocking I/O (network, file or inter-processcommunication). Traditional blocking programming does I/O in the same fashion as regular functioncalls; processing may not continue until the operation is complete. Here is some pseudo-code thatdemonstrates blocking I/O:1 var post = db.query(‘SELECT * FROM posts where id = 1‘);2 // processing from this line onward cannot execute until the line above completes3 doSomethingWithPost(post);4 doSomethingElse();What is happening here? While the database query is being executed, the whole process/threadidles, waiting for the response. This is called blocking. The response to this query may take manythousands of CPU cycles, rendering the entire process unusable during this time. The process couldhave been servicing other client requests instead of just waiting for the database operation tocomplete.Programming in this way does not allow you to parallelize I/O (such as performing another databasequery or communicating with a remote web service). The call stack becomes frozen, waiting for thedatabase server to reply.This leaves you with two possible solutions to keep the process busy while it’s waiting: create morecall stacks or use event callbacks.

Solution 1: Create more call stacksIn order for your process to handle more concurrent I/O, you have to have more concurrent callstacks. For this, you can use threads or some kind of cooperative multi-threading scheme like coroutines,fibers, continuations, etc.The multi-threaded concurrency model can be very difficult to configure, understand and debug,mainly because of the complexity of synchronization when accessing and modifying shared state;you never know when the thread you are running is going to be taken out of execution, which canlead to bugs that are strange and difficult to reproduce.On the other hand, cooperative multi-threading is a “trick” where you have more than one stack,and each “thread” of execution explicitly de-schedules itself to give time to another parallel “thread”of execution. This can relax the synchronization requirements but can become complex and errorprone,since the thread scheduling is left in the hands of the programmer.

Solution 2: Use event-driven I/OEvent-driven I/O is a scheme where you register callbacks to be invoked when an interesting I/Oevent happens.An event callback is a function that gets invoked when something significant happens (e.g. the resultof a database query is available.)To use event callbacks in the previous example, you could change it to:1 callback = function(post) {2 doSomethingWithPost(post); // this will only execute when the db.query function3 returns.4 };5 db.query(‘SELECT * FROM posts where id = 1‘, callback);6 doSomethingElse(); // this will execute independent of the returned status of the7 db.query call.Here you are defining a function to be invoked when the database operation is complete, then passingthis function as a callback argument to the db query operation. The db operation becomes responsiblefor executing the callback when the result is available.You can use an inline anonymous function to express this in a more compact fashion:1 db.query(‘SELECT * FROM posts where id = 1‘,2 function(post) {3 doSomethingWithPost(post); // this will only execute when the db.query functi4 on returns.5 }6 );7 doSomethingElse(); // this will execute independent of the returned status of the8 db.query call.While db.query() is executing,the process is free to continue running doSomethingElse(), and evenservice new client requests.

For quite some time, the C systems-programming “hacker” community has known that event-drivenprogramming is the best way to scale a server to handle many concurrent connections. It has beenknown to be more efficient regarding memory: less context to store, and time: less context-switching.This knowledge has been infiltrating other platforms and communities: some of the most wellknownevent loop implementations are Ruby’s Event Machine, Perl’s AnyEvent and Python’sTwisted, and some others.Tip: For more info about event-driven server implementations, see http://en.wikipedia.org/wiki/Reactor_-pattern?.Implementing an application using one of these event-driven frameworks requires frameworkspecificknowledge and framework-specific libraries. For example: when using Event Machine, youmust avoid using all the synchronous libraries available in Ruby-land (i.e. most libraries). To gainthe benefit of not blocking, you are limited to using libraries that are specific for Event Machine. Ifyou use blocking libraries, your program will not be able to scale optimally because the event loop isconstantly being blocked, which may delay the processing of I/O events and makes your applicationslow, defeating the original purpose of using event-driven I/O.Node has been devised as a non-blocking I/O server platform from day one, which means that youshould expect everything built on top of it to be non-blocking (with some specific and very explicitexceptions). Since JavaScript itself is very minimal and does not impose any way of doing I/O (itdoes not have a standard I/O library like C, Ruby or Python), Node has a clean slate to build upon.

Why JavaScript?Ryan Dahl began this pet project of his by building a platform that was programmable in C, but hesoon realized that maintaining the context between callbacks was too complicated and could leadto poorly structured code. He then turned to Lua.Lua already has several blocking I/O libraries and the mix of blocking and non-blocking couldconfuse average developers and prevent many of them from building scalable applications, so Luawasn’t ideal either. Dahl then thought to JavaScript.JavaScript has closures and first-class functions, making it indeed a powerful match with eventedI/O programming.Closures are functions that inherit the variables from their enclosing environment. When a functioncallback executes it will magically remember the context in which it was declared, along with allthe variables available in that context and any parent contexts. This powerful feature is at the heartof Node’s success among programming communities. Let’s see a little bit of this goodness in action:In the web browser, if you want to listen for an event, a button click for instance, you may dosomething like:1 var clickCount = 0;2 document.getElementById(‘mybutton‘).onclick = function() {3 clickCount ++;4 alert(‘Clicked ‘ + clickCount + ‘ times.‘);5 };or, using jQuery:?http://en.wikipedia.org/wiki/Reactor_patternWhy? 71 var clickCount = 0;2 $(‘button#mybutton‘).click(function() {3 clickCount ++;4 alert(‘Clicked ‘ + clickCount + ‘ times.‘);5 });In both examples we assign or pass a function as an argument. This function will then be executedlater once the relevant event (button clicking in this case) happens. The click handling function hasaccess to every variable in scope at the point where the function is declared, i.e. practically speaking,the click handler has access to the clickCount variable, declared in the parent closure.Here we are using a global variable, “clickCount”, where we store the number of times the user hasclicked a button. We can also avoid having a global variable accessible to the rest of the system,by wrapping it inside another closure, making the clickCount variable only accessible within theclosure we created:1 (function() {2 var clickCount = 0;3 $(‘button#mybutton‘).click(function() {4 clickCount ++;5 alert(‘Clicked ‘ + clickCount + ‘ times.‘);6 });7 })();In line 7 we are invoking a function immediately after defining it. If this is strange to you, don’tworry! We will cover this pattern later.Here you don’t have to worry about synchronization: your callback function will not be interrupteduntil it returns - you have that guarantee.

How I Learned to Stop Fearing and Love JavaScriptJavaScript has good and bad parts. It was created in 1995 by Netscape’s Brendan Eich, in a rush toship the latest version of the Netscape web browser. Due to this rush some good, even wonderful,parts got into JavaScript, but also some bad parts.This book will not cover the distinction between JavaScript good and bad parts. (For all we know, wewill only provide examples using the good parts.) For more on this topic you should read DouglasCrockford book named “JavaScript, The Good Parts”, edited by O’Reilly.In spite of its drawbacks, JavaScript quickly - and somewhat unpredictably - became the de-factolanguage for web browsers. Back then, JavaScript was used primarily to inspect and manipulateHTML documents, allowing the creation the first dynamic, client-side web applications.In late 1998, the World Wide Web Consortium (W3C), standardized the Document Object Model(DOM), an API devised to inspect and manipulate HTML documents on the client side. In responseto JavaScript’s quirks and the initial hatred towards the DOM API, JavaScript quickly gained abad reputation, also due to some incompatibilities between browser vendors (and sometimes evenbetween products from the same vendor!).Despite mild to full-blown hate in some developer communities, JavaScript became widely adopted.For better or for worse, today JavaScript is the most widely deployed programming language onplanet Earth – and growing.If you learn the good features of the language - such as prototypical inheritance, function closures,etc. - and learn to avoid or circumvent the bad parts, JavaScript can be a very pleasant language towork in.Function Declaration StylesA function can be declared in many ways in JavaScript. The simplest is declaring it anonymously:1 function() {2 console.log(‘hello‘);3 }Here we declare a function, but it’s not of much use, because we do not invoke it. What’s more, wehave no way to invoke it as it has no name.We can invoke an anonymous function in-place:1 (function() {2 console.log(‘hello‘);3 })();Here we are executing the function immediately after declaring it. Notice we wrap the entirefunction declaration in parenthesis.We can also name functions like this:1 function myFunction () {2 console.log(‘hello‘);3 }Here we are declaring a named function with the name: “myFunction”. myFunction will be availableinside the scope in which it’s declared1 myFunction();and also within inner scopes:1 function myFunction () {2 console.log(‘hello‘);3 }45 (function() {6 myFunction();7 })();A result of JavaScript treating functions as first-class objects means we can assign a function to avariable:1 var myFunc = function() {2 console.log(‘hello‘);3 }This function is now available as the value of the myFunc variable.We can assign that function to another variable:1 var myFunc2 = myFunc;And invoke them just like any other function:1 myFunc();2 myFunc2();We can mix both techniques, having a named function stored in a variable:1 var myFunc2 = function myFunc() {2 console.log(‘hello‘);3 }4 myFunc2();(Note though, we cannot access myFunc from outside the scope of myFunc itself!)We can then use a variable or a function name to pass variables into functions like this:1 var myFunc = function() {2 console.log(‘hello‘);3 }45 console.log(myFunc);or simply declare it inline if we don’t need it for anything else:1 console.log(function() {2 console.log(‘hello‘);3 });

Functions are first-class objectsIn fact, there are no second-class objects in JavaScript. JavaScript is the ultimate object-orientedlanguage, where (almost) everything is indeed, an object. As that, a function is an object where youcan set properties, pass it around inside arguments and return them.Example:1 var scheduler = function(timeout, callbackfunction) {2 return function() {3 setTimeout(callbackfunction, timeout)4 }5 };67 (function() {8 var timeout = 1000; // 1 second9 var count = 0;10 var schedule = scheduler(timeout, function doStuff() {11 console.log(++ count);12 schedule();13 });14 schedule()15 })();1617 // "timeout" and "count" variables18 // do not exist in this scope.In this little example we create a function and store it in a variable called “scheduler” (starting online 1). This function returns a function that sets up a timer that will execute a given function withina certain number of miliseconds (line 3). This timeout will schedule a callback function to be calledafter a time delay of 1 second, as specified by the timeout variable.Why? 11In line 9 we declare a function that will immediately be executed in line 15. This is a normal wayto create new scopes in JavaScript. Inside this scope we create 2 variables: “timeout” (line 8) and“count” (line 9). Note that these variables will not be accessible to the outer scope.Then, on line 10, we invoke the scheduler function, passing in the timeout value as first argumentand a function called doStuff as second argument. This returns a function that we store in the localschedule variable, which we later invoke (line 14), provoking the setTimeout to be called. When thetimeout occurs, this function will increment the variable count and log it, and also call the scheduleall over again.So in this small example we have: functions passed as argument, functions to create scope, functionsto serve as asynchronous callbacks and returning functions. We also here present the notions ofencapsulation (by hiding local variables form the outside scope) and recursion (the function is callingitself at the end).In JavaScript you can even set and access attributes in a function, something like this:1 var myFunction = function() {2 // do something crazy3 };4 myFunction.someProperty = ‘abc‘;5 console.log(myFunction.someProperty);6 // #=> "abc"JavaScript is indeed a powerful language, and if you don’t already, you should learn it and embraceits good parts.

JSHintIt’s not to be covered here, but JavaScript indeed has some bad parts, and they should be avoided atall costs.One tool that’s proven invaluable to me is JSHint. JSHint analyzes your JavaScript file and outputs aseries of errors and warnings, including some known misuses of JavaScript, such as using globallyscopedvariables (like when you forget the “var” keyword), and freezing values inside iteration thathave callbacks that use them, and many others that are useful.JHLint can be installed using1 $ npm install -g jshintIf you don’t have Node installed see section about NPM?.and can be run from the command line like this:?index.html#npmWhy? 121 $ jshint myfile.jsYou can also define what rules this tool should obey by defining and customizing a .jshintrc insideyour home directory. For more information on JSHint plrease refer to the official documentation athttp://www.jshint.com/docs/?.

JavaScript versionsJavaScript is a standard with its own name - ECMAScript - and it has gone through various iterations.Currently Node natively supports everything the V8 JavaScript engine supports ECMA 3rd editionand parts of the new ECMA 5th edition.These parts of ECMA 5 are nicely documented on the following github wiki page: https://github.com/joyent/node/wiki/5-Mozilla-Features-Implemented-in-V8?