Add c4s1

Author: tomclose

_sessions/c4s1/1_motivating_functions.md

@@ -0,0 +1,53 @@
+---
+title: Improving code
+---
+
+This session we're going to be looking at ways to improve the code you write. In particular, we're going to see how to use *functions* to begin to separate out program logic into reusable chunks.
+
+### Why do we need functions?
+
+Take a look at this bit of code taken from a sinatra app:
+
+{% highlight ruby %}
+@swimmer_first_name   = @swimmer[:name].split.first
+@swimmer_last_name    = @swimmer[:name].split.last
+@swimmer_dob          = @swimmer[:dob]
+
+@cyclist_first_name   = @cyclist[:name].split.first
+@cyclist_last_name    = @cyclist[:name].split.last
+@cyclist_dob          = @cyclist[:dob]
+
+@runner_first_name    = @runner[:name].split.first
+@runner_last_name     = @runner[:name].split.last
+@runner_dob           = @runner[:dob]
+{% endhighlight %}
+
+This code contains a lot of repetition. Some of the repetition might be unavoidable: we might really need to set up all those different instance variables to share with a view. Other bits aren't and will cause us problems in the long run.
+
+The duplication of the logic for extracting the first and last name is particularly problematic:
+
+* If we wanted to change the way a last name was extracted from a name (e.g to take into account names like 'Pierre de Fermat') we'd have to make changes in three places.
+* The code is also cluttered and harder to make sense of than it needs to be: each time you read `.split.first` your brain has to convert that into 'find the first name'. As a programmer you will spend more time reading code than writing it, so these considerations are important.
+
+A nicer way to write this code would be to use `first_name` and `last_name` functions, that contain the logic for splitting up the name:
+
+{% highlight ruby %}
+@swimmer_first_name   = first_name(@swimmer[:name])
+@swimmer_last_name    = last_name(@swimmer[:name])
+@swimmer_dob          = @swimmer[:dob]
+
+@cyclist_first_name   = first_name(@cyclist[:name])
+@cyclist_last_name    = last_name(@cyclist[:name])
+@cyclist_dob          = @cyclist[:dob]
+
+@runner_first_name    = first_name(@runner[:name])
+@runner_last_name     = last_name(@runner[:name])
+@runner_dob           = @runner[:dob]
+{% endhighlight %}
+
+{% exercise %}
+1. Clone down the sinatra app for this session: [https://github.com/code61/sinatra_c4s1](https://github.com/code61/sinatra_c4s1).
+2. Install the required libraries: `cd sinatra_c4s1` and then `bundle install`.
+2. Familiarise yourself with the app, by looking through the code and running the app from the command line (`ruby app.rb`).
+3. See if you can identify other places where logic could be cleaned up.
+{% endexercise %}

_sessions/c4s1/2_functions.md

@@ -0,0 +1,41 @@
+---
+title: Functions
+---
+
+A *function* (or *method*) is a way of separating out a piece of programming logic so that you can use it elsewhere.
+
+### Defining and calling a function
+
+There are two steps in using a function
+
+1. *Define* the function: to define a function you need to give it a name and write the code contained in the function.
+2. *Call* the function: when you use the function, we say that the function is being 'called'. Calling a function causes the code inside it to be run.
+
+{% highlight ruby %}
+def first_name(full_name)
+  full_name.split.first
+end
+
+first_name('Tom Close') #=> 'Tom'
+first_name('Ashok Menon') #=> 'Ashok'
+{% endhighlight %}
+
+In the example above the function takes a single *parameter* (in this case the full name that you want to split up).
+
+* When you call the function you give it the full name (e.g. `"Tom Close"`) as a string.
+* The the variable `full_name`, that you specified in the function definition, is set to the name you provided. In this case this is equivalent to `full_name = "Tom Close"`.
+* The statements inside the function body are then executed.
+* The function *returns* the value of the last expression to be evaluated.
+
+{% exercise %}
+1. **Fork** and clone down the exercises for this session: [https://github.com/code61/exercises_c4s1](https://github.com/code61/exercises_c4s1)
+2. Install the gems you need - in the `exercises_c4s1` folder, run: `bundle install`
+3. Open `names.rb` in sublime text.
+4. Using the code above fill out the `first_name` function.
+5. Open `irb` and load in the file by running `load 'names.rb'`.
+6. Try the function out, by calling it in irb.
+7. Close `irb` and run the tests we've provided for the function by running `rspec spec/first_name_spec.rb`.
+8. Now try and write the body of the `last_name` function. Follow the same procedure of trying in irb, then running the test `rspec spec/last_name_spec.rb`.
+9. (Ext) Improve your `last_name` function, so that it can cope with composite last names (treating everything after the first name as the last name). Test your solution by running `rspec spec/ext_last_name_spec.rb`
+10. (Ext) Work through the functions in `date.rb`. Test your solutions running the tests in files `spec/month_spec.rb`, `spec/last_digit_spec.rb`, `spec/penultimate_digit_spec.rb`, `spec/ordinal_suffix_spec.rb` and `spec/date_in_words_spec.rb`.
+{% endexercise %}

_sessions/c4s1/3_multiple_arguments.md

@@ -0,0 +1,72 @@
+---
+title: More about arguments
+---
+
+So far we've only looked at functions with a single argument. What if we want to have no parameters, multiple parameters or a variable number?
+
+### Functions with no parameters
+
+It is sometimes useful to have a function with no parameters, often for a task that you need to perform repetitively:
+
+{% highlight ruby %}
+require 'csv'
+
+def load_data
+  # read data in from the csv file
+  data = CSV.read('tmp/students/data.csv')
+
+  # remove the header row
+  data[1..-1]
+end
+{% endhighlight %}
+
+When you call a function with no parameters, you don't need to use brackets:
+
+{% highlight ruby %}
+
+load_data #=> [[..], [..], [..], ...]
+
+{% endhighlight %}
+
+<p class='small'>[In fact you don't need brackets when you're calling a function with arguments either. For the time being we'll use them though, to keep things simple.]</p>
+
+### Functions with multiple parameters
+
+Defining and calling a function with multiple parameters is just like defining and calling one with a single parameter:
+
+{% highlight ruby %}
+def insult(word, strength)
+  "#{word.capitalize} off" + '!' * strength
+end
+
+insult('goose', 4) #=> "Goose off!!!!"
+{% endhighlight %}
+
+When you call a function with multiple parameters, you need to make sure you provide the right number, otherwise you'll get an error.
+
+{% highlight ruby %}
+insult('badger', 4, 5)
+#=> ArgumentError: wrong number of arguments (3 for 2)
+#=> from (pry):2:in `insult'
+{% endhighlight %}
+
+### Functions with optional parameters
+
+Sometimes it's useful to be able to supply a parameter if you want, but use a sensible default otherwise:
+
+{% highlight ruby %}
+def i_love(thing = 'ruby')
+  "I love #{thing}!"
+end
+
+i_love('coding') #=> "I love coding!"
+i_love           #=> "I love ruby!"
+{% endhighlight %}
+
+{% exercise %}
+1. Open `more_functions.rb` and begin to work your way throught the functions in the file.
+2. For each function you write, reload the file into irb to try it out: `load 'more_functions.rb'` (run this **inside** `irb`).
+3. For each function you write, run the appropriate test e.g.: `rspec spec/multiply_and_sum_spec.rb` (run this **outside** `irb`, on the command line).
+4. If you get onto the `describe_result` function, you will need to start by writing your own test in `spec/describe_result_spec.rb`. (Do this by copying and pasting from another test, and make the appropriate changes.)
+{% endexercise %}
+{% endexercise %}

_sessions/c4s1/4_refactor_example.md

@@ -0,0 +1,14 @@
+---
+title: Refactoring
+---
+
+**Refactoring** is the act of restructuring a piece of code **without changing its behaviour**. Refactoring is very important in software development, as without it software projects quickly become unweildy and difficulat to work with.
+
+You're going to refactor the sinatra app, by completing the functions in the `helper_functions.rb` file.
+
+{% exercise %}
+1. Open `app.rb` in Sublime Text.
+2. Uncomment the commented out `post` block at the bottom, and comment out the other one. This is how we want the code to look, but currently the functions aren't there to make this work.
+3. Uncomment the line `require './helper_functions'` at the top of `app.rb`
+3. Open the file `helper_functions.rb` in Sublime Text. Complete the functions so that the app works as before.
+{% endexercise %}

_sessions/c4s1/5_homework.md

@@ -0,0 +1,8 @@
+---
+title: Homework
+---
+
+{% exercise %}
+1. Finish off any exercises from class.
+2. Do the [Codecademy Ruby track](http://www.codecademy.com/tracks/ruby) Sections 9 and 10.
+{% endexercise %}

course3.md

@@ -39,45 +39,3 @@ layout: default
 - [Session 4](c3s4)
   + sending emails?
   + Hashes
-
-
-- [Session 1](c4s1)
-  + functions
-  + lots of exercises with tests
-  + [hwk] refactor a sinatra app
-- [Session 2](c4s2)
-  + more functions
-- [Session 3](c4s3)
-  + mongodb/classes
-- [Session 4](c4s4)
-  + CRUD app
-
-
-name can be a variable, a Constant, (an @instance variable, a @@class variable, $global)
-http://rubylearning.com/satishtalim/ruby_names.html
-
-adding numbers 
-string interpolation
-
-(methods puts)
-
-sinatra: returns last expression in the block to the web browser, url matching, getting param from url, string interpolation
-deploying?
-
-SESSION2
-
-conditionals
-sinatra templates? (only showing values)
-form submissions? (with validations?) - example of a function??
-FOAAS ?? / text-based game
-
-SESSION3
-
-collections & iterating
-providing the contents of a file?
-similar to sinatra3?
-
-SESSION4
-
-hashes - explaining params, 
-building an api?

course4.md

@@ -11,10 +11,12 @@ layout: default
 - [Preparation](c4prep)
 
 - [Session 1](c4s1)
-
+  + functions: defining, calling
+  + lots of exercises with tests
+  + [hwk] refactor a sinatra app
 - [Session 2](c4s2)
-
+  + more functions
 - [Session 3](c4s3)
-
+  + mongodb/classes
 - [Session 4](c4s4)
-
+  + CRUD app