Hi. This talk is going to be, mostly, a plug for Rust.
-Those of you who know me may find this surprising. After all Rust in
+Those of you who know me may find this surprising. After all, Rust in
its current form is only about 4 years old, and I myself only learned
it in December. I'm not known for liking new things :-). All I can
say is that I tried it and have been impressed.
programmers have typically used in C and C++ to make their code
comprehensible.
+[ Borrowing example slide ] https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#mutable-references
+
But in Rust the ownership is known to the language, and the rules
surrounding ownership are enforced by the compiler. When an object
ceases to have an owner, it is freed.
This ownership system is used not only for dynamically allocated
objects, but for local variables, and statically allocated objects.
-[ Borrowing example slide ] https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#mutable-references
+[ dangling reference error example https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#dangling-references ]
To allow an object to be accessed other than through owner, Rust
formalises the notion of borrowing. An object can be borrowed by
writing the ampersand, giving a reference. The compiler checks that
the object will outlive the reference.
-[ dangling reference error example https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#dangling-references ]
+[ Borrowing example slide with mut missing ] ABOVE https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#mutable-references
Borrows (that is, references) come in two kinds: mutable and
immutable. You can have many immutable references at once. A mutable
reference permits modification, and provides exclusive access.
-[ Borrowing example slide with mut missing ] ABOVE https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#mutable-references
-
That's what the `mut' is doing in that example. If you leave it out
the compiler complains. This is the Rust `borrow checker' that you
have may have heard about: the part of the compiler which enforces the
C======================================================================C
-[ overview slide? | syntax ]
+[ tour - syntax ]
Apart from the ownership system, there is little new in Rust.
Nevertheless, it is an advanced language with a lot of expressive
power - power which is generally available without sacrificing
performance.
-Sometimes advanced languages from academia can feel like
-incomprehensible alien technology, with a steep learning curve and an
-unfamiliar or even obscure syntax.
-
-Not Rust. For me, Rust has managed to take the best and most proven
-features of earlier research languages, and package them up into a
-whole which feels fairly familiar and is easy to use.
+Despite being an advanced and powerful language, Rust mostly manages
+to feel quite familiar. I have found it easy to learn and to use.
I'm going to zoom through a few of Rust's most important properties:
-[ syntax | safety ]
-
Rust's syntax is a conventional structure of curly braces, keywords,
parentheses, and infix expressions. It looks a lot like C or
JavaScript or something.
-[ safety | type ]
-
-Rust is safe by default. That is, bugs in your code can't corrupt
-memory the way that they do in C and C++. But, unlike most other safe
-languages, if you really want full manual control, you can write
-`unsafe'. This is rarely needed, even if you want really fast code.
-
-[ type | inference ]
+[ tour - type annotations ]
Rust is statically typed. The compiler will typecheck it. This is
great. You may have heard Haskell and Ocaml programmers say "once you
editor. Then keep fixing errors until it builds and lo! it will often
work.
+[ tour - type inference & polymorphism ]
+
Rust also has type inference (similar to Ocaml, Haskell, etc.), so you
can often leave out the type annotations.
-[ polymorphism ]
-
Rust supports polymorphism (also known as `generics'; it calls the
feature `traits'. They're a bit bit like C++ templates, but not mad.
Rust supports dynamic dispatch (like `virtual' in C++), or static
dispatch, but in both cases the typechecking is done at compile time.
-[ unsafe Rust/C/C++ example, chrobakpayne.rs glue.cpp ]
+[ tour - safety ]
+
+Rust is safe by default. That is, bugs in your code can't corrupt
+memory the way that they do in C and C++. But, unlike most other safe
+languages, if you really want full manual control, you can write
+`unsafe'. This is rarely needed, even if you want really fast code.
+
+[ tour - unsafe Rust/C/C++ example, chrobakpayne.rs glue.cpp ]
Rust has a reasonably good system for interfacing to code written in
other languages. With the appropriate annotations, you can call C
Of course nothing is perfect. I'm very critical by nature, so I often
find things to gripe about.
-[ borrow checker error ]
+[ borrow checker error, lifetime example ]
The most obvious difficulty with Rust, if you read the internet, is
some's feeling they are constantly fighting the borrow checker.
Rust does have macros. In fact it has two ways to define macros (one
built on top of the other). The more sophisticated macro system is
-very capable and has been used to really impressive effect. But it's
-hard to use casually; and the simpler macro definition facility is
-simultaneously too complicated and underpowered. So casual macro use
-is slightly awkward.
+very capable and has been used to really impressive effect. You can
+see an example here.
+
+But it's hard to use casually; and the simpler macro definition
+facility is simultaneously too complicated and underpowered. So
+casual macro use is slightly awkward.
[ cargo - dw posts, links ]
it. Apparently this is what is expected by the youth of today. It
can be hit hard enough to stop it doing this, but you still run into
the difficulty that if you use one library from the repository, you
-end up having to trust much more widely than ideal. And at least
+end up having to trust much more widely than ideal. At least
Rust's repository contains larger libraries than, say node.js's, so
-the number of people you're trusting is much lower.
+the number of people you're trusting is much lower, but it's still
+troublesome.
Also, as a build tool, cargo can be very inflexible. Despite an
official policy that cargo should be suitable for running inside
up containing piece of opinionated curl-pipe-bash-ware, you should
expect a culture which produces these kind of problems.
+[ other problems ]
+
+Rust does not currently readily support dynamic linking between Rust
+modules. This is something the Rust community know they need to work
+on but it hasn't been their priority. Some of Rusts's language design
+choices make this challenging, although not impossible. In particular
+the very nice system of generics. Personally I like the tradeoff that
+Rust has made here. I expect that some form of dynamic linking or
+partial compilation will very likely appear eventually. But in the
+meantime there are places where replacing C with Rust is awkward.
+
+Rust depends on LLVM. So its architecture support for smaller
+architectures (with less money behind them) is poor. From my point of
+view as a Debian contributor a particular problem is the lack of an
+m68k backend for LLVM. But it provides a more general difficulty with
+supporting a wide set of embedded architectures, which Rust would
+otherwise be very suited to.
+
+
F======================================================================~
-[ rust-lang, ian.jackson@ ]
+[ rust-lang, ijackson@ ]
Despite these difficulties, and of course a fair few minor
irritations, I have found programming in Rust to be both fun and very
productive.
-I'm a very polylingual programmer. I think my record is 6 languages
-in the same personal project. Some of my recent forays into Rust have
+I tend to mix languages a lot. I think my record is 6 languages in
+the same personal project. Some of my recent forays into Rust have
involved switching between Rust and C++ and Perl. This kind of thing
throws differences between languages into sharp relief.
I'll still start new programs in many of those other languages, and
often I choose a language for its libraries. But for me Rust will
-now often be my preferred choice, if I can get away with it.
+now often be high on my list, if I can get away with it.
If you want to know more, there's a wealth of stuff online. The place
to start is probably https://docs.rust-lang.org/. And of course I'd
~ijackson / talk-2019-ghm-rust.git / blobdiff