These are the slides to a talk I gave at Pittsburgh techFest 2012. The topic was an overview of the Node.js framework, and how you can use it to build amazing things.
* See more of my work at http://www.codehenge.net
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
6.
7. Outline
What is Node.js?
Technology Overview
How does it work?
Demo
Code!
Deployment and Hosting
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?
13.
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
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
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
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
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)
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
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');
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/