MozillaPH Rust Hack & Learn Session 2

Rust
Hack & Learn
Session #2
Robert “Bob” Reyes
05 Jul 2016
#MozillaPH
#RustPH

Check-in at Swarm &
Foursquare!

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

Agenda
• Mozilla in the Philippines
• Type Option in Rust
• Conditional Statements
• Loops
• Functions
• What to expect on Session 3?

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.

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

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

Firefox Student
Ambassadors (FSA)
http://fsa.mozillaphilippines.org

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

Some stuff that we
are working on …

MozillaPH Rust Hack & Learn Session 2

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

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

Co-work from
MozSpaceMNL
http://mozspacemnl.org

Let’s get to know
each other first.
What is your name?
From where are you?
What do you do?
Why are you here?

Where are the
MENTORS?
Please feel free to approach & ask
help from them 

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.”

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.

Mozilla ❤️ Rust
• Rust grew out of a personal project by
Mozilla employee Graydon Hoare.
• Rust is sponsored by Mozilla Research
since 2009 (announced in 2010).

Type Option
• Type Option represents an optional value
• Every Option is either:
• Some  contains a value
or
• None  does not contain any value

Type Option
• Option types are very common in Rust code & can be
used as:
• Initial values
• Return values for functions that are not defined over
their entire input range (partial functions)
• Return value for otherwise reporting simple errors,
where None is returned on error
• Optional struct fields
• Struct fields that can be loaned or "taken" Optional
function arguments
• Nullable pointers
• Swapping things out of difficult situations

If/Else Statement
• if-else in Rust is similar to other languages.
• However, the boolean condition doesn't need to be
surrounded by parentheses, &
• Each condition is followed by a block.
• if-else conditionals are expressions  all branches
must return the same type.

[Samples] If/Else
fn main() {
let n = 5;
if n < 0 {
println!(“{} is negative”, n);
} else if n > 0 {
println!(“{} is positive”, n);
} else {
println!(“{} is zero”, n);
}
}

[Samples] If/Else
 Add to the end of the previous example
let big_n =
if n < 10 && n > -10 {
println!(“and is a small number,
increase ten-fold”);
10 * n
} else {
println!(“and is a big number, reduce
by two”);
n / 2
};
println!(“{} -> {}”, n, big_n);
}

Loop in Rust
• Rust provides a loop keyword to indicate an infinite
loop.
• The break statement can be used to exit a loop at
anytime,
• The continue statement can be used to skip the rest
of the iteration & start a new one.

[Samples] Loop
fn main() {
let mut count = 0u32;
println!(“Let’s count until infinity!”);
loop {
count +=1;
if count == 3 {
println!(“three”);
continue;
}
println!(“{}”, count);
if count == 5 {
println!(“OK, that’s enough!”);
break;
} } }

Nesting & Labels
• It is possible to break or continue outer loops when
dealing with nested loops.
• In these cases
• the loops must be annotated with some 'label
and
• the label must be passed to the break/continue
statement.

[Samples] Nesting & Labels
fn main() {
‘outer: loop {
println!(“Entered the outer loop”);
‘inner: loop {
println!(“Entered the inner
loop”);
break ‘outer;
}
println!(“This point will never be
reached”);
}
println!(“Exited the outer loop”);
}

While Statement
• The while keyword can be used to loop until a
condition is met.
• while loops are the correct choice when you’re not
sure how many times you need to loop.

[Samples] While Statement
fn main() {
let mut n = 1;
while n < 101 {
if n % 15 == 0 {
println!(“fizzbuzz”);
} else if n % 3 == 0 {
println!(“fizz”);
} else if n % 5 == 0 {
println!(“buzz”);
} else {
println!(“{}”, n);
}
n += 1;
} }

For & Range Statement
• The for in construct can be used to iterate through
an Iterator.
• One of the easiest ways to create an iterator is to use
the range notation a..b.
• This will yield values from a (inclusive) to b (exclusive)
in steps (increment) of one.

[Samples] For & Range
fn main() {
for n in 1..101 {
if n % 15 == 0 {
} else if n % 3 == 0 {
} else if n % 5 == 0 {
} else {
println!(“{}”, n);
}
}
}

Match Statement
• Rust provides pattern matching via
the match keyword.
• Can be used like a switch statement in C.

[Samples] Match
fn main() {
let number = 13;
println!(“Tell me about {}”, number);
match number {
1 => println!(“one!”),
2 | 3 | 5 | 7 | 11 => println!(“prime”),
13…19 => println!(“a teen!”),
_ => println!(“not special”),
}
}

[Samples] Match
fn main() {
let boolean = true;
let binary = match boolean {
false => 0,
true => 1,
};
println!(“{} -> {}”, boolean, binary);
}

If Let Statement
• if let is a cleaner alternative to match statement.
• It allows various failure options to be specified.

[Samples] If Let
fn main() {
let number = Some(7);
let letter: Option<i32> = None;
let emoticon: Option <i32> = None;
if let Some(i) = number {
println!(“Matched {:?}!”, i);
} else {
println!(“Didn’t match a number. Let’s
go with a letter!”);
};
let i_like_letters = false;
<continued…>

[Samples] If Let
if let Some(i) = emoticon {
println!(“Matched {:?}!”, i);
} else if i_like_letters {
println!(“Didn’t matched a number. Let’s
go with a letter!”);
} else {
println!(“I don’t like letters. Let’s go
with an emoticon :)!”);
};
}

While Let Statement
• Similar to if let.
• while let can make awkward match sequences
more tolerable.

[Samples] While Let
fn main() {
let mut optional = Some(0);
while let Some(i) = optional {
if i > 9 {
println!(“Greater than 9, quit!”);
optional = None;
} else {
println!(“’i’ is ‘{:?}’.
Try again.”, i);
optional = Some(i + 1);
}
}
}

Functions in Rust
• Functions are declared using the fn keyword
• Arguments are type annotated, just like variables
• If the function returns a value, the return type must be
specified after an arrow ->
• The final expression in the function will be used as
return value.
• Alternatively, the return statement can be used to return
a value earlier from within the function, even from inside
loops or if’s.

[Samples] Functions
• Fizz Buzz Test
• "Write a program that prints the numbers from 1 to
100.
• But for multiples of three print “Fizz” instead of the
number
• For the multiples of five print “Buzz”.
• For numbers which are multiples of both three and
five print “FizzBuzz”."

[Samples] Functions
fn main() { fizzbuzz_to(100);
}
fn is_divisible_by(lhs: u32,
rhs: u32) -> bool {
if rhs == 0 {
return false;
}
lhs % rhs == 0
}
fn fizzbuzz(n: u32) -> () {
if is_divisible_by(n, 15)
{
} else if
is_divisible_by(n, 3) {
} else if
is_divisible_by(n, 5) {
} else { println!(“{}”,
n);
}
}
fn fizzbuzz_to(n: u32) {
for n in 1..n + 1 {
fizzbuzz(n);
}
}

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

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

Next: Session #3
• We need VOLUNTEERS to talk about:
• Rust Standard Library
• Vectors
• Strings
• Concurrency
• Error Handling

WANTED: RustPH Mentors
• REQUIREMENTS:
 You love teaching other developers while learning
the Rust programming language.
• RustPH Mentors Meeting on Wed 13 Jul 2016 from
1900H to 2100H at MozSpaceMNL.
• MEETING AGENDA:
• Draw out some plans on how to attract more
developers in learning Rust.
• How to make developer journey in learning Rust a
fun yet learning experience.

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

MozillaPH Rust Hack & Learn Session 2

More Related Content

What's hot

What's hot (20)

Similar to MozillaPH Rust Hack & Learn Session 2

Similar to MozillaPH Rust Hack & Learn Session 2 (20)

More from Robert 'Bob' Reyes

More from Robert 'Bob' Reyes (20)

Recently uploaded

Recently uploaded (20)

MozillaPH Rust Hack & Learn Session 2

Editor's Notes