Node.js vs Play Framework

Node.js: server-side JavaScript runtime environment;
open source; single threaded; non-blocking I/O.

express.js: the most popular web
framework for Node.js.

Play Framework: Java/Scala web framework; open
source; multithreaded; non-blocking I/O.

Yevgeniy Brikman
Former Play Tech Lead at LinkedIn. Long time Node.js user.

The framework scorecard
Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share

For each feature we discuss...
1
Much worse than most frameworks
About the same as most frameworks
Much better than most frameworks
5
10

Node.js: 1-click installers for every OS

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');
console.log('Server running at http://127.0.0.1:1337/');
server.js
The “Hello World” Node app: 1 file, 6 lines of code.

var express = require('express');
var app = express();
app.get('/', function(req, res){
res.send('Hello World');
});
var server = app.listen(1337, function() {
console.log('Listening on port %d', server.address().port);
});
server.js
The “Hello World” Express app: 1 file, 8 lines of code.

Run using node <filename>. Starts instantly!

Hit http://localhost:1337 to test

Node Beginner Book, Mastering Node.js,
Node: Up and Running, Node.js in Action

Express Web Application Development Express.js Guide

And much, much more
Tons of resources; very gradual learning curve.

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10

Play: download from playframework.com,
extract, add activator to your PATH

Generate a new app using activator new

The “Hello World” Play app: ~35 files and folders

Run the app using activator run

(Downloading all dependencies can take a
while the first time around)

Hit http://localhost:9000 to test

Play for Scala Learning Play Framework 2

Ultimate Guide to Getting Started with Play.
Not as many resources; steep learning curve.

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7

GET clients/:id Clients.show(id: Long)
def show(id: Long) = Action { request =>
getClient(id).map { client =>
Ok(views.html.clients.show(client))
}
}
Routing
app.get('clients/:id', function(req, res) {
getClient(req.params.id, function(client) {
res.render('show', client);
});
});
RESTful routing. Extracts query & path
params.
RESTful routing. Extracts query & path
params. Type safe. Actions are
composable. Reverse routing.

@(name: String, headline: String)
<div class="client">
<h1>@name</h1>
<div class="headline">
Headline: @headline
</div>
</div>
Templates
<h1>{{name}}</h1>
Headline: {{headline}}
</div>
</div>
Many template options: handlebars,
mustache, dust, jade, etc. Most support
client-side rendering!
Twirl templates are compiled into Scala
functions: type safe and composable!
Other template types via plugins.

i18n
Translations: i18next-node, i18n-node.
Formatting: moment.js, numeral.js.
Translations: Play i18n API.
Formatting: Java formatting libraries.
<h1>{{name}}</h1>
{{t "headline.label" headline=headline}}
</div>
</div>
@(name: String, headline: String)
<h1>@name</h1>
Messages("headline.label", headline)
</div>
</div>

var regForm = forms.create({
name: fields.string({required: true}),
age: fields.number({min: 18})
Forms, node-formidable, validator.js. Play form binding and validation API.
Form binding and validation
});
regForm.handle(req, {
success: function(form) { ... },
error: function(form) { ... }
});
val regForm = Form(mapping(
"name" -> nonEmptyText,
"age" -> number(min = 18)
)(UserData.apply)(UserData.unapply))
regForm.bindFromRequest.fold(
err => BadRequest("Validation error"),
data => Ok(s"Hi $data.name!")
)

// Automatically parse application/json body
app.use(bodyParser.json());
app.post('/clients', function (req, res, next) {
var name = req.body.name;
var age = req.body.age;
res.send(name + " is " + age + " years old.");
});
POST /clients Clients.create
case class Person(name: String, age: Int)
implicit val prsnFmt = Json.format[Person]
def create = Action(parse.json) { request =>
val person = request.body.as[Person]
Ok(s"$person.name is $person.age years old")
}
bodyParser, xml2js, node-formidable. Play JSON, XML, File Upload APIs.
JSON, XML, File Upload

Data
Slick, Anorm, Ebean, JPA
MySQL, MariaDB, PostgreSLQ, SQLite, Oracle, SQL Server,
DB2, Derby, H2
Sequelize, Bookshelf.js, node-orm2 SQL
MySQL, MariaDB, PostgreSQL, SQLite
NoSQL
mongojs/mongoose, cassandra-client,
cradle/nano, node_redis, node-neo4j
MongoDB, Cassandra, CouchDB, Redis, Neo4j
ReactiveMongo, DataStax, sprouch, play-plugins-
redis, Neo4j-play, JPA
MongoDB, Cassandra, CouchDB, Redis, Neo4j
node-memcached, connect-cache Caching
memcached, in-memory (not recommended)
play2-memcached, memcontinuationed,
Play Cache, ehcache, Guava
memcached, in-memory
node-db-migrate, node-migrate Schemas Play database evolutions

socket.io: server & client APIs;
WebSockets, Flash Sockets, polling, etc.
Play WebSockets, Comet, and
EventSource APIs. Server-side only.
Real-time web
// server code
io.on('connection', function (socket) {
socket.emit('msg', 'Server says hi!');
socket.on('msg', function (msg) { … });
});
def chat = WebSocket.acceptWithActor {
request => out => Props(new Chat(out))
}
class Chat(out: ActorRef) extends Actor {
def receive = {
case m: String => out ! s"Got msg: $m"
}
}
// client code
socket.emit('msg', 'Client says hi!');
socket.on('msg', function (msg) { … });

● Express.js is a minimal framework ● Play is a full stack framework
● You need plugins for most tasks
● Finding good plugins takes time
● Gluing plugins together takes time
● There are defaults for most tasks
● Defaults are mostly high quality
● All defaults can be replaced

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10

Unit testing: Jasmine, Mocha, QUnit,
nodeunit, Expresso or Vows

var request = require('supertest')
, app = require('express')();
app.get('/user', function(req, res){
res.send(200, { name: 'tobi' });
});
request(app)
.get('/user')
.expect('Content-Type', /json/)
.expect(200);
Functional testing: use supertest or call
server.listen directly.

UI testing: phantom.js or zombie.js

Code coverage: Istanbul or Blanket.js

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10

Unit testing: junit, ScalaTest, specs2, or testng

"respond to the index Action" in new App(FakeApplication()) {
val Some(result) = route(FakeRequest(GET, "/Bob"))
status(result) mustEqual OK
contentType(result) mustEqual Some("text/html")
charset(result) mustEqual Some("utf-8")
contentAsString(result) must include ("Hello Bob")
}
Functional testing: use Play’s built-in
functional test helpers.

class ExampleSpec extends PlaySpec with OneServerPerSuite with OneBrowserPerSuite {
"The OneBrowserPerTest trait" must {
"provide a web driver" in {
go to (s"http://localhost:$port/testing")
pageTitle mustBe "Test Page"
click on find(name("b")).value
eventually { pageTitle mustBe "scalatest" }
}
}
}
UI testing: use Play’s built-in integration test
helpers and built-in Selenium support.

Code coverage: jacoco4sbt or scct

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10

(not enabled by default!) Connect CSRF Middleware CSRF
(not enabled by default!)
Depends on template engine XSS Twirl escapes correctly
Vulnerabilities: eval, setTimeout, Injection
Security
CSRFFilter
setInterval, new Function Few vulnerabilities of this sort
Helmet middleware Headers SecurityHeadersFilter
passport.js, everyauth Auth SecureSocial, deadbolt, play-authenticate
Node Security Project Advisories Play Security Vulnerabilities

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8

{
"name": "Hello World App",
"version": "0.0.3",
"dependencies": {
"express": "4.8.0",
"underscore": "1.6.0"
},
"scripts": {
"test": "node tests/run.js",
"lint": "jshint src"
}
}
Node.js uses NPM to manage dependencies and
basic build commands

Many options available for more complicated
builds: grunt.js, gulp.js, or broccoli

Thousands of plugins for all common build tasks

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10

Play uses SBT as the build system. SBT is an
interactive build system.

object AppBuild extends Build {
lazy val root = Project(id = "root", base = file(".")).settings(
name := "test-play-app",
version := version,
libraryDependencies += Seq(
"org.scala-tools" % "scala-stm_2.11.1" % "0.3",
"org.apache.derby" % "derby" % "10.4.1.3"
)
)
def version = Option(System.getProperty("version")).getOrElse("0.0.3")
}
In SBT, build definitions are written in Scala!
… But the learning curve is very steep.

Dependencies are managed using Ivy:
familiar, but slow.

Play uses sbt-web to build static content: few
plugins; depends on Rhino (slow) or node.js (!).

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7

Many node-friendly hosting options: Heroku,
Joyent, Azure, OpenShift, Nodejitsu

Monitoring: New Relic, Nodetime,
AppDynamics, node-monitor

if (cluster.isMaster) {
for (var i = 0; i < numCPUs; i++) {
cluster.fork(); // Fork workers
}
cluster.on('exit', function(worker, code, signal) {
console.log('worker ' + worker.process.pid + ' died');
});
} else {
http.createServer(function(req, res) {
// ...
}).listen(8000);
}
Use cluster to run one node instance per CPU

Use forever, monit, or Domain to handle crashes.

{
"dbConfig": {
"host": "localhost",
"port": 5984,
"dbName": "customers"
}
}
config/default.json
var config = require('config');
var host = config.get('dbConfig.host');
server.js
Configuration: node-config or nconf

Use nginx, apache, or ATS to load balance,
serve static content, terminate SSL
Client
Data Center
Reverse proxy
(e.g. nginx) DB
Static server
(e.g. nginx)
Node
instNaondcee
instNaondcee
instNaondcee
instNaondcee
instance
Node
instNaondcee
instNaondcee
instNaondcee
instance
Node
instNaondcee
instNaondcee
instNaondcee
instance

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7
8

A few Play-friendly hosting options: Heroku,
playframework-cloud, CloudBees

Monitoring: New Relic, metrics-play

Use the SBT Native Packager to package the
app as tgz, deb, RPM, etc.

dbConfig = {
host: "localhost",
port: 5984,
dbName: "customers"
}
conf/application.conf
val host = Play.current.configuration.getString("dbConfig.host")
app/controllers/Application.scala
Configuration: Play comes with Typesafe Config

Use nginx, apache, or ATS to load balance,
serve static content, terminate SSL
Client
Data Center
Reverse proxy
(e.g. nginx)
Play app
DB
Static server
(e.g. nginx)
Play app
Play app

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7
8 7

Node.js: use IntelliJ or node-inspector to debug

Use DTrace, TraceGL, node-stackviz, and node-profiler
to debug perf issues

var winston = require("winston");
winston.info("CHILL WINSTON! ... I put it in the logs.");
Use winston, log4js, or bunyan for logging

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7
8 7
10

Play runs on the JVM, so you can use your
favorite IDE to debug: IntelliJ, Eclipse, NetBeans

In dev, Play shows errors right in the browser

Use YourKit, VisualVM, BTrace, and jmap to
debug perf issues

Use logback, slf4j, or log4j for logging

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7
8 7
10 10

Part 1: scaling for lots of traffic

TechEmpower benchmarks.
Warning: microbenchmarks are not a substitute for real world perf testing!

Single query
(Note: JDBC is blocking!)

Multiple queries
(Note: JDBC is blocking!)

Internet Load
Balancer
Frontend
Server
Frontend
Server
Frontend
Server
Backend
Server
Backend
Server
Backend
Server
Backend
Server
Backend
Server
Data
Store
Data
Store
Data
Store
Data
Store
LinkedIn experience #1: Play and Node.js are very
fast in a service oriented architecture with NIO.

// BAD: write files synchronously
fs.writeFileSync('message.txt', 'Hello Node');
console.log("It's saved, but you just blocked ALL requests!");
// Good: write files asynchronously
fs.writeFile('message.txt', 'Hello Node', function (err) {
console.log("It's saved and the server remains responsive!");
});
LinkedIn experience #2: Play is ok with blocking I/O
& CPU/memory bound use cases. Node.js is not.

Part 2: scaling for large teams and projects

Node.js: best for small projects, short
projects, small teams.

Play: best for longer projects. Slower ramp up, but
scales well with team and project size.

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7
8 7
10
10
10
10

Functional programming: first class functions,
closures, underscore.js

...Which means you can share developers,
practices, and even code: rendr, derby, meteor

Node core is (mostly) stable and mature. Bugs,
regressions, and backwards incompatibility are rare.

'' == '0' // false
0 == '' // true
0 == '0' // true
false == 'false' // false
false == '0' // true
false == undefined // false
false == null // false
null == undefined // true
' trn ' == 0 // true
Bad Parts

// Default scope is global
var foo = "I'm a global variable!"
// Setting undeclared variables puts them in global scope too
bar = "I'm also a global variable!";
if (foo) {
// Look ma, no block scope!
var baz = "Believe it or not, I'll also be a global variable!"
}
Awful Parts

doSomethingAsync(req1, function(err1, res1) {
// ...
});
});
});
});
Callback hell: control flow, error handling,
and composition are all difficult

Many NPM packages are NOT stable or mature.
Incompatibility + bugs + dynamic typing = pain.

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7
8 7
10
10
10
10
3

def sort(a: List[Int]): List[Int] = {
if (a.length < 2) a
else {
val pivot = a(a.length / 2)
sort(a.filter(_ < pivot)) :::
a.filter(_ == pivot) :::
sort(a.filter(_ > pivot))
Functional programming
}
}

val NameTagPattern = "Hello, my name is (.+) (.+)".r
val ListPattern = "Last: (.+). First: (.+).".r
// Case classes automatically generate immutable fields, equals, hashCode, constructor
case class Name(first: String, last: String)
// Use Option to avoid returning null if there is no name found
def extractName(str: String): Option[Name] = {
Option(str).collectFirst {
// Pattern matching on regular expressions
case NameTagPattern(fname, lname) => Name(fname, lname)
case ListPattern(lname, fname) => Name(fname, lname)
}
}
Very expressive: case classes, pattern
matching, lazy, option, implicits

Runs on the JVM; interop with Java.

Concurrency & streaming tools: Futures, Akka,
STM, threads, Scala.rx, Async/Await, Iteratees

def index = Action {
// Make 3 sequential, async calls
for {
foo <- WS.url(url1).get()
bar <- WS.url(url2).get()
baz <- WS.url(url3).get()
} yield {
// Build a result using foo, bar, and baz
}
}
No callback hell!

Fortunately, Play/SBT support incremental
compilation and hot reload!

Play is stable, but not mature: backwards
incompatible API changes every release.

Even worse: Scala is not binary compatible
between releases!

Backwards incompatibility = pain.
… Static typing makes it a little more manageable.

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7
8 7
10
10
10
10
3 8

544 Contributors 351
2,376 Watchers 576
31,332 Stars 5,077
6,970 Forks 1,872
3,066 PR’s 2,201
Github activity as of 08/10/14

StackOverflow 10,698
53,555 Questions
Google Group
14,199 Members 11,577
Google Group
~400 Posts/Month ~1,100
StackOverflow, mailing list activity as of 08/12/14

4 langpop.com 18
10 TIOBE 39
5 CodeEval 12
7 IEEE Spectrum 17
1 RedMonk 13
12 Lang-Index 26
Language Popularity as of 08/12/14

88,000 packages in NPM ~80 Play Modules

88,000 packages in NPM 83,000 artifacts in Maven

Joyent offers commercial
support for Node.js
Typesafe offers commercial
support for Play

1,172 LinkedIn 49
3,605 Indeed 179
214 CareerBuilder 16
Open jobs as of 08/13/14

82,698 LinkedIn 9,037
2,267 Indeed 206
447 CareerBuilder 30
Candidates as of 08/13/14

Learn
Develop
Test
Secure
Build
Deploy
Debug
Scale
Maintain
Share
10 7
8 10
10 10
6 8
10 7
8 7
10
10
10
10
3 8
10 7

Both frameworks are great. Decide based on
strengths/weakness, not my arbitrary score!

Use node.js if:
1. You’re building small apps with small teams
2. You already have a bunch of JavaScript ninjas
3. Your app is mostly client-side JavaScript
4. Your app is mostly real-time
5. Your app is purely I/O bound

Don’t use node.js if:
1. You don’t write lots of automated tests
2. Your code base or team is going to get huge
3. You do lots of CPU or memory intensive tasks

Use Play if:
1. You’re already using the JVM
2. You like type safety and functional programming
3. Your code base or team is going to get big
4. You want a full stack framework
5. You need flexibility: non-blocking I/O, blocking I/O,
CPU intensive tasks, memory intensive tasks

Don’t use Play if:
1. You don’t have time to master Play, Scala, and SBT
2. You hate functional programming or static typing

Node.js vs Play Framework

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Node.js vs Play Framework

Semelhante a Node.js vs Play Framework (20)

Mais de Yevgeniy Brikman

Mais de Yevgeniy Brikman (20)

Último

Último (20)

Node.js vs Play Framework