This document discusses server-side event-driven programming and Node.js. It covers key concepts like asynchronous programming using callbacks and event loops. Node.js uses asynchronous and non-blocking I/O to minimize overhead and maximize scalability compared to traditional threaded models. Common Node.js applications include APIs, proxies, and simple data transformations.

1. Emerging Paradigms -
Server Side Event Driven
Programming
Kamal Hussain
http://www.linkedin.com/in/hussainkamal/

2. Agenda
● Linear Vs Nonlinear Code
● Concurrency through threads and events
● Event loop
● PHP and Javascript
● Node.js - closeup
● Important concepts

3. We are used to ..
val client = new HttpClient()
val method = new GetMethod("http:
//www.google.com")
val statusCode = client.executeMethod
(method)
println("Server responded with %d" .
format(statusCode))

4. Event driven approach
var callback = function(data) {
console.log("firing callback " +
data);
};
$.get('/endpoint', callback);
console.log('Did you see callback?');

5. Achieving scale and concurrency
● Multiple threads/processes
● Size the threadpool correctly
● Each thread is responsible for one task such
as serving a request
● Asynchronous programming

6. Asynchronous with
threads/processes

7. Asynchronous with events

8. Problems with Threads
● Hard to program
● Memory requirements are high
● Large overhead
● Context switching
● Priority inversion

9. Threads wait
udemy.com

10. Cost of IO
L1 Cache 3 Cycles
L2 Cache 14 Cycles
RAM 250 cycles
Disk 41 000 000 cycles
Network 240 000 000 cycles

12. Event Loop Architecture
courtsey: http://www.johanndutoit.net/

13. Writing synchronous Vs
Asynchronous
// Good: write files asynchronously
fs.writeFile('message.txt', 'Hello Node', function (err) {
console.log("It's saved and the server remains responsive!");
});
// BAD: write files synchronously
fs.writeFileSync('message.txt', 'Hello Node');
console.log("It's saved, but you just blocked ALL requests!");
This can cause performance drop from thousands of requests/seconds to a few
dozen/second.
http://engineering.linkedin.com/nodejs/blazing-fast-nodejs-10-performance-tips-linkedin-
mobile

14. Tale of two languages
● PHP was invented in 1994 by Rasmus
Lerdorfas as a replacement for CGI scripts
● PHP was a substitute for single-threaded C
programs
● Brendan Eich developed Javascript in 1995
for a completely different purpose. JS was
designed to run within Netscape Navigator
and was primarily designed to handle
events.
PHP -> eventless, Javascript -> eventful

15. Node.js
● Ryan Dahl invented Node.js in 2009 as a
continuation of Javascript heritage.
● Node.js is modeled after multi-task, multi-page
handling of a web server.

16. What's Node.js?
"Node.js is a server-side software system designed for
writing scalable Internet applications, notably web servers.
Programs are written on the server side in JavaScript,
using event-driven, asynchronous I/O to minimize overhead
and maximize scalability."
- from wikipedia

17. Node.js - asynchronous I/O
● First class functions
● Closures
● Event loop
● Callback counters
CPU intensive tasks are delegated to workers

18. PHP Way
$fp = fopen("fp.txt", 'w)
fwrite($fp, "hello world");
fclose($fp);

19. Node.js way
var fs = require('fs');
fs.open('fp.txt', 'w', 0666,
function(error, fp) {
fw.write(fp, 'helloworld', null,
'utf-8', function() {
fs.close(fp, function(error) {
});
});
});

20. Node.js simple example
var http = require('http');
http.createServer(function(req, res) {
res.writeHead(200, {'Content-Type' :
'text/plain'});
res.end("Hello Worldn");
}).listen(8000, "127.0.0.1");
console.log("Server running at http:
//127.0.0.1:8000");

21. Node.js Core APIs
Events
EventTransmitter
Event listener
Event emitter
Call back
Http
I/O

22. Node.js Workers
Synchronous call
Workers are blocked
Call returns

23. Workers Vs Events
Workers
1 event per connection
N workers per CPU
Events
N connections per CPU
1 process per CPU

24. Node.js Typical Applications
● Proxy
● API server
○ REST API calls
○ Simple transformations
See performance comparisons at:
http://www.slideshare.net/FabianFrankDe/nodejs-performance-case-study

25. Concepts to learn
First class functions
Lambdas - anonymous functions
Closures
Non-blocking IO

26. Deploying Node.js
http://www.slideshare.net/BenLin2/webconf-nodejsproductionarchitecture

27. Key takeaway
Learn Javascript and
functional programming.
Future is brighter :)

28. Reference
● Node - Up and Running by Tom Hughes-Croucher,
Mike Wilson - Oreilly
● Node.js for PHP Developers - Oreilly
● Javascript: The definitive guide - Oreilly
● LinkedIn, Netflix Blogs
● http://architects.dzone.com/articles/nodejs-php-programmers-
1-event
● https://www.udemy.com/lectures/understanding-the-nodejs-
event-loop-91298
● https://speakerdeck.com/guldenpt/before-start-coding-in-
node-dot-js