Using Git, Pointers in Rust

cs4414 Fall 2013
University of Virginia
David Evans

Plan for Today
Why and how to use git
Practice programming pointers (making a List)
24 September 2013 University of Virginia cs4414 1
(Paper) notes for today have some of the
code. Posted notes will have all code.
I won’t be able to hold my usual office hours this
afternoon, but can meet (briefly) after class today and/or
arrange another time.

How (Not) to Manage Files
“Smart Lawyer”
Version Control

Version Control
• How can Alice find the last working version of
her code before she broke everything trying to
fix a little bug?
• How can Alice and Bob work on a program
together?
• How can 10,000 developers work together on
the Linux kernel?
Annual Linux Development Report

Number of
Changes per
Hour
“Since the beginning of
the git era (the 2.6.11
release in 2005), a total
of 9,784 developers have
contributed to the Linux
kernel; those developers
worked for a minimum of
1,064 companies.”

Top Companies

2011-07-21
2013-06-30

http://www.vidarholen.net/contents/wordcount/

Centralized Version Control
Repository
(cvs, subversion)
Alice:
gash> svn checkout
gash> svn update
[make changes]
gash> svn commit
Bob:
gash> svn checkout
gash> svn update
[make changes]
gash> svn commit

Distributed
Version
Control
Main Repository
(git, Mercurial)
[make changes]
Alice’s
Local
Repository
commit
[make changes]
Bob’s
Local
Repository
commitupdate update

Main
Repository
(Hg)
[make changes]
Alice’s
Local
Repository
update,
commit
[make changes]
Bob’s
Local
Repository
update,
commit
Repository
(svn)
[make changes] [make changes]
Centralized: One Repo Distributed

What has to happen
before Bob sees
Alice’s changes?
Main Repository
(Hg)
changed gash.rs
Alice’s
Local
Repository
commit update
Bob’s
Local
Repository
Alice Bob
see gash.rs

git pull = “pull” and “update”
Main Repository
(git)
changed gash.rs
Alice’s
Local
Repository
commit
Bob’s
Local
Repository
Alice Bob
see gash.rs
(I find this asymmetrical
and confusing…but not
many scenarios where
pulling to local without
updating is useful.)
pull is not the analog of push –
it is analog of commit + push

What if Bob had modified his copy?
Main Repository
(git)
changed zhttpto.rs
Alice’s
Local
Repository
commit
Bob’s
Local
Repository
Alice Bob
changed zhttpto.rs
gash> git pull
…
error: Your local changes to the following
files would be overwritten by merge:
ps1/zhttpto.rs
Please, commit your changes or stash
them before you can merge.
Aborting

Okay, let’s commit:
Main Repository
(git)
changed gash.rs
Alice’s
Local
Repository
commit
Bob’s
Local
Repository
Alice Bob
changed gash.rs
gash> git commit -a –m "Added a comment about lack of security."
[master 1347c1f] Fixed the notorious zombie process bug.
1 files changed, 3 insertions(+), 0 deletions(-)
gash> git pull
Auto-merging ps1/zhttpto.rs
CONFLICT (content): Merge conflict in ps1/zhttpto.rs
Automatic merge failed; fix conflicts and then commit the result.

Observing Conflicts
//
// zhttpto.rs
//
// Reference solution for PS1
//
// Special thanks to Kiet Tran for providing code we incorporated into this.
//
<<<<<<< HEAD
// Note: it would be very unwise to run this server on a machine that is
// on the Internet and contains any sensitive files!
=======
// Warning: this is not a secure server!
>>>>>>> faf7829d3ab38459172b622351d68ac1f47bddd0
//
// University of Virginia - cs4414 Fall 2013

Resolving Conflicts (for Luddites)
gash> emacs zhttpto.rs
edit conflicted file manually (removing the <<<< and ====)
gash> git commit -a -m "Updated security message."
[master 1e6e684] Updated security message.
gash> git push
…
To https://github.com/cs4414/Reference-Solutions.git
faf7829..1e6e684 master -> master

Resolving Conflicts (for Moderns)
git mergetool

Avoiding Conflicts
It’s easier to ask
forgiveness than it is to get
permission.
Admiral Grace HopperWith conflicts, it is better to avoid
them than to resolve them!
- pull before you start modifying, and
often while working
- commit early and often, use good
messages
- push whenever you have something
worth sharing (but don’t push junk)
- divide your project into small,
coherent files
- communicate well with your
teammates!

Avoiding Major Conflicts with Teammates
Don’t resolve conflicts
by just undoing others’
work!
At least make sure you
understand it before
replacing their changes
with your own.

What’s more important for getting an
interesting computing job?

Impressive Transcript from
Prestigious Institution
Impressive Code and Record
in Hacker Communities

Linked Lists in Rust

What’s a List?

Linked Lists
A List is an object that is either:
Null (a special value representing empty list)
or a pair whose second part is a List
struct Node {
head : int,
tail : Option<@Node>
}
type List = Option<@Node> ;
Keeping things simple for now!
@ = automatically managed

let p: List =
Some(@Node{head: 1,
tail: Some(@Node{head : 2,
tail: Some(@Node{head: 3,
tail: None})})});
struct Node {
head : int,
}

to_str
struct Node {
head : int,
}

fn to_str(lst: Option<@Node>) -> ~str {
fn elements_to_str(n: @Node) -> ~str {
match (n.tail) {
None => fmt!("%?", n.head),
Some(tail) => fmt!("%?, %s", n.head, elements_to_str(tail))
}
}
match(lst) {
None => ~"Null",
Some(n) => fmt!("[%s]", elements_to_str(n))
}
}

Using Traits
trait ToStr {
fn to_str (&self) -> ~str;
}
(ToStr is part of the core)
Similar to interface in Java (except Rust
traits can include default implementations).

impl ToStr for List {
fn to_str(&self) -> ~str {
fn elements_to_str(n: @Node) -> ~str {
match (n.tail) {
None => fmt!("%?", n.head),
Some(tail) => fmt!("%?, %s", n.head, elements_to_str(tail))
}
}
match(*self) {
None => ~"Null",
Some(n) => fmt!("[%s]", elements_to_str(n))
}
}
}
fn main() {
let lst : List = Some(@Node{head: 1, tail: Some(@Node{head : 2,
tail: Some(@Node{head: 3, tail: None})})});
println(fmt!("%s", lst.to_str()));
}

Using our List (?)
fn main() {
let lst : List =
Some(@Node{head: 1,
tail: Some(@Node{head : 2,
tail: Some(@Node{head: 3, tail: None})})});
println(lst.to_str());
lst.head = 0;
}

Making it mutable
struct Node {
head : int,
}
Since Rust 0.6 – can’t
make struct fields mut
struct Node {
head : int,
tail : Option<@mut Node>
}
type List = Option<@mut Node> ;

fn main() {
let lst : List = Some(@mut Node{head: 1,
tail: Some(@mut Node{head : 2,
tail: Some(@mut Node{head: 3, tail: None})})});
match lst {
None => fail!("Unexpected None!"),
Some(n) => n.head = 0
}
}

Increment All
Write a List method that increments the value of every
element of the list.

Increment All
trait Increment {
fn incr(&self);
}
impl Increment for List {
fn incr(&self) {
let mut current = *self;
loop {
match(current) {
None => break,
Some(node) => { node.head += 1; current = node.tail },
}
}
}
}

Mapping
self.mapr(|x: int| { x + 1 })
Define a higher-order
mapr method that
applies a function to all
elements in a List.

impl Map for List {
fn mapr(&self, f: &fn(int) -> int) {
let mut current = *self;
loop {
match(current) {
None => break,
Some(node) => { node.head = f(node.head);
current = node.tail },
}
}
}
}

Don’t we want to avoid @?

struct Node {
head : int,
tail : Option<~Node>
}
type List = Option<~Node> ;
What else needs to change to make a List with owned Nodes?

struct Node {
head : int,
}
trait Map {
fn mapr(&self, &fn(int) -> int)
}
-> List;

struct Node {
head : int,
}
trait Map {
fn mapr(&self, &fn(int) -> int) -> List;
}
impl Map for List {
fn mapr(&self, f: &fn(int) -> int) -> List {
match(*self) {
None => None,
Some(ref node) => { Some(~Node{ head: f(node.head),
tail: node.tail.mapr(f) }) },
}
}
} Is this better or worse than the @mut version?

Next class: making map
multi-threaded!
Read the MapReduce paper
(or at least the slides) before
Thursday’s class
Posted notes (later today) will have all code.
I won’t be able to hold my usual
office hours this afternoon, but
can meet after class today
and/or arrange another time.

Using Git, Pointers in Rust

More Related Content

What's hot

Viewers also liked

Similar to Using Git, Pointers in Rust

More from David Evans

Recently uploaded

Using Git, Pointers in Rust

Editor's Notes