1) The document discusses the author's experience building their own node.js web framework, including their background with other technologies like Ruby on Rails. 2) It describes the key features of their framework, such as MVC structure, middleware support, asset packaging, and command line tools. 3) The author explains that they rolled their own framework to learn more about how frameworks work, have more control over the technology stack, and because node.js performance is better than Ruby on Rails. They emphasize that building the framework was a fun learning experience.

1. How and why I roll my own
node.js framework

2. Agenda
• A very brief introduction to node.js
• Personal technical skill background
• What is the minimal features a web framework must have?
• From express to plain node and back to express again
• Framework features
• Live demo
• Why do I roll my own node.js framework?

3. A very brief
introduction to
Node.js

4. What is node.js?

5. Node.js is a none-blocking
I/O , event-driven server-
side javascript. It runs on
google’s v8 javascript
engine.

6. Um ...

7. ???

8. What is node really?

9. Node is JavaScript on the server

10. and it’s blazing fast

11. Personal technical skill background

12. Front-end developer ->
Node.js ->
Rails ->
Codeigniter(Php) ->
Rails(Ruby) ->
Node.js(JavaScript)

13. What is the minimal features
a web framework must have?

14. A.K.A
the most
important feature

15. Router?

16. NO

17. Code generators?

18. NO

19. ORM, Helpers,
Templates,
Command line
console ...

20. NO, NO, NO!!!

21. It’s project structure!

22. Example project structure
.
|-- configs.js
|-- app
| |-- controllers
| |-- models
| `-- views
|-- core
`-- public
|-- css
|-- img
`-- js

23. My first try

24. Define controllers
// Ex. users.js
module.exports = {
index : function ( req, res ){
//...
},
show : function ( req, res ){
//...
},
new : function ( req, res ){
//...
},
create : function ( req, res ){
//...
}
// ....
};

25. Load controllers into a hash
var controllers = {};
require( 'fs' ).readdir( PATH_TO_CONTROLLERS, function( err, files ){
if( err ) throw err;
files.forEach( function( file ){
if( /.js$/.test( file )){
var controller = require( PATH_TO_CONTROLLERS + file );
Object.keys( controller ).forEach( function ( action ){
var name = file.replace( '.js', '' );
// Ex. controllers[ 'users/index' ] = controller[ action ];
controllers[ name + '/' + action ] = controller[ action ];
});
}
});
});

26. Start server
require( 'http' ).createServer( function( req, res ){
var handler = require( 'url' ).
parse( req.url, true ).
pathname.
replace( /(/$)/g, '' );
if( controllers[ handler ]){
try{
controllers[ handler ]( req, res );
}catch( err ){
res.error( 500, err );
}
}else{
res.error( 404 );
}
}).listen( PORT, HOST );

27. From Express to plain node
and back to Express again

28. Intro to connect and express
Node -> Ruby
Connect -> Rack
Express -> Sinatra

29. What is middleware
and How does it work?

30. •WSGI (Python)
•Rack (Ruby)
•PSGI and Plack (Perl)
•Hack2 / WAI (Haskell)
•JSGI & Jack (JavaScript)
•Ring (Clojure)
•EWGI (Erlang)
•PHP Rack (PHP)

31. app.configure( function (){
app.use( express.bodyParser());
app.use( express.methodOverride());
app.use( app.router );
});

32. Source: http://www.godfat.org/slide/2011-08-27-rest-
core.html#slide68

33. Middlewares, good or bad?

34. Performance <---> Flexibility

35. Flexibility and
maintainability
won the battle

36. Final features

37. • MVC structure.
• Mongoose as ODM (mongodb) with validation.
• Lightening fast template parsing with thunder.
• RESTful routing, supports namespace and nested resource.
• Middlewares and 3rd party libs support.
◦ All connect and express middlewares compatible.
◦ Socket.io compatible.
• Assets pipeline.
• Cluster support.
• Comprehensive logger for debugging.
• Command line tools.
◦ Powerful generators for project prototyping.
◦ Model command line console.
◦ Project routes inspecttion.

38. Packages that help to build
a web framework

39. Flow control
View parser
Asset packer
Inflection

40. Flow control
var flow = new Flow();
// set global variables
flow.series( function ( next ){
require( './lib/global' )( base_dir, next );
}).
// load logger
series( function ( next ){
require( CORE_DIR + 'logger' );
// this has to go after the `require`
LOG.sys( 'loading core module: logger' );
next();
}).
// load util
series( function ( next ){
LOG.sys( 'loading core module: utils' );
require( CORE_DIR + 'utils' );
next();
}).
// load model
series( function ( next ){
LOG.sys( 'loading core module: model' );
require( CORE_DIR + 'model' )( next );
}).
// load express
series( function ( next ){

41. // load express
series( function ( next ){
LOG.sys( 'loading core module: express' );
require( CORE_DIR + 'express' )( next );
}).
// load lib
parallel( function ( results, ready ){
var app = results[ 0 ];
LOG.sys( 'loading core module: lib' );
require( CORE_DIR + 'lib' )( app, ready );
}).
// load helper
parallel( function ( results, ready ){
var app = results[ 0 ];
LOG.sys( 'Loading helper: application' );
require( HELPER_DIR + 'application' )( app );
ready();
}).
// load assets
parallel( function ( results, ready ){
var app = results[ 0 ];
LOG.sys( 'loading core module: assets' );
require( CORE_DIR + 'assets' )( app, ready );
}).
// overwrite res.send
parallel( function ( results, ready ){
var app = results[ 0 ];
LOG.sys( 'Overwriting express res.send' );

42. // overwrite res.send
parallel( function ( results, ready ){
var app = results[ 0 ];
LOG.sys( 'Overwriting express res.send' );
require( CORE_DIR + 'response' );
ready();
}).
join().
//load controller_brige
series( function ( results, next ){
var app = results[ 0 ][ 0 ];
LOG.sys( 'loading core module: controller_bridge' );
require( CORE_DIR + 'controller_bridge' )( app, next );
}).
// start server
series( function ( app, next ){
LOG.sys( 'loading core module: server' );
require( CORE_DIR + 'server' )( app, next );
}).
// load 'after server start libs'
end( function ( app ){
LOG.sys( 'loading core module: started' );
require( CORE_DIR + 'started' )( app );
});
https://github.com/dreamerslab/node.flow

43. View parser
<!DOCTYPE html>
<html>
<head>
<title><?= it.title ?></title>
</head>
<body>
<h1 class="header"><?= it.header ?></h1>
<ul class="list">
<? for( var i = 0, l = it.list.length; i < l; i++ ){ ?>
<li class="item">'<?= it.list[ i ] ?>'</li>
<? } ?>
</ul>
</body>
</html>
https://github.com/dreamerslab/thunder

44. Asset packer
https://github.com/dreamerslab/node.packer
Inflection
https://github.com/dreamerslab/node.inflection

45. Yes,
most of the features
are from Rails

46. So why not just Rails?

47. Rails is quite slow
compare to node

48. Both
dev and production
env are hard to setup

49. ***Dude I just want to write some code***

50. Backward compatibility is
‘0’

51. Don't get me wrong,
I still love its
architecture
and most of the
conventions

52. Best part of node

53. It’s a lot like
PHP in many ways

54. The language itself is
simple( but powerful )

55. You can start with
plain node and still
get your apps to work
very quickly

56. Depends on how complicated
your app is you can choose
different frameworks
builds on top of node

57. Live demo :D

58. Why I roll my own node.js
framework?

59. It’s fun !

60. You will definitely learn a lot in the process even if your framework is
not as popular as rails you should still give it a try. It really helps you
understanding how a framework work so that you can write better app
code.

61. Happy coding :)

62. Ben Lin
ben@dreamerslab.com
http://twitter.com/dreamerslab
https://github.com/dreamerslab