customers

 developer preferences

technology trends

chooses ...

how to make wise decisions?

making wiser decisions

Text

Client Side
Technologies of Choice

Server Side
Technologies of Choice

Quality Assurance

3rd party integrations

Web & Mobile Solutions

?

other
don't fit

Server Side
Technologies of Choice

Language / Frameworks

business logic, api

Data Storage /

Search Engine

Cloud Infrastructure

computing power, PaSS, IaSS, private clouds, orchestration, auto scaling, storage, cdn

Server Side
Technologies of Choice

Language / Frameworks

business logic, api

Data Storage /

Search Engine

Cloud Infrastructure

PaaS, IaaS, auto scaling, storage, cdn

• Scala / Elixir

• Clojure

• Rust

• Redis

• PostgreSQL FTS

• Mongo DB

Private Clouds on dedicated hardware

Community

github stars

•  14_864 - rust

•   8_899 - ruby

•   5_526 - scala

•   5_932 - elixir

•   4_961 - clojure   

•   2_446 - iron

•  29_115 - ror

•   7_276 - play

•   5_061 - phoenix

•   2_783 - compojure   

import scala.actors.Futures._

object binarytrees {
  def report(name: String, depth: Int, check: Int) =
    println(name + " of depth " + depth + "\t check: " + check)

  def main(args: Array[String]) = {
    val n = try{ args(0).toInt } catch { case _ => 1 }
    val minDepth = 4
    val maxDepth = n max (minDepth+2)
    val threads = 3  // More than 3 tends to overwhelm GC

    report("stretch tree", maxDepth+1, Tree(0,maxDepth+1).isum)
    val longLivedTree = Tree(0,maxDepth)
    var depth = minDepth
    while (depth <= maxDepth) {
      val iterations = 1 << (maxDepth - depth + minDepth)
      val limits = (0 to threads).map(_*iterations/threads).sliding(2).toList
      val check = limits.map(i => future(Go(i(0)+1,i(1),depth).calc))
      report(iterations*2 + "\t trees", depth, check.map(_()).sum)
      depth += 2
    }
    report("long lived tree", maxDepth, longLivedTree.isum)
  }
}

case class Sum(var sum: Int) {
  def +=(i: Int) = { sum+=i; this }
}

case class Go(i0: Int, i1: Int, depth: Int) {
  def calc = (Sum(0) /: (i0 to i1))((s,i) =>
    s += Tree(i,depth).isum + Tree(-i,depth).isum
  ).sum
}

final class Tree(i: Int, left: Tree, right: Tree) {
  def isum: Int = if (left eq null) i else i + left.isum - right.isum
}
object Tree {
  def apply(i: Int, depth: Int): Tree = {
    if (depth > 0) new Tree(i, Tree(i*2-1, depth-1), Tree(i*2, depth-1))
    else new Tree(i, null, null)
  }
}

extern crate typed_arena;

use std::thread;
use typed_arena::Arena;

struct Tree<'a> {
    l: Option<&'a Tree<'a>>,
    r: Option<&'a Tree<'a>>,
    i: i32
}

fn item_check(t: &Option<&Tree>) -> i32 {
    match *t {
        None => 0,
        Some(&Tree { ref l, ref r, i }) => i + item_check(l) - item_check(r)
    }
}

fn bottom_up_tree<'r>(arena: &'r Arena<Tree<'r>>, item: i32, depth: i32)
                  -> Option<&'r Tree<'r>> {
    if depth > 0 {
        let t: &Tree<'r> = arena.alloc(Tree {
            l: bottom_up_tree(arena, 2 * item - 1, depth - 1),
            r: bottom_up_tree(arena, 2 * item, depth - 1),
            i: item
        });
        Some(t)
    } else {
        None
    }
}

fn inner(depth: i32, iterations: i32) -> String {
    let mut chk = 0;
    for i in 1 .. iterations + 1 {
        let arena = Arena::new();
        let a = bottom_up_tree(&arena, i, depth);
        let b = bottom_up_tree(&arena, -i, depth);
        chk += item_check(&a) + item_check(&b);
    }
    format!("{}\t trees of depth {}\t check: {}",
            iterations * 2, depth, chk)
}

fn main() {
    let n = std::env::args_os().nth(1)
        .and_then(|s| s.into_string().ok())
        .and_then(|n| n.parse().ok())
        .unwrap_or(10);
    let min_depth = 4;
    let max_depth = if min_depth + 2 > n {min_depth + 2} else {n};

    {
        let arena = Arena::new();
        let depth = max_depth + 1;
        let tree = bottom_up_tree(&arena, 0, depth);

        println!("stretch tree of depth {}\t check: {}",
                 depth, item_check(&tree));
    }

    let long_lived_arena = Arena::new();
    let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth);

    let messages = (min_depth..max_depth + 1).filter(|&d| d % 2 == 0).map(|depth| {
        let iterations = 1 << ((max_depth - depth + min_depth) as u32);
        thread::spawn(move || inner(depth, iterations))
    }).collect::<Vec<_>>();

    for message in messages.into_iter() {
        println!("{}", message.join().unwrap());
    }

    println!("long lived tree of depth {}\t check: {}",
             max_depth, item_check(&long_lived_tree));
}

Ruby 3.0 is scheduled to 2020

(Summer Olympics in Tokyo)

• 3.0 x times faster then 2.0 and
• modern concurrency approach

class String
  BLANK_RE = /\A[[:space:]]*\z/

  def blank?
    BLANK_RE === self
  end
end

extern "C" fn fast_blank(buf: Buf) -> bool {
    buf.as_slice().chars().all(|c| c.is_whitespace())
}

class String
  BLANK_RE = /\A[[:space:]]*\z/

  def blank?
    BLANK_RE === self
  end
end

extern "C" fn fast_blank(buf: Buf) -> bool {
    buf.as_slice().chars().all(|c| c.is_whitespace())
}

class String
  BLANK_RE = /\A[[:space:]]*\z/

  def blank?
    BLANK_RE === self
  end
end

fast_blank (C) 10 x faster then ruby

rust implementation > c implementation

extern "C" fn fast_blank(buf: Buf) -> bool {
    buf.as_slice().chars().all(|c| c.is_whitespace())
}

http://www.sitepoint.com/ruby-can-be-faster-with-a-bit-of-rust/

customers

 developer preferences

technology trends

chooses ...

Client Side
Technologies of Choice

Web Browser Apps

frameworks*

Mobile Apps

Desktop Apps

• Ionic ^2 (angular.js)

• Foundation For Apps (angular.js)

• Ember CLI Cordova

• ...

• .. framework or lib

• Photon (ui)

• ...

• .. framework or lib

• how

• ...

http://smashingboxes.com/ideas/choosing-a-front-end-framework-angular-ember-react

customers

 developer preferences

technology trends

chooses ...

Quality Assurance

Testing Tools

api / business logic / client side

Peer Review

Infrastructure

• Code Review
• Pull Request Workflow
• Pair Programming

• Virtual Development (conteiners)
• In Cloud Development

customers

 developer preferences

technology trends

chooses ...

3rd Integrations

customers

 developer preferences

technology trends

chooses ...

vendor lock-in

?

Internet of Things

Big Data / Rich Data

Machine Learning

Fully Fledged Frameworks

Server Less Applications Development

Server Less Applications Development

Fully Fledged Frameworks

Fully Fledged Frameworks

Internet of Things

SDK: embedded C, JS, Arduino Yun

?

Internet of Things

Big Data / Rich Data

Machine Learning

Fully Fledged Frameworks

Server Less Applications Development

customers

 developer preferences

technology trends

chooses ...

vendor lock-in