Ruby is dyingWhat languages are cool now?

Michał Konarski

u2i.com

Seriously, is Ruby dying?

Ruby Go

https://blog.whoishiring.io/hacker-news-who-is-hiring-thread-part-1/

Who is hiring?

But let’s look from a different angle...

http://www.tiobe.com/

TIOBE Index

Well, not exactly.

But what languages are cool now?

Let’s look at six of them

Swift

Swift

● designed by Apple● released in 2014● created for iOS, macOS, tvOS● multi-paradigm● statically, strongly typed● compiled

namespacesgenerics

closures

tuplesoperator overloading

native collections

type inference

pattern matching

multiple return types

Read-Eval-Print-Loop (REPL)

Swift features

Nothing really outstanding.

So, what’s the story behind Swift?

“We absolutely loved Objective-C, but we had to ask ourselves a question -

what would it be like if we had Objective-C without the baggage of C?”

Tim Cook

It’s mainly because Objective-C is bad.

And they had nothing else.

@interface Foo : NSObject@property (readonly) int bar;- (instancetype)initWithBar:(int)bar;+ (instancetype)fooWithBar:(int)bar;@end

@implementation Foo- (instancetype)initWithBar:(int)bar { self = [super init]; if (self) { _bar = bar; }

return self;}

+ (instancetype)fooWithBar:(int)bar { return [[self alloc] initWithBar:bar];}@end

How bad is Objective-C?

http://www.antonzherdev.com/post/70064588471/top-13-worst-things-about-objective-c

Swift is easier to read

Objective-C

if (myDelegate != nil) {if ([myDelegate respondsToSelector:

@selector(scrollViewDidScroll:)]) {[myDelegate scrollViewDidScroll:myScrollView]

}}

Swift

myDelegate?.scrollViewDidScroll?(myScrollView)

Why also Swift is better?

● no need to have two separate files (code and headers)● it’s safer (runtime crash on null pointer)● it has automatic ARC (Automatic Reference Counting)● it’s faster● it requires less code● it has namespaces

It’s not only a language

XCode 8

https://developer.apple.com/xcode/

It’s not only a language

Swift Playgrounds

http://www.apple.com/swift/playgrounds/

● sponsored by Mozilla● announced in 2010● first release in 2012● stable release in 2015● statically, strongly typed● multi-paradigm● compiled

“The goal of the project is to design and implement a safe, concurrent, practical systems

language”Rust FAQ

There are not such languages?

Apparently not.

Current languages are wrong

● there is too little attention paid to safety

● they have poor concurrency support

● they offer limited control over resources

● they stick too much to paradigm

So let’s create a new high-low level language!

Rust is a high level language!

● generics ● traits● pattern matching● closures● type inference● automatic memory allocation and deallocation● guaranteed memory safety● threads without data races

Rust is a low level language!

● no garbage collector● manual memory management● zero-cost abstractions● minimal runtime● as fast as C/C++

Guaranteed memory safety? How?

Ownership

fn foo() {

let v1 = vec![1, 2, 3];let v2 = v1;println!("v1[0] is: {}", v1[0]);

}

error: use of moved value: `v

You can’t have two references to the same object!

Ownership

stack heap

[1, 2, 3]v1

v2

There are more such mechanisms.

Future of Rust

● currently two big projects: servo and rust● other smaller projects: redox, cgmath, Iron, rust-doom● it changes very quickly● it has a good opinion in the community● it will be hard to replace C/C++● It has a steep learning curve

Go

Go

● designed in Google in 2007● first release in 2009● stable release in 2016● statically, strongly typed● multi-paradigm, concurrent● compiled

Standard languages (Java, C++)

● are very strong: type-safe, effective, efficient● great in hands of experts ● used to build huge systems and companies

Standard languages (Java, C++)

● hard to use● compilers are slow● binaries are huge● desperately need language-aware tools● poorly adapt to clouds, multicore CPUs

Simpler languages (Python, Ruby, JS)

● easier to learn● dynamically typed (fewer keystrokes)● interpreted (no compiler to wait for)● good tools (interpreters make things easier)

Simpler languages (Python, Ruby, JS)

● slow● not type-safe● hard to maintain in a big project● very poor at scale● not very modern

What if we had a static language with dynamic-like syntax?

A niche for a language

● understandable● statically typed● productive and readable● fast to work in● scales well● doesn't require tools, but supports them well● good at networking and multiprocessing

Features of Go

● syntax typical for dynamic languages● type inference● fast compilation● garbage collector● memory safety features● built-in concurrency● object oriented without classes and inheritance● lack of generics● compiles to small statically linked binaries

Interfacestype Animal interface { Speak() string}

type Dog struct {}

func (d Dog) Speak() string {return "Woof!"

}

func SaySomething(a Animal) {fmt.Println(a.Speak())

}

func main() {dog := Dog{}SaySomething(dog)

}

Built-in concurrency!

Goroutines

func main() { go expensiveComputation(x, y, z) anotherExpensiveComputation(a, b, c)

}

Channels

func main() { ch := make(chan int)go expensiveComputation(x, y, z, ch) v2 := anotherExpensiveComputation(a, b, c) v1 := <- chfmt.Println(v1, v2)

}

Future of Go

● it’s popularity constantly raises● it’s backed by Google● it’s used by Docker, Netflix, Dropbox, CloudFare,

SoundCloud, BBC, New York Times, Uber and others● it’s seen as a good balance between Java-like languages

and Python-like● it easy to learn and powerful● it runs well in cloud environments● might be a good choice for microservices approach

● created by José Valim● released in 2012● functional● dynamically, strongly typed● compiled to Erlang VM byte code

Erlang? Processes!

Elixir = Erlang with Ruby syntax

Elixir features

● massively concurrent● scalable● fault-tolerant● great performance● functional, but practical● nice Ruby-like syntax● metaprogramming via macros

Ruby has Rails.

Elixir has Phoenix.

Controllers in Rails

class PagesController < ApplicationController def index @title = params[:title] @members = [ {name: "Chris McCord"}, {name: "Matt Sears"}, {name: "David Stump"}, {name: "Ricardo Thompson"} ] render "index" endend

http://www.littlelines.com/blog/2014/07/08/elixir-vs-ruby-showdown-phoenix-vs-rails/

Controllers in Phoenix

defmodule Benchmarker.Controllers.Pages do use Phoenix.Controller

def index(conn, %{"title" => title}) do render conn, "index", title: title, members: [ %{name: "Chris McCord"}, %{name: "Matt Sears"}, %{name: "David Stump"}, %{name: "Ricardo Thompson"} ] endend

http://www.littlelines.com/blog/2014/07/08/elixir-vs-ruby-showdown-phoenix-vs-rails/

Future of Elixir

● new Erlang for the masses● fits highly concurrent niche● attracts Ruby developers● no big company behind● used by Pinterest● will fly on the wings of Phoenix?

● created by data scientists● released in 2012● dynamically, strongly typed● compiled

Compiled one for fast stuff.Interpreted one for visualisation.

Data scientists’ two languages problem:

Julia features

● solves scientists’ two language problem● familiar syntax● extensive scientific library● user-defined types● multiple dispatch● built-in parallelism ● good performance (comparing to C)

Single dispatch (Ruby)

a.do_something(b, c)

Only a decides which method to choose.

Multiple dispatch

julia> f(x::Float64, y::Float64) = 2x + y;

julia> f(2.0, 3.0)7.0

julia> f(2.0, 3)ERROR: MethodError: `f` has no method matching

Here everything decides!

Future of Julia

● R, MATLAB and C competitor ● unifies scientific software stack● not mature enough yet● small, but growing number of libraries

● created by Google● released in 2011● optionally typed● interpreted● translated to JavaScript

Let’s replace JavaScript!

Dart vs JavaScript

● class-based (not prototype-based)● normal foreach● named parameters● operator overriding● string interpolation● optional typing● false is false● easy DOM operations

Looks familiarclass Point { num x; num y;

Point(this.x, this.y); distanceFromOrigin() { return sqrt(x * x + y * y); }}

main() { var p = new Point(2, 3); print(p.distanceFromOrigin());}

Cascade operator

querySelector('#button') ..text = 'Confirm' ..classes.add('important') ..onClick.listen(

(e) => window.alert('Confirmed!'));

Future of Dart

● 2016 AdWord UI built in Dart● no Dart VM in browsers● fragmented community● client-side future is dim● backend future looks much better

Sources

● developer.apple.com/swift● rust-lang.org● golang.org● elixir-lang.org● julialang.org● dartlang.org

Any questions?

@mjkonarski

michalkonarski

michal.konarski@u2i.com