Background

• This lab is about racket, with some wrap-up of the discussion on git.
• We'll mainly follow Quick: An introduction to Racket with Pictures
• You should be familiar with the fcs-cs2613-dev VM from Lab 1.
• For more detail on the topics covered here we will refer to the Racket Guide, mainly chapter 2.
• We will also refer to specific sections of the Racket Reference in particular
  • printing output.
• For a concise guide to lists and recursion, see Beautiful Racket on Lists

Part 0: Git Tutorial Part II: Working with multiple repos

For this part of the lab, form pairs. If there's an odd number of people, form a triple.

Cloning

Each person in the pair should carry out the following actions at neighbouring computers.

1. Open a terminal on the FCS Linux session (i.e. not in the fcs-cs2613-dev VM). Make a directory lab1-scratch somewhere outside the cs2613 git repository you created earlier.

2. Now move to the lab1-scratch directory, and make a clone of the central repo.

    $ git clone https://<username>@vcs.cs.unb.ca/git/cs2613-<username> cs2613-clone
   

   This creates a new directory "cs2613-clone" containing a clone of your repository. Notice that in general this is a good way of checking that your work is properly submitted. The TA and Prof will do exactly this cloning step in order to mark your work. The clone is on an equal footing with the original project, possessing its own copy of the original project’s history.

Viewing project history

1. At any point you can view the history of your changes using

    $ git log
   

   Use this command to verify that all the changes you expected to be pushed to the server really were.

   If you also want to see complete diffs at each step, use

    $ git log -p
   

   Often the overview of the changes is useful to get a feel for each step

    $ git log --stat --summary
   

2. Temporarily trade computers with your partner. Use git log to examine the history of their repo. Consider their commit messages, and the construction of their commits (i.e. what changes are commited together). Discuss how each of your might improve your history, if possibly by learning from the other.

Sharing changes with a central repo

For the remainder of Part 0, work together on one computer.

1. Switch to (or open) a terminal in the fcs-cs2613-dev VM.

2. Navigate to the ~/fcshome/lab1-scratch/cs2613-clone/frog directory.

3. create a new blog entry, and commit it.

4. Push your changes back to the central repository.

    $ git push origin master
   

5. Change directory to your original directory ~/fcshome/cs2613. Bring in the changes you made

    $ git pull origin
   

This merges the changes from the central copy of "master" branch into the current. branch. If you made other changes in the meantime, then you may need to manually fix any conflicts.

The "pull" command thus performs two operations: it fetches changes from a remote branch, then merges them into the current branch.

Git next steps

Congratulations, you now know enough git to finish this course.

There is lots more to learn, particularly about branching and collaboration. If you want to get a big(ger) picture view, a good place to start is Git Concepts Simplified.

Part 1: Hello World

1.1 Command Line

• Form into groups of 2-3 students (if you like, you can stay in the groups from Part 0).

• Start the fcs-cs2613-dev VM, and start a terminal

• change to examples/racket.

• run the program with

    $ racket hello.rkt
  

• There's a kindof obvious bug. Figure how to fix the bug. There's a few options.

1.2 DrRacket: A Racket Specific IDE

• Start DrRacket from the activities menu

• Referring to the DrRacket documentation as needed, open and run the hello.rkt program from the previous part.

1.3 If you have extra time

Byte compilation

• use the time command

    $ time racket hello.rkt
  

• Now compile the code with

    $ raco make hello.rkt
  

• Time it again. What do you observe?

more IDE stuff

• run hello.rkt the program under the debugger in DrRacket
• figure out how to run a racket program in code-oss

1.4 Discussion

• For those familiar with other IDEs, what's similar and what's different about this one?
• What's the difference between a text editor and an IDE?
• What's a REPL?

Part 2: Squaring the Circle.

• Do this part on your own.

• Follow steps 2-5 of the Quick Tutorial

• Make note of the main new concepts encountered for your journal.

• If you have extra time

  • figure out how to have a default argument of 10 to square, i.e. (square) should be equivalent to (square 10)

---

Part 3: Functions, Scope, and Lists

• Do this part on your own.

• Follow steps 7-9 of the Quick Tutorial

• Make note of the main new concepts encountered for your journal.

• If you have extra time

  • start reading Section 2.3 of the Racket Guide
  • read Assignment 1

Part 4: More about lists

• Reference for this part of the lab is Beautiful racket lists explainer and Section 2.3 of the Racket Guide

• Form groups of 2 or 3 people

• Rewrite the rainbow example to use explicit recursion (i.e. calling first and rest), rather calling than map.

  • Make an auxilary function color-mapper that takes two parameters p and color-list and calls (colorize p color) for each element color of color-list.
  • Your function can steal the structure of my-map but you shouldn't call map or my-map
• If you have extra time, repeat the exercise with for/list instead of first and rest.