The document provides an overview of node.js, an event-driven server-side JavaScript environment designed for building fast and scalable network applications. It highlights the efficiency of the v8 engine and the advantages of an event-driven, non-blocking I/O model. The presentation also covers the node.js API, community modules, and deployment options, along with a coding demonstration.

1. Node.js
A Guided Tour
Presenter: C. Aaron Cois, Ph.D.

2. The web is changing
 It used to be about consumption

3. Real-time Interaction

4. Real-time Interaction
 Real-Time Games
 Chat
 Stock tickers
 Twitter Feeds
 Collaboration
 Creation
…on a massive scale

5. What do we need to make it
happen?
 Fast, persistent I/O
 HTTP wasn’t built for this
 Server’s need to push data to clients
 Polling is slow and inefficient
 Scalability
 Usability
 Maintainability

7. Outline
 What is Node.js?
 Technology Overview
 How does it work?
 Demo
 Code!
 Deployment and Hosting

8. What is Node.js?

9. Node.js
 Node.js
is an event-driven, server-side
JavaScript environment
 Based on the V8 JavaScript Engine,
developed by Google
 Most importantly, node.js is a
 server-side runtime environment, that
 compiles and executes JavaScript very
efficiently.

10. Platforms
 Runs on OSX, Linux, Windows
 Clickable installers for:
 Windows
 Mac OSX
 Linux has apt-get and yum

11. Why Node?
 Node.js is specifically designed for
building fast, efficient, scalable network
applications
 Node uses an event-driven, non-blocking
I/O model to maximize efficiency

12. Technology: V8 Engine
 Developed by Google
 Ships with the Google Chrome web browser
 Allows Chrome to run JavaScript code much
faster
 It does this by compiling the JavaScript directly
into native machine code
 As opposed to interpreting JavaScript, or
execute it as bytecode
 What does this mean for us, and for Node.js?

14. Technology: JavaScript
 JavaScript is:
 A fully-functional programming language
 Capable of doing anything other traditional
languages (C++, Java, Ruby, etc) can do
 Has an excellent event model
 Traditionally resigned to the context of the
web application frontend
 i.e. running inside a web browser

15. Technology: JavaScript2
 There’sno reason the JavaScript
language can’t be used elsewhere (say,
server-side)
 This is where node.js comes in, executing
JavaScript efficiently on the server-side
 JavaScript brings to Node.js:
 Natural event-based programming, ideal
for client-server applications
 A known language, with low overhead

16. Who is using Node.js?

17. How does it work?

18. The Basic Idea
I/O is expensive

19. *http://blog.mixu.net/2011/02/01/understanding-the-node-js-event-loop/

20. Ways to deal with I/O
 Synchronous
 One requests at a time, first come, first serve
 Fork
 New process for each request
 Threads
 New thread for each request
*http://www.nightmare.com/medusa/async_sockets.html

21. Another Thesis
Thread-per-connection
is memory-expensive

23. Traditional Threaded Model
N worker threads/processes
 Each incoming connection handed
to a worker
 That worker is now “in use”, and can
handle no other connection, even if it is
waiting on:
 FileI/O
 DB I/O
 Network I/O
 etc

24. The life of a worker…
Waiting on Waiting on Waiting on DB…
File I/O… Network
Response…
Time

25. The life of a worker…
Blocking Wastes Cycles
Waiting on Waiting on Waiting on DB…
File I/O… Network
Response…
Time

26. The Other Basic Idea
Writing (Good) Threaded
Code is DIFFICULT

27. The life of N workers…
Thread 1
Thread 2
Thread 3
Thread 4
Time

28. The life of N workers…
Thread 1
Thread 2
Thread 3
Thread 4
Time

29. The life of N workers…
Thread 1
Thread 2
ALL PROCESSES IDLE
Thread 3
Thread 4
Time

30. Even worse…
 If
all threads are in use, every incoming
connection is blocked
 Thiscan cause
massive traffic jams
on high-throughput
applications

31. Is this the only way?
There is
another…

32. The Node.js way
 Axiom:
 Multi-Threaded code
 Is difficult to write
 Is difficult to debug
 Sucks up more dev/test/maintenance cycles
 Most often has inefficient performance
 Conclusion:
 Screw it: Write code using a single thread

33. Single threaded?!?
Skeptical? I don’t blame you
But hear me out…

34. Node.js Event Loop
 Event Loop (from Wikipedia):
 A “construct that waits for and dispatches
events or messages in a program”
 Instead
of performing I/O ourselves, we
dispatch I/O events to Node’s event loop
 It handles threads, process optimization,
concurrency, etc

35. Node.js Event Loop
DB I/O command to event loop
Net I/O command to event loop
File I/O command to event loop
Time

36. Node.js Event Loop
DB I/O command to event loop
Net I/O command to event loop
File I/O command to event loop Open for
more work!
Time

37. Node.js app code…
 Isrun entirely in a single thread
 Passes I/O requests to the event loop,
along with callbacks
 Your code then:
 Goes to sleep
 Uses no system resources
 Will be notified via callback when I/O is
complete

38. Callback example
var filename = “test_file.txt”;
fs.open(filename, “w”, function(err, file) {
if (err) throw err;
});

39. Callback example
Filesystem module forwards task to event loop
var file = (“test_file.txt”);
fs.open(file, “w”, function(err, file) {
if (err) throw err;
});

40. Callback example
Callback is invoked when work is complete
var file = (“test_file.txt”);
fs.open(file, “w”, function(err, file) {
if (err) throw err;
});

41. This is not magic
 The following:
for(i=0; i<5; i++) {
sleep(1000);
}
 Will
block the entire Node event loop for 5
seconds

42. Node is in charge
 Let Node.js handle
 Dispatch
 Concurrency
 (most) Async operations
 What Node doesn’t promise:
 To not block when you tell it to
 Order of execution (e.g. forked parallel
processes)

43. Interlude: Modules

44. Node.js API
 Node provides an API in the form of modules
(a.k.a. libraries)
 Modules work with event loop to dispatch async
tasks
 API modules are installed along with Node
 They provide standard application framework
functionality
 STDIO: console logging, timing, tracing
 File System: File system access
 …etc

45. A Few Good Modules
 Net Network socket support
 HTTP HTTP communication
 File System File system access
 Crypto Cryptography
 Streams STDIO
 Many more…

46. Node.js Community
 Additionally,
the Node.js community
maintains excellent modules to enhance
the capabilities of Node
 These modules operate as
 Libraries
 Toolkits
 Frameworks
 …and much more.

47. Notable Community Modules
 Express Web App Framework
 Socket.io Websockets, etc
 Passport/Everyauth Authentication
 Jade HTML Template Engine
 Connect Middleware collection
 Less Simplified CSS

48. Let’s see some code!

49. Node Web Server
var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello Worldn');
}).listen(1337, '127.0.0.1');

50. Node TCP Listener
var net = require('net');
var server = net.createServer(function (socket) {
socket.write('Echo serverrn');
socket.pipe(socket);
});
server.listen(1337, '127.0.0.1');

51. Live Demo
http://techfestchat.jit.su
Hosting courtesy of Nodejitsu

52. Any .NET Devs in the room?
 Microsoft has been expending a lot of
effort to make Node a first class
framework
And now…

53. A sneak preview!

54. MS WebMatrix 2
Open WebMatrix 2

55. Node.js Deployment and
Hosting

56. Cloud Hosting
 Heroku
 Microsoft Azure
 Nodejitsu
 Cloud Foundry
 Nodester
 DotCloud
 Appfog
 Joyent (coming soon)
 …

57. Thanks!
 Feel free to look me up at:
http://www.codehenge.net
I love questions, collaborations, and talking with
people!
 If you are interested in formal Node.js
learning, I also have a course available at:
http://www.udemy.com/learn-nodejs-by-
example/