Post on 13-Apr-2017
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