Web Technologies

current state & what's coming

customers

 developer preferences

technology trends

chooses ...

how to make wise decisions?

making wiser decisions

Text

What we do?

What we do?

THIS ALREADY HAPPEN

Client Side
Technologies of Choice

Server Side
Technologies of
Choice

Quality Assurance

3rd party integrations

Web & Mobile Solutions

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

  • Citus Data

Private Clouds on dedicated hardware

vm JVM BEAM JVM, JS compiled
syntax JAVA (+) *Ruby *LISP *C++
concurency actor model actor model STM ownership model
framework Play Phoenix Compojure* / Reagent*  Iron
who use it EPFL
$2.3mln ERC
Typsafe Inc.
Jose Valim
Plataforma.
Community
Clojure Community Rust Community
$Mozilla
st stable rel. 2006 (v2.*) 2014 2009 2015
typing static dynamic* dynamic static

Community

github stars

  •  16_300 - rust
  •   9_521 - ruby
  •   6_700 - elixir
  •   6_002 - scala
  •   4_961 - clojure   
  •   2_788 - iron
  •  30_710 - ror  
  •   6_046 - phoenix
  •   7_775 - play
  •   2_870 - compojure   
3.24 156 3.70 142 / 5.5
4.29 121 1.61 76 / 2.1
5.75 354 1.70 56 / 1.8
11.52 686 8.21 45 / 1.4
14.07 607 2.14 61 / 2.0
18.93 1,013 2.90 44 / 1.1
48.92 937 0 47 / 1.2
57.98 243 0 170 / 4.4
exec (s) mem (kb) comp (s) loc / size (kb)
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

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

number issues 875 (943) 214 (-100) 480
Github Stars (since Oct '15) +4000 (+5000) +2000 +11000

customers

 developer preferences

technology trends

chooses ...

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

3rd Integrations

customers

 developer preferences

technology trends

chooses ...

vendor lock-in

What to choose

 

Language

JavaScript

Ruby
Rust

What to choose

 

Server Side Framework

Ruby
on
Rails

What to choose

 

Client Side Framework

Angular
Ember
React*

Coder Dojo

every Thursday at 4 PM

1 Maja 17 - Mikstura.IT

 

  • JavaScript & Ember.js
  • Ruby &Ruby on Rails

 

Angular 2

one time - 23rd April, 9 AM

1 Maja 17 - Selleo

 

  • Introduction to Angular 2

 

Than you!

Any Questions?

Made with Slides.com