@timglabisch

Ich bin Tim
Wer mich schon mal im Internet gesehen hat, vermutlich mit diesem Bild
Ich Maintaine Deptrac primär
- Wenn Deptrac doof ist, und rust doof ist, dann hab ich euch wohl den abend versaut x)
... Und Github denkt ich würde in diesen Sprachen entwickeln
- Das ist definitiv falsch, ich mach kein Basic x)
- gibt aber vielleicht ein ganz guten Überblick über meinen "sprachlichen" Background
Ich arbeite hier für Sensiolabs
- Und wie jede andere Firma, suchen wir natürlich auch nach neuen tollen mitarbeitern, wer also interesse hat, gerne einfach mich, andreas und freerich ansprechen.
Der Titel des Talks war ja Rust für PHP Devs
- In diesem Sinne hab ich heute viel Code mitgebracht
- Ich hab aber auch viele Slides mitgebracht
- Sollte ich euch deutlich zu schnell werden, einfach aufschreien oder mit irgendwas nach mir werfen.

echo sprintf("%s", "Hello PHPUG!");

(clickable)

function greet(string $name) {
    echo sprintf(
		"Hello %s",
		$name
	);
}

$name = "PHPUG";
greet($name);

(clickable)

class Person {
    public $age = null;
}

$tim = new Person();
$tim->age = 25;
echo sprintf(
	"Tim is %d years old",
	$tim->age
);

(clickable)

class Person {
    public $age;

    private function __construct(int $age) {
        $this->age = $age;
    }

    public static function newWithAge(int $age) : Person {
        return new static($age);
    }
}

$tim = Person::newWithAge(25);
echo sprintf("Tim is %d years old", $tim->age);

(clickable)

Hier haben wir auf der rechten seite eine Typische Klasse in PHP (mit einem named Constructor)
Der Konstruktor (statische Funktion) erlaubt das erstellen einer Person mit einem Alter
Der Rückgabewert des Construktors ist eine Person (php7)
im anschluss lässt sich eine Person erstellen, mit einem alter, und das alter ausgeben
...recht klassisches php...
Schauen wir uns den Rust Code an
- wir definieren ein struct (unserer properties in php)
- Rust kennt nur "named constructors (new ist lediglich eine Namenskonvention)
- In Rust wird immer die letzte Expression zurückgegeben, man spart sich also das "return"
- Im Anschluss kein über ::new Instanz erstellt werden
- Diese kann dann wie gewohnt verwendet werden

Warum Rust?

>

prevents segfaults - kennt jemand segfaults?
Das sind die Fehler die z.b.
- PHP Intern sind und kein spass zum Debuggen machen
- hab ich häufiger mal wenn ich gewaltige tests suits laufen lasse
- Wäre PHP also in Rust geschrieben, dann könnte es diese art von Fehlern nicht geben?
  - Krass
  - Absolutes alleinstellungsmerkmal unter "System programming" sprachen.
- thread safety ist auch so ne sache
  - Threading ist hart
  - Rust ist die erste sprache, welche thread safety erzwingen kann
- Wie macht rust das alles?
  - Es kompilliert schlicht nicht, wenn es sich nicht sicher ist.

Der ganze wichtige Kram

ist in C / C++

geschrieben

people.mozilla.org/~acrichton/rust-talk-2014-12-10/#/2/1
youtube.com/watch?v=agzf6ftEsLU

C++ Fehlerhandling

Kein "PHPStorm".

Kein "Composer".

Memory Management.

people.mozilla.org/~acrichton/rust-talk-2014-12-10/#/2/1
youtube.com/watch?v=agzf6ftEsLU

people.mozilla.org/~acrichton/rust-talk-2014-12-10/#/4/1

Wie löst Rust das "Problem"?

function greet(string $name) {
    echo "Hello ". $name . "\n";
}

$name = "PHPUG";
greet($name);
greet($name);

(clickable)

Borrowing

"ownership" löst das free() Problem.

Rusts Ownership bedeutet sichere parallele Programmierung.

Selbst wenn PHP-Entwickler involviert sind.

Effizientes Memory Management.

Heap vs. Stack

// Frag den Ram nach Platz für ne Zval
//
// typedef union _zvalue_value {
//    long lval;                 /* long value */
//    double dval;               /* double value */
//    struct {
//        char *val;
//        int len;               /* this will always be set for strings */
//    } str;                     /* string (always has length) */
//    HashTable *ht;             /* an array */
//    zend_object_value obj;     /* stores an object store handle, and handlers */
// } zvalue_value;
//
// registriere die variable im GC

$a = "Foo";
// und prüf hin und wieder und am ende, ob die variable noch gebraucht wird

(clickable)

# sudo dtrace -n 'pid$target::malloc:entry' -c "php malloc.php"

function foo() {
    return "fooooo";
}

echo "------------------------\n";
sleep(2);

while(true) {
    $a = foo();
    sleep(0.5);
}

(clickable)

Installation

Rustup / (apt / compile your own / phpbrew)

$ phpbrew install 5.4.0 +default

$ phpbrew use 5.4.22

$ curl https://sh.rustup.rs -sSf | sh

$ rustup default nightly

Rustup funktioniert wie phpbrew
einfaches update command und man ist auf der neusten version.
den bedarf für module gibts nicht, weil rust ja in rust geschrieben ist
Rustup kann auch sehr einfach Cross kompilieren
- Das Rust Team arbeietet hard daran, dass es kein Problem ist
- Von Windows auf Linux zu kompillieren
- von Irgendwas auf ARM
- Momentan werden 32 Targets unterstützt, sowas wie Android, Freebsd, Powerpc...

➜ rust_for_php_devs git:(master) ✗ rustup toolchain list stable-x86_64-apple-darwin nightly-2016-03-14-x86_64-apple-darwin nightly-2016-03-27-x86_64-apple-darwin nightly-2016-05-10-x86_64-apple-darwin nightly-2016-05-20-x86_64-apple-darwin nightly-2016-05-27-x86_64-apple-darwin ➜ rustup target list

Package Management

cargo / composer

composer

composer.json / composer.lock

cargo

Cargo.toml / Cargo.lock

cargo

$ cargo new --bin hellophpug

$ cargo run

IDE?

PHP "Basics"

include, autoloader, namespaces, tests

Autoloader + Namespaces

if (
	file_exists($mod.'.rs') &&
	file_exists($mod.'/mod.rs')
) {
    throw new \Exception(
        '[file].rs or [file]/mod.rs?'
    );
} else if (file_exists($mod.'.rs')) {
    include $mod.'.rs';
} else if (file_exists($mod.'.rs')) {
    include $mod.'/mod.rs';
}

(clickable)

Autoloader + Namespaces

Tests

Lets "write" a small webserver.

$ cargo new --bin webfoo

[dependencies]
nickel = "*"

#[macro_use] extern crate nickel;

use nickel::{Nickel, HttpRouter};

fn main() {
	let mut server = Nickel::new();

	server.get("/", middleware!(
		let a = "Hello World";
		a
	));

	server.get("/bar", middleware!("Bar"));
	server.listen("127.0.0.1:6767");
}

$ cargo run

Ein wenig mehr OOP

class Person {

    private $age;

    function __construct($age) {
        $this->age = $age;
    }

    function getAge() {
        return $this->age;
    }
}

echo sprintf(
	"Tim is %d years old",
	(new Person(25))->getAge()
);

(clickable)

Compiler Warnung bei: fn main() { let mut names = Vec::new(); println!("{}", names.join(", ")); }

qafoo.com/blog/083_never_use_null

$numbers = [1, 2, 3, 4, 5, 6, 10, 100];

$result =
	array_values(array_map(
		function($a) { return $a * 2; },
		array_filter(
			array_filter($numbers, function($a) { return $a > 4; }),
			function($a) { return $a < 100; }
		)
	));

$result[] = 10;
$result[] = 11;

var_dump($numbers);

(clickable)

Generics

class Option<T> {

    private T $value;

    public function __construct(T $value) {
        $this->value = $value;
    }

    public function unwrap() {
        if ($this->value === null) { die('yolo'); }
        return $this->value;
    }
}

echo (new Option<String>("hello"))->unwrap();
echo (new Option<String>(null))->unwrap();

(clickable)

Community

Projects

thx :)

Fragen?

https://medium.com/@deckarep/paradigms-of-rust-for-the-go-developer

Lifetimes

map/reduce

Mapper

while (($line = fgets(STDIN)) !== false) {
    $matches = [];
    preg_match('/\d+$/', $line, $matches);
    if (!isset($matches[0])) {
        continue;
    }
    $url_number = $matches[0];
    echo $url_number."\t".'1'."\n";
}

(clickable)

Reducer

$lastNumber = null;
$lastCount = 0;
while (($line = fgets(STDIN)) !== false) {
    list($number, $count) = explode("\t", $line);
    if ($lastNumber === null) {
        $lastNumber = $number;
    }
    if ($lastNumber === $number) {
        $lastCount++;
        continue;
    }
    echo $lastNumber."\t".$lastCount."\n";
    $lastCount = 1;
    $lastNumber = $number;
}
if ($lastCount && $lastNumber) {
    echo $lastNumber."\t".$lastCount."\n";
}

(clickable)

Rust for PHP devs