Introdution to Node.js
Download as KEY, PDF0 likes638 views
Node.js is an event-driven I/O platform for JavaScript that allows non-blocking, asynchronous code for building scalable network applications. It uses an event loop model that handles concurrent connections efficiently by doing useful work on the CPU when waiting for I/O operations to complete. Node.js comes with a package manager (NPM) and a rich ecosystem of modules. It is well-suited for real-time applications due to its asynchronous and non-blocking nature which allows for high throughput and scalability.
![Got Pong?
vows
.describe('API Service')
.addBatch
'Ping':
topic: -> zombie.visit("http://127.0.0.1/api/ping", this.callback)
'should respond with pong': (browser) ->
JSON.parse(browser.text('body'))['pong'].should.be.true](https://image.slidesharecdn.com/nodejs-20110715-110715102459-phpapp02/85/Introdution-to-Node-js-26-320.jpg)
Introdution to Node.js
- 2. What’s Node?
- 3. What’s Node? Evented I/O for V8 JavaScript
- 4. Evented I/O • Don’t wait for I/O to complete • Instead, do useful stuff on the CPU • When I/O has finished, execute callback code
- 5. An Example File.open('/etc/motd', 'w') do |f| logger.debug(f.read) end
- 6. An Example fs.readFile '/etc/motd', (err, data) -> console.log(data) unless err
- 7. An Example fs.readFile('/etc/motd', function(err, data) { if (!err) { return console.log(data); } });
- 8. Evented I/O • Prior to Node, no I/O libraries for JavaScript
- 9. Modules • Organise functionality • No interference with other code
- 10. Loading a module hello = require('hello') hello.world()
- 11. hello.coffee exports.world = () -> console.log('Hello World') hello = require('hello') hello.world()
- 12. Listening to Events hello_world = new HelloWorld() hello_world.on 'generated', (text) -> console.log text
- 13. Emitting Events class HelloWorld extends EventEmitter generate: -> this.emit 'generated', 'Hello World!' hello_world.on 'generated', (text) -> console.log text
- 14. Gems? • The Node Package Manage (NPM) is awesome • Find packages at http://search.npmjs.org/ • Node, and packages, are asynchronous by design
- 15. Consider this http = require('http'); http.createServer (req, res) -> respond_later = () -> res.writeHead 200, {'Content-Type': 'text/plain'} res.end 'Thank you for waiting 2 secondsn' setTimeout respond_later, 2000 .listen(1337, "127.0.0.1")
- 16. Got Speed? 1000 concurrent users 10 requests / user 1 node server What’s your estimate?
- 17. Watch it online... http://vimeo.com/ariejan/jmeter- benchmark-of-nodejs
- 18. Got Speed? 1000 concurrent users 10 requests / user 1 node server Average Response Time: 2007 ms
- 19. It’s got speed... ... but does it offer quality?
- 20. Take your vows • Asynchronous Behaviour Driven Development
- 21. An example, again... JSONToolbox.com
- 22. Honour your vows API Service Random password with a negative length of -32 ✓ should receive a password of length 32 Random password with a length > 256 ✓ should receive a password of length 256 Random password with length 40 ✓ should receive a password of length 40 Random password with default length ✓ should receive a valid response ✓ should receive a password of length 12 by default User agent ✓ should report the user agent string IP Address ✓ should report client IP address as 127.0.0.1 Ping ✓ should respond with pong ✓ OK » 10 honored (0.087s)
- 23. Honour your vows ✓ OK » 10 honored (0.087s)
- 24. Got Ping? app.get '/api/ping', (req, res) -> res.contentType('application/json') res.send { "pong" : true }
- 25. Enter Zombies • Headless, full-stack testing • It’s capybara, but faster • Oh, of course it’s asynchronous as well
- 26. Got Pong? vows .describe('API Service') .addBatch 'Ping': topic: -> zombie.visit("http://127.0.0.1/api/ping", this.callback) 'should respond with pong': (browser) -> JSON.parse(browser.text('body'))['pong'].should.be.true
- 27. Useful stuff • coffee-script - duh! • express - Sinatra inspired web framework • socket.io - cross-browser websockets • vows, zombie - BDD • nodeunit - TDD / Unit testing • redis - Fast in memory DB, with PubSub support
- 28. Link Fest • http://nodejs.org • http://vowsjs.org • http://zombie.labnotes.org • http://search.npmjs.org • https://github.com/ariejan/jsontoolbox • https://github.com/ariejan/apocalypse
- 29. Q&A
- 30. Thank you! Good Night!
Editor's Notes
- #2: Welcome et. all.\n
- #3: This talk is about Node.js, or Node. Does anyone know what Node is, actually?\n
- #4: Node brings Evented I/O to the V8 JavaScript Engine. V8 is Google’s open source JavaScript engine, it’s used in Google Chrome.\n
- #5: Evented I/O makes Node lightning fast. While waiting for some I/O to happen, it continues to utilize the CPU. Let’s skip to an example, shall we?\n
- #6: Reading a file from disk, slow I/O. See this ruby example. If f.read takes X seconds, execution is blocked for X seconds - nothing else happens.\n
- #7: Node goes do other stuff while waiting for I/O to complete. When the data is ready (or an error occurred), execute the callback function to continue processing the data. This is Coffee script btw.\n
- #8: Okay, plain JavaScript for the non-coffeescripters.\n
- #9: \n
- #10: Modules allow you to organise functionality in logic units. These units can’t interfere with each other, because they are .. modular.\n\nTell about how JS files loaded all use the same variable scope.\n
- #11: This is how you load a module in Coffee Script. Then you can call a method from that module.\n
- #12: The hello module implementation.\n
- #13: Events are an awesome pattern. Here’s an example.\n
- #14: This is how you’d write the implementation. Of course in coffee script. Now wait for someone to call hello_world.generate()\n
- #15: NPM\nNode was designed from the ground up. There is no ‘sync-node’, everything was designed to be async. Including packages for everything.\n
- #16: A simple Node HTTP Server. When a request comes in we set a 2 second timer and then respond. Each request should take about 2 seconds to complete. \n
- #17: Take a 1000 **concurrent** users; who’ll send 10 requests in succession each. How long does it take to run this test? For time’s sake, I’ll show you a video instead of running it live.\n\n10k requests at 2 seconds each on 1 server: 20k seconds, about 5.5 hours\n
- #18: Show em! - http://vimeo.com/ariejan/jmeter-benchmark-of-nodejs\n
- #19: Be amazed. Requests return on average after 2007ms. This means Node is not waiting 2 seconds before accepting the next request. When a timer goes, the response is send immediately.\n
- #20: How about testing?\n
- #21: Async tests! So they aren’t blocking on I/O either and therefore are lightning fast, just like Node is!\n
- #22: JSONToolbox. A Node project by yours truly.\n
- #23: Are my vows honoured? Yes the are ;-)\n
- #24: DO YOU SEE IT?! Yes, 10 specs, including starting and shutting down a server, in 0.087s!\n
- #25: Okay, first, here’s what we got. But, this is an API. Where's my capybara?\n
- #26: We’ll need full-stack testing here to make sure everything works ‘in the browser’. We’ll use Zombie.js\n
- #27: We’ll describe the API Service. Batches are executed sequentially. Tests within a batch are run asychroniously.\n
- #28: Some packages I’ve found to be useful.\n
- #29: Some links\n
- #30: Any questions?\n
- #31: Bye bye\n