From concept to cloud a look at modern software development

From concept to cloud:
A look at modern software
development
From concept to cloud:
Chris Richardson

A look Author original CloudFoundry.com
atthe of POJOs in Action
Founder of
modern software
development
crichardson@vmware.com
@crichardson
plainoldobjects.com
Chris Richardson
Author of POJOs in Action,
Founder of the original CloudFoundry.com
crichardson@vmware.com, @crichardson
plainoldobjects.com

About Chris

http://www.theregister.co.uk/2009/08/19/springsource_cloud_foundry/

vmc push About-Chris

Developer Advocate for

Signup at http://cloudfoundry.com

Promo code: sgce2012

Dreams of my childhood

Published in 1968

The vision
HAL 9000

.... is an artiﬁcial intelligence

became operational on

12 January 1992.....

So how are we doing?

The reality

Floor cleaning
robot

The reality

http://en.wikipedia.org/wiki/IBM_Watson
cluster of ninety IBM Power 750 servers
with a total of 2880 POWER7 processor
cores and 16 Terabytes of RAM.

We still have a long way
to go before we can
build HAL

But despite that....

Today, a small team of
people can easily build
an application that’s
used by millions of
people world-wide
http://highscalability.com/blog/2012/5/7/startups-are-creating-a-new-
system-of-the-world-for-it.html

Cloud Computing

http://en.wikipedia.org/wiki/Cloud_computing

Many of the
fundamentals of
computing were
invented before many of
us were born

1948 - First computer
2010
30 tons
2000
167 m2
1990 150 KW
1980
40 divs/second
1970

1960

1950 http://en.wikipedia.org/wiki/ENIAC

1940

1956 - Hard drive
3.7 Mbit

Weighed over a ton

Designed to ﬁt
through a door

http://boingboing.net/2010/06/24/ibm-hard-disk-drive.html

1971 - microprocessor
4 bit

108-740 kHz

2,300 transistors

http://en.wikipedia.org/wiki/Microprocessor

The power of Moore’s law

http://www.gotw.ca/publications/concurrency-ddj.htm

In my career
1982
RM 380Z
4 Mhz 8-bit Z80
32K RAM
100K ﬂoppy

2012
MacBookPro
2.5 Ghz Quad core 64 bit Intel i7
256K/core + 8M cache,16G RAM
512G SSD drive

Machrone’s law

“...the price of the
computer you want to buy
will always be $5000*...”

* Today it’s $3000

Wirth’s law

“Software is getting slower more
rapidly than hardware becomes
faster.”

1958 - Lisp
2010

(defun factorial (n) garbage collection
2000
(if (<= n 1) dynamic typing
1990 1 self-hosting compiler
1980 (* n (factorial (- n 1))))) tree data structures
1970

1960

1950 http://en.wikipedia.org/wiki/
Lisp_(programming_language)
1940

1960 - Algol 60
procedure Absmax(a) Size:(n, m) Result:(y) Subscripts:(i, k);
2010 value n, m; Many
array a; integer n, m, i, k; real y;
2000 begin integer p, q; languages
y := 0; i := k := 1;
for p:=1 step 1 until n do
including Java
1990
for q:=1 step 1 until m do are derived
if abs(a[p, q]) > y then
1980
begin y := abs(a[p, q]); from Algol
i := p; k := q
1970 end
end Absmax
1960

http://en.wikipedia.org/wiki/Algol_60
1950

1940

1967 - Simula
2010

2000 class-based object-
1990 oriented
programming
1980

1970

1960

http://en.wikipedia.org/wiki/Simula
1950

1940

So what have programming
language designers been
doing since then?

1995 - Java
Not innovative BUT
2010

2000

1990
Brought garbage collection, object-
oriented programming, exception
1980
handling, safety ... to mainstream
1970
developers
1960

1950
Gosling “Java is a blue collar
google “Gosling the feel of Java”
language”
1940

1980s - Cool IDEs for Lisp
and Smalltalk
2010
Editor
2000

Class
1990
List
1980
Repl
1970

1960 Class
hierarchy
1950
Debugger
1940

1990s
2010
• CVS - Lockless version management
2000
• DVCS - distributed version control
1990 • Refactoring
1980 • Agile/XP starts to become popular
1970
• Mosaic web browser
1960
• Web crawlers
1950

1940 http://www2.jpl.nasa.gov/sl9/

2000s - online developer
community
• Explosion of open-source
2010

• Binary artifact repositories - 41K maven.org
2000

1990

1980 • Github.com social coding - 1M projects!
1970

1960

1950

1940

2000s - DevOps, NoOps,
Continuous Deployment, etc
2010
• Developers responsible for testing,
2000
operations, ...
1990

• Continuous deployment: update production
1980
many times a day
• Chaos monkeys - constantly verify that the
1970

1960
system can tolerate failure
1950
http://highscalability.com/blog/2012/5/7/startups-are-creating-a-new-system-of-the-world-for-it.html

1940

William Gibson

“The future is already here –
it's just not evenly distributed.”
Ideas take a long time to
diffuse through the software
community

Polyglot applications
NoSQL databases
Cloud Computing

Until ~2004 Java was
the one language to
rule them all

Some developers
became frustrated with
the perceived
complexity of Java

Ruby on Rails became popular

• Web application framework for Ruby
• Signiﬁcantly more productive
• Simplicity of Convention over Conﬁguration
• Motivated the Java community to improve:
• e.g. Spring became even easier to use
But...

…Highlighted problems with Java

• Tedious collection processing
• Painful object construction code
• Tedious XML processing
• Types: verboseness and complexity of
generics
• Limited support for DSLs
Reopened the debate about programming
languages

Alternative languages

• Ruby
• Groovy
• Clojure
• Scala
• JavaScript/NodeJS

Closures
scala> val numbers = Array(1,2,3,4,5)
numbers: Array[Int] = Array(1, 2, 3, 4, 5)

scala> val oddNumbers = numbers.ﬁlter((x => x % 2 == 1))
oddNumbers: Array[Int] = Array(1, 3, 5)

scala> val doubled = numbers.map(_ * 2)
doubled: Array[Int] = Array(2, 4, 6, 8, 10)

XML processing

scala> val xml = <foo><bar>baz</bar></foo>
xml: scala.xml.Elem = <foo><bar>baz</bar></foo>

scala> (xml "bar").text
res9: String = “baz”

Meta-programming
Computer programs that modify
themselves

Grails persistence methods
class Customer {
String name
}
Customer c = new Customer("John Doe")

if (!c.save())
fail "validation failed: ${c.errors}"

Customer c2 = Customer.get(c.id)

def customers = Customer.ﬁndAllByName(“Fred”)

Sinatra DSL example
require 'sinatra'

get '/hi' do
"Hello World!"
end

A Ruby-based Domain Speciﬁc Language for web
programming

So what should we do
with these languages?

Traditional web application architecture
WAR

StoreFrontUI

Billing
Service

Customer MySQL
Browser Apache Management Database

Inventory
Service

Simple to Shipping
Service

develop Tomcat
test
deploy
scale

But there are problems
• Inadequate for modern, real-time web applications
(need NodeJS)
• Obstacle to frequent deployments
• Slows down IDE and dev/test cycle
• Obstacle to scaling development
• Requires long term commitment to technology
stack

Modular, polyglot application architecture
Desktop Browser Native Mobile application HTML5 mobile application

StoreUI StoreUI StoreUI

Asynchronous, NodeJS
Javascript
scalable StoreUI
communication

RabbitMQ

Spring/
Rails Inventory
Scala web Shipping Service
Service
application

Customer Inventory Order
Billing Service
Management Database Database
Standalone
“headless”
Customer Spring/Java
Database applications

Real world examples
http://techblog.netﬂix.com/

Between 100-150 services are accessed to build a
page.
http://highscalability.com/amazon-architecture

http://www.addsimplicity.com/downloads/
eBaySDForum2006-11-29.pdf

http://queue.acm.org/detail.cfm?id=1394128

There are drawbacks
• Complexity: Architectural, development,
deployment
• Deciding when to use it
• In the beginning: you don’t need it and it will
slow you down
• When you do need it: refactoring existing code
is painful

But there are many beneﬁts
• Scales development: focused two pizza devops teams
• Deploy services independently
• Scale services independently
• Improves fault isolation
• Enforces well deﬁned interfaces between components
• Eliminates long-term commitment to a single technology stack

Modular, polyglot applications

If services are small...

• Regularly rewrite using a better technology stack
• Pick the best developers rather than best <pick a
language> developers polyglot culture

• Adapt system to changing requirements and
better technology without a total rewrite

Moreover: you are not the same you ...
• 50 to 70 billion of your cells die each day
Can we build software
• Cell lifetimes:
systems with these
• hours - some white blood cells
characteristics?
• days - stomach lining cells
• years - bone cells Too much technical debt
• lifetime - brain cells component death?
• Yet you (the system) remains intact

http://dreamsongs.com/Files/
DesignBeyondHumanAbilitiesSimp.pdf

http://dreamsongs.com/Files/WhitherSoftware.pdf

Relational databases
have been the place to
store your data

Limitations of relational
databases
• Scaling
• Despite Moore’s law vertical scaling is limited/expensive
• Horizontal scaling is limited
• Distribution
• Updating schema
• O/R impedance mismatch
• Handling semi-structured data

Solution: Use NoSQL
Beneﬁts Drawbacks

• Higher performance • Limited transactions
• Higher scalability • Relaxed consistency
• Richer data-model • Unconstrained data
• Schema-less

NoSQL databases
Data Model Examples

Key-value Redis,Voldemort

Document MongoDB, CouchDb

Extensible columns/Column- Cassandra, Hbase, SimpleDB,
oriented DynamoDB
Graph Neo4j

http://nosql-database.org/ lists 122+ NoSQL databases

Redis

• Advanced key-value store K1 V1

• Very fast K2 V2

• Optional persistence
K3 V2

MongoDB: fast, scalable, document oriented
Server
Database: Food To Go
Collection: Restaurants
{
"_id" : ObjectId("4bddc2f49d1505567c6220a0")
"name": "Ajanta",
"serviceArea": ["94619", "99999"], BSON = binary
"openingHours": [
{
JSON
"dayOfWeek": 1,
"open": 1130,
"close": 1430 },
Sequence of
{ bytes on disk
"dayOfWeek": 2,
"open": 1130,
è fast i/o
"close": 1430
}, …
]
}

Cassandra: very scalable
Application Application

Cassandra cluster Cassandra cluster

Node 1 Node 1

Node 4 Node 2 Node 4 Node 2

Node 3 Node 3

Datacenter 1 Datacenter 2

The future is polyglot persistence

e.g. Netflix
• RDBMS
• SimpleDB
• Cassandra
• Hadoop/Hbase

IEEE Software Sept/October 2010 - Debasish Ghosh / Twitter @debasishg

Let’s imagine that you
want to deploy an app...
• Do you know how much hardware to buy?
• Can you afford it?
• How long does it take to approve, buy and install?
• Who is going to set it up?
• What happens if the trafﬁc increases 10x?
• Can we afford a test lab?

Cloud computing
empowers us to deal
with these challenges...

Cloud computing deﬁned

IT delivered as a service
Over the internet
Self-service
Pay per use

The three layers of cloud
computing

SaaS

PaaS

IaaS

Wednesday October 18,
2006....

AWS evangelist

.... spoke at the Oakland JUG

Sign up and deploy your
application a few minutes later

• Login using your
existing Amazon
account
• Select the web

Beneﬁts of IaaS
• Agility
• Pay per use
• Elasticity
• Focus on deploying your application
But you need to configure and maintain the
operating systems, the app servers and the
databases etc.

Need to move up the stack
SaaS

PaaS

IaaS

PaaS
=
Application deployment
and management
+
Service provisioning

The Open
Platform as a Service

Deploy and scale applications in seconds,
without locking yourself into a single cloud

Flex ible,
pen,
le, O lable
Simp Sca

Easy polyglot application deployment and
service provisioning
OSS community

vFabric
Postgres
Private

Ap

Clouds

p

Data Services
lica
'o
n
S

vFabric
Public
erv

RabbitMQTM
ice

Msg Services
Clouds

In
ter
fac

Micro
e

Other Services
Clouds
Additional partners services …

CloudFoundry.COM - Multi-tenant
PaaS operated by VMware
CloudFoundry.COM (beta)
Services
Runtimes & Frameworks

vCenter / vSphere

Infrastructure

Micro Cloud Foundry – Industry ﬁrst TM

downloadable PaaS
Micro Cloud Foundry
Services
Runtimes & Frameworks

Your Laptop/PC

Single VM instance of
Cloud Foundry
that runs on a developer’s
MAC or PC

CloudFoundry.ORG - Community open-source project
Apache2 license
CloudFoundry.ORG

Your Infrastructure

Download Setup Deploy Behind
Code Environment BOSH Firewall

Sinatra + Redis
require 'sinatra'
require 'redis' Connect to Redis

conﬁgure do
$r = Redis.new(:host => '127.0.0.1', :port => '6379') if !$r
end

get '/' do
"Hello World! " + $r.incr("hitcounter").to_s
end
Increment hit
counter

http://sgce2012.cloudfoundry.com/

Consuming 3rd party
cloud services

Thousands of 3rd party
services
http://www.programmableweb.com/apis/directory

Number of APIs increasing exponentially

Cloud service trends

• Predominantly REST
• Predominantly JSON
• > billion API calls/day: Twitter, Google, Facebook,
Netﬂix, Accuweather, ...
• Increasing number of API-only companies
http://www.slideshare.net/jmusser/j-musser-apishotnotgluecon2012

Diverse

Paypal SendGrid Face.com Google

Cybersource Twilio GeoNames Aviary.com Yahoo

AlchemyAPI Tropo WorldAddresses Amazon

Mashery

Amazon Simple Storage Service (S3)
• Bucket
• has a globally unique name, e.g. cloudtools.org.photos
• contains objects
• Objects - 1 byte – 5 Tbytes
• Pay per use: storage + bandwidth
• Accessed via RESTful API
• PUT – create bucket or object
• GET – retrieve object
1T objects
• DELETE – delete an object
June 2012

face.com - face detection and recognition

http://api.face.com/faces
/detect.json
?api_key=
&api_secret=
&urls=<url>
&detector=Aggressive
&attributes=all

Twilio - Telephony and SMS
as a service
• REST API
• Allocate phone numbers
• Make and receive phone calls
• Send and receive SMS messages
• Pay per use:
• Phone number – per month
• Phone calls - per-minute
• SMS – per SMS sent or received
• Example: Salesforce – SMS-based voting for 19,000
conference attendees

Expose your APIs
and
build an ecosystem

Going beyond today’s pop
culture
But love is blind and lovers cannot see
The pretty follies that themselves commit;
For if they could, Cupid himself would blush
To see me thus transformed to a boy.

William Shakespeare, The Mechant of Venice

Gartner hype curve

http://www.gartner.com/technology/research/methodologies/hype-cycle.jsp#

Clock speeds have plateaued

http://www.gotw.ca/publications/concurrency-ddj.htm

Multi core is the future

• Dual core A5 for iPhone 4S
• Quad core Intel i7 for laptops
• 10 core Intel Xeon Processor
• 3072 core NVidia Tesla Kepler

Sometimes we can use request-
level parallelism and let the
container worry about it
BUT not always...

But concurrent
programming is difﬁcult

The problem
=
Mutable state that’s
shared between multiple
threads (using locks)

Not thread safe
public class InventoryTracker {

private int inStock;
private int sold = 0;

public InventoryTracker(int initialInventory) {
this.inStock = initialInventory;
}

public int getInStock() { return inStock; }

public int sell(int units) {
inStock -= units;
sold += units;
return inStock;
}
}

Thread safe
public class InventoryTracker {

private int inStock;
private int sold = 0;

public InventoryTracker(int initialInventory) {
this.inStock = initialInventory;
}

public synchronized int getInStock() { return inStock; }

public synchronized int sell(int units) {
inStock -= units;
sold += units;
return inStock;
}
}

NodeJS - Event driven
• Single threaded runtime no concurrency

• Runs an event loop that waits for i/o events
• i/o event callback function

• Updates state
• Publishes events triggers more callbacks)

• Initiates i/o, registering callbacks
• Returns shared between
multiple threads

NodeJS example
var http = require('http');
var fs = require('fs'); HTTP request handler
var url = require('url');

var inStock = 100;
var sold = 0;

http.createServer(function (req, res) {

var quantity = parseInt(url.parse(req.url, true).query.quantity);

inStock -= quantity;

sold += quantity;

var message = "inStock=" + inStock + ", sold=" + sold;

res.end(message);
}).listen(1337, "127.0.0.1");

console.log('Server running at http://127.0.0.1:1337/');

http://127.0.0.1:1337?quantity=1

Scala Actors
• Actor = object that asynchronously exchanges
immutable messages with other actors
• Actor processes one message at a time
• Sends messages
• Updates its private mutable state
• Creates new actors
• No shared state Mutable state that’s
shared between
multiple threads

Scala example
case class Sell(quantity: Int) Message types
case class Sale(inStock : Int, sold : Int)

class InventoryTracker(initialInventory : Int) extends Actor {
var inStock = initialInventory
var sold = 0

def receive = {
case Sell(quantity) => Update state
inStock -= quantity
sold += quantity
sender ! Sale(inStock, sold)

}
}
Send reply
case class Order(quantity: Int)

class StoreFront(inventoryTracker: ActorRef) extends Actor {
var numberOfOrders = 0

def receive = {
case Order(quantity) => Send message
numberOfOrders += 1
inventoryTracker ! Sell(quantity)
case Sale(inStock, sold) =>
println("numberOfOrders=" + numberOfOrders + ",inStock=" +
inStock + ", sold=" + sold) Handle reply
}
}

Pure functional
programming
• Eliminates mutable state
BUT
• I/O and state management require Monads
• Monads are extremely difﬁcult to learn
shared between
multiple threads

Clojure - a modern LISP
• Practical functional programming language
• Runs on the JVM
• Core data structures are immutable
BUT
• Ref = object that holds a mutable reference to a value
• Refs can only be updated within a transaction
• Software Transaction Memory
• Atomic, Consistent, Isolated
• No explicit locks shared between multiple
threads

Clojure STM example
Create refs
(defrecord InventoryTracker [in-stock sold])

(defn make-inventory-tracker [initial-inventory]

(InventoryTracker. (ref initial-inventory) (ref 0)))
Update refs
(defn sale [tracker quantity]

(dosync

(let [new-in-stock (alter (:in-stock tracker) - quantity)

new-sold (alter (:sold tracker) + quantity)

]

[new-in-stock new-sold]

)))

dosync
(def it (make-inventory-tracker 100)) =
a transaction
(sale it 25)

Final thoughts
Software development is an old
... yet immature profession
Multi-core programming is a challenge
BUT
The cloud enables anyone with a good idea to
create an application that touches the lives of
millions of people

Thank you!
Chris Richardson

Author of POJOs in Action
Founder of the original CloudFoundry.com

crichardson@vmware.com
@crichardson
plainoldobjects.com

Signup @ cloudfoundry.com Promo code: sgce2012

From concept to cloud a look at modern software development

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie From concept to cloud a look at modern software development

Ähnlich wie From concept to cloud a look at modern software development (20)

Mehr von Software Guru

Mehr von Software Guru (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

From concept to cloud a look at modern software development