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?
Selleo web technologies of choice
By Michał Czyż
Selleo web technologies of choice
current status & (potential) future choices
- 1,478