The document is an introduction to the Rust programming language, covering its history, features, and the importance of ownership in memory safety. It also discusses Mozilla's role in Rust's development, including its use in projects like Servo and Firefox. Additionally, the agenda includes topics such as installing Rust, using Cargo, and basic programming concepts in Rust.

1. Introduction to
Rust
(Programming Language)
Robert “Bob” Reyes
08 Sep 2017
#MozillaPH
#RustPH

2. #MozillaPH
#RustPH
If you’re on social media, please use
our official hashtags for this talk.

3. About Me
• Mozilla Rep for the PHL since 2011
• Technopreneur at TurfSitePH.net
• Technology Columnist at MB.com.ph
• Team Manager at SIPFC.org
• Dad of Xeon & Haswell

4. Being an Open Source Dev

5. Target Audience
• People with some background in
programming (any language).
• People with zero or near-zero knowledge
about Rust (Programming Language).
• People who wants to learn a new
programming language.

6. Agenda
• Mozilla in the Philippines
• Installing Rust
• Hello World, the Rust way
• Intro to Cargo
• IDE Support
• Variables & Constants
• Simple Arithmetic Functions

7. What is
Mozilla?

8. #MozillaPH

9. History of Mozilla
On 23 Feb 1998,
Netscape Communications Corp.
created a project called
Mozilla (Mosaic + Godzilla).
Mozilla was launched 31 Mar 1998.

10. We have a NEW
brand identity…

11. We have a NEW
brand identity…

12. The
Mozilla Manifesto

13. Mozilla’s Mission
To ensure the Internet
is a global public
resource, open &
accessible to all.

14. Get involved …

15. Some stuff that we
are working on …

17. #MozillaPH

19. #MozillaPH

20. How to be part of
MozillaPH?

21. Areas of Contribution
 Helping Users
(Support)
 Testing & QA
 Coding
 Marketing
 Translation &
Localization
 Web Development
 Firefox Marketplace
 Add-ons
 Visual Design
 Documentation &
Writing
 Education
 Rust Development
http://join.mozillaph.org

22. Join MozillaPH now!
http://join.mozillaph.org

23. Internship
at Mozilla
https://careers.mozilla.org/university/

24. Mozilla HQ

25. Mozilla HQ

26. Mozilla HQ

27. Mozilla HQ

28. Mozilla HQ

29. Mozilla HQ

30. Mozilla HQ

31. Mozilla HQ

32. Mozilla HQ

33. Mozilla HQ

34. Mozilla HQ

35. Mozilla HQ

36. Mozilla HQ

37. Mozilla HQ

38. Mozilla HQ

39. Mozilla HQ

40. Mozilla HQ

41. Mozilla HQ

42. Mozilla HQ

44. #MozillaPH

46. What is
Rust?

47. What is Rust?
• Rust is a systems programming language
that runs blazingly fast, prevents
segfaults, & guarantees thread safety.
• Compiles to Native Code like C++ & D.
• Strength includes memory safety &
correctness (just like in C).
“Rust is a modern native-code language
with a focus on safety.”

48. What is Rust?
• At present…
• Rust has more than 6.8K libraries, with
more than 85M downloads at crates.io
• More than 40 companies publically
using in production (Friends of Rust).

49. Mozilla &
Rust?

50. Mozilla ❤️ Rust
• Started as Mozillian Graydon Hoare’s
side project.
• He began working on Rust full time in 2009.
• Rust 1.0 released in 2015.
• New releases every six (06) weeks.
• Rust is Mozilla-supported, rather than
Mozilla-owned.

51. Rust &
Servo

52. Rust & Servo
• One part of Mozilla is working on
improving Rust.
• Another part is building a brand new web
rendering engine using Rust: Servo.
• High-level goals of Servo:
• Implement parallel layout.
• Experiment with alternative rendering design.
• Investigate feasibility of complete JS GC integration.
• Incubator for experiments that can be reintegrated
into Firefox.

53. Rust &
Firefox

54. Rust & Firefox
• We are already shipping Rust code in
Firefox (inside the media stack).
• The process of re-writing existing C++
code to Rust is called Oxidation.
• Some of the most challenging projects
related to Oxidation is part of the
Quantum project.
• The amount of Rust code in Firefox will
increase over time.

55. Rust & Firefox

56. Why
Rust?

57. Why Rust?
• Rust solves two core problems from
C++ & similar low-level programming
languages:
• Data races in multithreaded code.
• Use-after-free (UAF) errors.
• UAF’s are huge source of security
exploits in Firefox & other browsers.
• Both problems are addressed by making
“ownership” explicit.

58. Top 10 IoT Programming
Languages
1. C Language
2. C++
3. Python
4. Java
5. JavaScript
6. Rust
7. Go
8. Parasail
9. B#
10.Assembly
• No particular order.
• Based on popularity & following.

59. Low-Level
vs
High-Level

60. Programming Languages
Hardware
Machine Language
Assembly Language
High-Level Language
Fortran | C | Pascal
OO & Visual Languages
C++ | D | Rust

61. Ownership
in Rust

62. Ownership in Rust
• Encapsulates two (02) concepts:
• The lifetime of a value (i.e. when it is valid to
interact with it).
• Unique vs Shared Values.
• Leads to a few rules:
• Uniquely-owned values are destroyed when
they go out of scope.
• Only uniquely-owned values can be mutated.
• Borrowing a value means it is no longer
uniquely owned.

63. Ownership in Rust (Analogy)
• I have a coloring book, a marker & some
friends.
• If I leave, the coloring book & marker
leave with me.
• If a friend borrows the book, I can no
longer color it.
• My friends can also lend it to other friends.
• If someone leaves while my friends are
borrowing the book, they give it back before
leaving.

64. Ownership in Rust (Analogy)
• I can’t leave if the book is still borrowed.
• Either I wait, or I should have given it away.
• I can also lend someone the marker along with the
book, if they want to color in it.

65. How Does Ownership Help?
• Use-After-Free
• Can’t return/store pointer to an object that may
be deallocated before pointer.
• Can’t use immutable & mutable pointers to the
same object.
• Data Races
• Forced transfer ownership of data or copy when
using multiple threads.
• Only types that abide by compiler rules can be
shared – ensures type locking/atomic access is
used.

66. Race
Condition

68. What is Race Condition?
• A race condition is…
• An undesirable situation.
• Occurs when a device or system
attempts to perform two or more
operations at the same time.
• But because of the nature of the device
or system, the operations must be done
in the proper sequence to be done
correctly.

69. Features of
Rust?

70. Features of Rust
• Zero-cost abstractions
• Move semantics
• Guaranteed memory safety
• Threads without data races
• Trait-based generics
• Pattern matching
• Type inference
• Minimal runtime
• Efficient C bindings

71. Projects using
Rust

72. Projects Using Rust
 Magic Pocket
 Dropbox's file storage system that powers their
Diskotech petabyte storage machines.
 Servo
 Mozilla's new parallel rendering engine developed
in collaboration with Samsung.
 OpenDNS
 Uses Rust in two of its components.
 Redox OS
 A microkernel operating system being developed
in Rust.

73. Projects Using Rust
 Xi Editor
 The xi editor project is an attempt to build a high
quality text editor, using modern software
engineering techniques.
 GNU uutils coreutils
 uutils is an attempt at writing universal (as in cross-
platform) CLI utils in Rust. This repo is to
aggregate the GNU coreutils rewrites.
 Neon
 A safe Rust abstraction layer for native Node.js
modules.

74. Installing
Rust

75. Installing Rust
• Installer for Windows, Mac OS X & Linux available via
https://www.rust-lang.org
• If you wish to run Rust on your local machine when
you’re offline.
• Rust Playground [https://play.rust-lang.org]
• If you are online, you may opt to use this one
instead.
• You may use ANY text editor to code in Rust.
• As a practice, please save your Rust code
using .rs file extension.

76. Rust Playground

77. Rust Playground (Run)

78. Function
Main()

79. Function main()
• Every Rust program must have at least one (01)
function.
• Simplest possible function declaration is named as
“main”
fn main() {
}
• Functions can also take arguments
fn print_number(x:i32) {
println!(“x is: {}”, x);
}

80. Hello World
in Rust

81. helloworld.rs
fn main()
{
println!(“Hello world in Rust!”);
}

82. helloworld.rs (Run)

83. Cargo

84. Cargo
• A tool that allows Rust projects to declare their various
dependencies & ensure that you’ll always get a
repeatable build.
• Cargo does:
1. Introduces two (02) metadata files with various bits
of project information.
2. Fetches & builds your project’s dependencies.
3. Invokes rustc or another build tool with the correct
parameters to build your project.
4. Introduces conventions to make working with Rust
projects easier.

85. Cargo
• To start a new project with Cargo, we invoke in the
command line:
cargo new hello_world --bin
• Cargo will generate the following files & folders:
 Cargo.toml [file]
 src [folder]
 main.rs [file]
• Acts as a manifest file
• Contains all of the metadata that Cargo needs to
compile your project.

86. TOML, what?!

87. TOML
• Tom’s Obvious, Minimal Language
(or some say, Tom’s Own Markup Language)
• Created by Tom Preston-Werner
• Aims to be a minimal configuration file format that's
easy to read due to obvious semantics.
• Designed to map unambiguously to a hash table.
• Should be easy to parse into data structures in a wide
variety of languages.

88. Cargo.toml

89. Cargo.toml
[package]
name = "hello_world”
version = "0.1.0”
authors = ["Your Name <you@example.com>"]

90. IDE Support

91. IDE Support
• Modern IDEs give developers a massive increase in
productivity.
• Several community projects have provided an excellent
start towards IDE support.
• Good IDE support requires a number of components:
• The compiler must be modified to operate in a
different mode.
• Must provide name & type information from the
compiler to the IDE.
• Must write plugins for the IDEs themselves so they
know what to do with Rust projects.

92. IDE Support
• Available IDE Plugins:
• Eclipse [https://github.com/RustDT/RustDT]
• Intellij IDEA [https://github.com/intellij-rust/intellij-rust]
• Visual Studio [https://github.com/PistonDevelopers/VisualRust]
• Editor Plugins:
• Atom [https://atom.io/packages/language-rust]
• Emacs [https://github.com/rust-lang/rust-mode]
• Sublime Text [https://packagecontrol.io/packages/Rust]
• Vim [https://github.com/rust-lang/rust.vim]
• Visual Studio Code
[https://github.com/saviorisdead/RustyCode]

93. More on IDE Support
https://www.rust-lang.org/ides.html

94. Types &
Variables

95. Variables
• Variable Declaration
fn main() {
let a:u8 = 123;
}
• Whereas
• a  variable
• u8  data type (unsigned; 0 or positive; 8-bit)
• 123  value of variable “a”

96. Numeric Data Types
• i8  8-bit signed integer
• i16  16-bit signed integer
• i32  32-bit signed integer
• i64  64-bit signed integer
• u8  8-bit unsigned integer
• u16  16-bit unsigned integer
• u32  32-bit unsigned integer
• u64  64-bit unsigned integer
• isize  pointer-size signed integer
• usize  pointer-size unsigned integer
• f32/f64  32/64-bit floating point

97. Mutability
in Rust

98. Mutability
• The ability to change something.
• Mutable variable binding.
• You’re allowed to change what the binding points to.
let x = 5;
x = 6;  will result to an error!
• We can use the mut keyword:
let mut x = 5;
x = 6;  no problem; no error!

99. Constants
• Aside from using variables, we can also declare
constants in Rust:
const PI:u8 = 3;
 no fixed memory address
 memory safety is NOT compromised
static X:i32 = 123;

100. Operators
in Rust

101. Arithmetic Operators
+  addition & array/string concatenation
-  subtraction
*  multiplication
/  quotient
%  remainder

102. Arithmetic Operators
• Rust DOES NOT support ++ and – used in other
programming languages.
• a = a+1; or
• a += 1;
• b = b-1; or
• b -= 1;
• You may also use the following in Rust
• *=
• /=
• %=

103. Arithmetic Operators
let mut a = 2+3*4;
println!(“Answer = {}.”, a);
let mut a = (2+3)*4;
println!(“Answer = {}.”, a);

104. Arithmetic Operators
let mut a = 10/3;
println!(“Answer = {}.”, a);
let mut a = 10%3;
println!(“Answer = {}.”, a);
let a=10;
println!(“Remainder of {} / {}
= {}”, a, 3, (a%3));

105. More Sample
(Try them out)

106. Arithmetic Operators (eg1)
fn main() {
let num1 = 20;
let num2 = 10;
println!(“The SUM of the numbers =
{}”, (num1 + num2));
println!(”The DIFFERENCE of the
numbers = {}”, (num1 – num2));
… and so on

107. Arithmetic Operators (eg2)
fn main() {
let num1 = 20;
let num2 = 10;
let sum = num1 + num2;
let dif = num1 – num2;
let pro = num1 * num2;
let quo = num1 / num2;
println!(“The SUM of the numbers =
{}”, sum);
… and so on

108. Q&A

109. References

110. Reference Materials
• The Rust Programming Language Book
• https://doc.rust-lang.org/book/
• Rust by Example
• http://rustbyexample.com
• Rust User Forums
• https://users.rust-lang.org
• https://internals.rust-lang.org

111. facebook.com/groups/rustph

112. https://rustph.slack.com
To request an invite:
https://rustphslack.herokuapp.com

113. Thank you!
Maraming salamat po!
http://www.mozillaphilippines.org
bob@mozillaph.org