Making the transition from the traditional LAMP stack to MEAN is a daunting task. Changing your mindset to fit the asynchronous nature of Node.js is only part of the battle. The real challenge lies in understanding why you need to go MEAN in order to accomplish your goals. Any switch requires understanding the strengths and weaknesses of the MEAN stack and how they apply to your problem. PencilBlue compiled our lessons learned to provide developers and systems engineers a framework to easily evaluate the MEAN stack’s fit for their business. This presentation covers what we did right, what we wish we would have known, and the many pitfalls we encountered along the way to a successful deployment. Attendees will easily consume the material as we break it down logically into three categories: planning, development and deployment.

1. I Know it was MEAN
but I Cut the Cord to LAMP Anyway

2. The Next Milestone in Web Development
info@pencilblue.org
@GetPencilBlue

3. Planning Development Deployment
Actually do it Managing the flexibility What are my options?
Do I need a framework? The Basics The Upgrade
Dealing with SEO Simplifying Client Code Server Options
Finding the Right Talent Promise vs. Callback Choosing a Cloud

4. Follow along at:
pencilblue.org/presentation

5. MongoDB

6. Planning - Failing to Plan
Pros Cons
Easy Install Not good for inter object relationships
Flexible
Quick Development

7. Development - Prototyping vs. Production

8. Development - Flexible Base Service
+ save
+ delete
+ load
Widget Service
+ save
+ delete
+ load
Widget Service
+ save
Sprocket Service
+ save
{
object_type: “widget”,
name: “”,
description: “”
}:

9. Development - Too Flexible?
Document with Strings
{
object_type: “event”,
type: “startup”,
location: {
lat: “35.7806”,
lon: “78.6389”
}
}
Document with Floats
{
object_type: “event”,
type: “startup”,
location: {
lat: 35.7806,
lon: 78.6389
}
}
● Valid JSON
● Pases non-strict validation (JS)
● Geospatial index fails on insert

10. Development - Schema Documentation

11. Development - Common Data Fields
{
“first_name”: “Charlie”,
“last_name”: “Daniels”,
...
“doc_type”: “user”,
“doc_version”: 1,
“created”: “2014-09-11 15:01:07.602Z”,
“last_modified”: “2014-09-11 15:01:07.602Z”,
“created_by”: "5411b9334572668410000fd0”,
“last_modified_by”: "5411b9334572668410000fd0”
}

12. Development - Geospatial Indexing
The $geoWithin operator does not return sorted results. As a result MongoDB
can return $geoWithin queries more quickly than geospatial $near or
$nearSphere queries, which sort results.
db.places.find(
{
loc : {
$near : [50,50] ,
$maxDistance : 5
}
}
);
db.places.find(
{
"loc": {
"$geoWithin": {
"$center": [[50, 50, 5]
}
}
}
);
==

13. Deployment - Expense at Scale
Deployment Cost Managed
AWS m1.large $0.20/hr NO
Mongo HQ $18/GB* YES
Mongo Lab $15/GB* YES
Linode Medium $20/mo NO
* Other base fees may apply

14. Deployment - MMS & Getting to Scale

15. Routing & Frameworks

16. Planning - Do I need a framework?
● IS IT OPEN SOURCE?
● How often will I need to upgrade?
● If the project goes stagnant does that affect me?
● If the project gets bought by a company I don’t like does that affect me?
● What kind of custom functionality do I need to inject?
● Will packages be sufficient or will I need to fork so I can experiment?
● Do I want to maintain something custom?
● Can I do as well as or better than what is already out there?

17. Planning - Rube Goldberg of Software

18. Planning - The Forum Conundrum

19. Development - The Basic Example
var express = require('express')
var app = express()
app.get('/', function (req, res) {
res.send('Hello World!')
})
var server = app.listen(3000, function () {
var host = server.address().address
var port = server.address().port
console.log('Example app listening at http://%s:%s', host, port)
})

20. Deployment - Upgrading
What happens when I try to upgrade?
Chance of
Conflict
Time

21. Angular

22. Planning - Google did it!

23. Planning - Weighing In

24. Planning - Documentation
Pros Cons
Large Documentation Site API Documentation assumes
understanding of Angular
Support Groups Error handling can be cryptic
Guided Tutorials & Example Projects

25. Planning - Crawlers and Javascript
Pros Cons
Server Rendered Landing
Pages
SEO becomes easier because it
is the traditional model.
Even mediocre crawlers can
navigate your site
Mix and match of SPA and
traditional model
Tracking which pages need to be
rendered server-side
Single Page App Consistent SEO implementation
Metadata data changes based on
page context
Google is only search engine
boasting javascript execution.

26. Development - A Simple Example
<ol>
<li ng-repeat="user in users"
ng-bind="user"></li>
</ol>
//service code
angular.module('myservices', [])
.service('simpleService', function(){
this.getUsers = function() { return ['John', 'James', 'Jake']; }
});
//controller code
angular.module('myapp', ['myservices'])
.controller('SimpleController', function($scope, simpleService) {
$scope.users = simpleService.getUsers();
});

27. Development - A Growing Stack
Angular Controller
Angular Service
API Controller
Service Layer and Business Logic
Data Access
Client
Server

28. Separation of Concern => Testability
describe("Unit Testing Examples", function() {
beforeEach(angular.mock.module('App'));
it('should have a LoginCtrl controller', function() {
expect(App.LoginCtrl).toBeDefined();
});
it('should have a working LoginService service', inject(['LoginService',
function(LoginService) {
expect(LoginService.isValidEmail).not.to.equal(null);
}])
);
});

29. Deployment - Serving a Single Page App?
Considerations:
● How much data do I need to persist?
● Is my application solely a SPA?
Possible Options:
● Apache / PHP
● Python
● Rails
● Node.js

30. Node.js

31. Planning - Resource Management
Now that I use the same language across the entire stack hiring just got simpler.

32. Planning - Resource Management

33. Planning - Adoption
Big names are jumping on board:
● Linkedin
● Walmart Labs
● PencilBlue
http://nodejs.org/industry/

34. Development - Promise vs. Callback
//Promise example
function fs_readFile (file, encoding) {
var deferred = Q.defer()
fs.readFile(file, encoding, function (err, data) {
if (err) {
deferred.reject(err) // rejects the promise with `er` as the reason
}
else {
deferred.resolve(data) // fulfills the promise with `data` as the value
}
})
return deferred.promise // the promise is returned
}
fs_readFile('myfile.txt').then(console.log, console.error)
Courtesy of StrongLoop

35. Development - Promise vs. Callback
//Callback example
function fs_readFile (file, encoding, cb) {
fs.readFile(file, encoding, cb);
}
fs_readFile('myfile.txt', function (err, data) {
if (err) {
console.error(err) // outputs error
}
else {
console.log(data) // output result
}
});
Courtesy of StrongLoop

36. Development - Node Inspector

37. Development - Clustering
if (cluster.isMaster)
System.onMasterRunning();
else
onChildRunning();
System.onMasterRunning = function() {
//spawn workers
var workerCnt = os.cpus().length;
for (var i = 0; i < workerCnt; i++) {
cluster.fork();
}
cluster.on('disconnect', System.onWorkerDisconntect);
pb.log.info('System[%s]: %d workers spawned. Listening for disconnects.', System.getWorkerId(), workerCnt);
};
Core 1 Core 2 Core 3 Core 4 Core 5 Core 6 Core 7
M
W W W W W W W

38. Development - Error Handling
var http = require(‘http’);
var domain = require(‘domain’);
http.createServer(function(req, res){
var d = domain.create();
d.add(req);
d.add(res);
d.on(‘error’, handleError);
d.run(function() {
handleRequest(req, res);
});
}).listen(8080);

39. Deployment - Shooting for the Cloud
Elastic Beanstalk OpenShift Nodejitsu Bluemix
Linode Heroku

40. Deployment - Starting Simple
L
B
M
W
M
W
W
W
Use SSL
Termination
Pay for the backup
service
Write a procedure for
creating these nodes

41. Pros Cons
Extremely Flexible
Rapid Development
Expensive at Scale
Fast “Good Enough” HTTP Server Upgrades cause code changes
A battle tank that can do anything Error messages are a bit obfuscated
Fast and efficient Hard to debug
To Recap...

42. The choice is yours but...