Add README and a few comments

Author: derekchiang

README.md

@@ -0,0 +1,9 @@
+# Intro to Rust
+
+These are the code examples I used in the March 9 talk at OSC.  They are intended to show how the Rust compiler rejects memory-related bugs that are typically uncaught in other languages.  Here is a breakdown of the examples:
+
+* `lifetime.cpp` demonstrates a perfectly valid C++ program that uses an invalid pointer.  `lifetime.rs` is the equivalent Rust code that is rejected by the compiler.
+* `ownership.cpp` demonstrates a perfectly valid C++ program that makes use of deallocated memory.  `ownership.rs` is the equivalent Rust code that is rejected by the compiler.
+* `concurrency.cpp` demonstrates a perfectly valid C++ program that contains a data race.  `concurrency.rs` is the equivalent Rust code that is rejected by the compiler.  A valid version of the Rust code is commented out in `concurrency.rs`
+
+Note that the examples are necessarily contrived.

concurrency.cpp

@@ -9,10 +9,11 @@ int main() {
     int acc = 0;
 
     vector<thread> threads;
+    // create 10 threads
     for (int i = 0; i < 10; i++) {
         threads.push_back(thread([&]() {
             for (int j = 0; j < 100000; j++) {
-                acc++;
+                acc++;  // data race happens here; acc is not synchronized
             }
         }));
     }

concurrency.rs

@@ -18,6 +18,7 @@ fn main() {
     println!("{}", acc);
 }
 
+// Following is the correct, valid code
 
 // use std::thread;
 // use std::sync::{Arc,Mutex};

lifetime.cpp

@@ -6,10 +6,11 @@ using namespace std;
 int main() {
     string *ptr;
     {
-        string s;
+        string s;  // s is allocated here
         s = "Hello world!";
         cout << s << endl;
         ptr = &s;
+        // s is destroyed here
     }
     cout << *ptr << endl;
 }

lifetime.rs

@@ -1,8 +1,9 @@
 fn main() {
     let ptr = {
-        let s = "Hello world!".to_string();
+        let s = "Hello world!".to_string();  // lifetime of s starts here
         println!("{}", s);
         &s
+        // lifetime of s ends here
     };
-    println!("{}", ptr);
+    println!("{}", *ptr);  // &s is used here
 }

ownership.cpp

@@ -2,10 +2,12 @@
 #include <vector>
 #include <string>
 
+using namespace std;
+
 int main() {
-    std::vector<std::string> v;
+    vector<string> v;  // the first owner
     v.push_back("Hello");
-    std::string& x = v[0];
-    v.push_back("world");
-    std::cout << x;
+    string& x = v[0];  // the second owner
+    v.push_back("world");  // the first owner frees the underlying memory
+    cout << x;  // the second owner uses the freed (invalid) memory
 }

ownership.rs

@@ -1,7 +1,7 @@
 fn main() {
-    let mut v = vec![];
+    let mut v = vec![];  // v owns the vector
     v.push("Hello");
-    let x = &v[0];
-    v.push("world");
+    let x = &v[0];  // x borrows the vector
+    v.push("world");  // v tries to modify the vector
     println!("{}", x);
 }