Reading 00: Slack, GitHub, Student Machines

Everyone:

Welcome to CSE 20289 Systems Programming, which (as the syllabus states) is a course that "introduces students to the Unix programming environment where they will explore various command line utilities, files, processes, memory management, system calls, data structures, networking, and concurrency". What this means is that you will first learn how to effectively utilize a modern Unix programming environment and then you will study how to develop applications that take advantage of system level abstractions such as files, processes, and sockets.

Course Overview¶

Last semester, most of you took the CSE 20311 Fundamentals of Computing course where you learned how to program in the C language. After playing the Game of Life, generating anagrams, and building fractals, you should be capable of programming in a compiled language using conditional statements, loops, and functions. Moreover, you should be somewhat familiar with strings, arrays, and those crazy pointers.

In this course, we will build on this foundational knowledge by exploring the Unix programming environment in order to get a better idea of how a computer works and how to build applications that utilize different aspects of conventional computing systems. The semester can be broken down into the following units:

1. Unit 01: Bourne Shell

   First, we will begin by learning how to utilize the Unix shell and then how to compose multiple Unix utilities into pipelines and shell scripts while taking advantage of regular expressions.

2. Unit 02: Python

   Next, we will explore processing and manipulating data using Python. Along the way, we will discuss how to exploit the functional programming paradigm to efficiently perform parallel computing.

3. Unit 03: C

   Finally, we will descend down the software stack to C and discuss memory management as well as revisiting pointers, arrays, strings, and studying some data structures. We will then build our own Unix applications that take advantage of system level abstractions such as files and sockets through the use of system calls. All of this exploration will culminate in a multi-core HTTP client.

Moreover, throughout the course, we will frequently reflect on the wisdom and power of the Unix Philosophy:

1. Write programs that do one thing and do it well.

2. Write programs to work together.

3. Write programs to handle text streams, because that is a universal interface.

Each week there will be a Reading assignment meant to give you a context and reference into what we will be covering that upcoming week and a Homework assignment that will provide you an opportunity apply the material in (hopefully) interesting ways. Of course, there are three exams to assess your mastery of the material.

Readings¶

The readings for Wednesday, January 17 are:

1. The Linux Command Line

   • Chapter 1 - What is the Shell?
   • Chapter 2 - Navigation
   • Chapter 3 - Exploring the System
   • Chapter 4 - Manipulating Files and Directories

   • Chapter 5 - Working With Commands
     

2. Git Handbook

3. A beginner's guide to Git version control

The focus of the readings is to review the basics of using the Unix shell, which most of you used in CSE 20311 Fundamentals of Computing last semester, and to introduce you to Git, which we will be using throughout the semester.

In addition to reading the above readings and videos, it is recommended that you work through the following tutorials:

1. Command Line Crash Course

   This is a tutorial on using the command line interface on various operating systems (you should focus on the Unix shell).

2. Learn Git Branching

   This is an interactive tutorial on branching in Git.

Additional Resources¶

The following are additional resources that you may find useful:

Unix Shell¶

• A Linux Command Line Primer

• Learning the Shell

• Survival guide for Unix newbies

Git¶

• gittutorial

• Git Tutorial

• Pro Git

Tasks¶

Normally, you would have quiz to complete after each reading. For this initial reading, however, you only need do the following:

1. Join the class Slack channel.

2. Create your own private assignments Git repository on GitHub.

3. Clone your private assignments Git repository to your local computer or a student machine.

Task 1: Slack¶

For communication outside of our classroom, we will be using Slack, which is a real-time chat platform similar to Discord. Your first task is to create a ND-CSE Slack account (if you have not done so already) and join the #cse-20289-sp24 channel:

https://nd-cse.slack.com/messages/cse-20289-sp24/

Task 2: GitHub¶

All of your work in this class will be submitted to GitHub using git. Your second task is to setup your GitHub assignments repository by doing the following:

1. Sign-in or create a GitHub account if you do not already have one.

   https://github.com/join

   You may associate this account with either your Notre Dame or personal email address. It is up to you.

2. Fork the class assignments repository from the following template:

   https://classroom.github.com/a/OeaidyLn

   This will create a private cse-20289-sp24-assignments-$USERNAME repository under your own account and linked to the nd-cse-20289-sp24 organization.

Task 3: Student Machines¶

While you are free to use any machine you wish to do your work, the department provides a set of student machines that you can login to and do remote work in an environment crafted for the course. The following steps allow you to clone the assigments you just created to any machine of your choosing.

1. Before you can clone your git repository, you will need to determine which form of authentication, you wish to use with GitHub.

   Note, that GitHub has recently shutdown password authentication.

   To remotely access your repository from the command-line, you have two options:

   1. Setup a Personal Access Token: With this method, GitHub will generate an application specific passsword that you can use with HTTPS. As the PAT is a long string of characters, it is recommended that you use it in conjunction with a password manager or keyring.

   2. Setup SSH Keys: With this method, you generate a local public and private key pair on your computer and then upload the public key to GitHub. When accessing GitHub from the command-line, you will use the private key to authenticate to the server.

      This is the recommended way to setup your repository as it will allow for passwordless access.

   Setup SSH Keys¶

   Note: If you have already Setup SSH Keys in another course (such as Data Structures), you do not need to make new keys and can skip this process.

   Here is a quick tutorial on how to Setup SSH Keys on the student machines (if you have not already):

   1. Generate SSH keys if you don't have them yet:

      # Accept the defaults, don't make a password if you want to go passwordless
      $ ssh-keygen
      

   2. Copy the contents of ~/.ssh/id_rsa.pub to the SSH Keys section of your GitHub settings page:

      https://github.com/settings/keys

      # Copy and paste the contents of this file into GitHub
      $ cat ~/.ssh/id_rsa.pub
      

   3. Edit/create ~/.ssh/config to use this key with GitHub:

      # Add the following to your config (replace $NETID with your netid)
      $ vim ~/.ssh/config
      Host github.com
              User git
              Hostname github.com
              PreferredAuthentications publickey
              IdentityFile /escnfs/home/$NETID/.ssh/id_rsa
      

   Once this is done, you should be able to do git operations without a password. You will need to accept the host key the first time by typing in "yes".

   Text Editor¶

   Any time you see references to vim in example commands, remember that you can use any text editor such as nano or emacs instead.

2. Clone your git repository to your local machine (or the student machines):

   # Example of cloning GitHub assignments repository to local or student machine
   $ git clone git@github.com:nd-cse-20289-sp24/cse-20289-sp24-assignments-$USERNAME.git
   remote: Enumerating objects: 70, done.
   remote: Counting objects: 100% (70/70), done.
   remote: Compressing objects: 100% (13/13), done.
   Receiving objects: 100% (70/70), 6.25 KiB | 1.56 MiB/s, done.
   Resolving deltas: 100% (4/4), done.
   remote: Total 70 (delta 4), reused 70 (delta 4), pack-reused 0
   

3. Edit the README.md file in your assignments repository such that the Name and NetID fields are completed (i.e. replace "Domer McDomerson" and "dmcdomer"). You should commit your change and then push them to GitHub.

   # Example on editing README in assignments repository and pushing changes to GitHub
   
   $ cd cse-20289-sp24-assignments-$USERNAME   # Go into the assignments directory
   
   $ nano README.md                            # Edit the README.md file
   
   $ git add README.md                         # Mark the file for recording
   
   $ git commit -m "Update README"             # Record the change
   [master c550fa1] Update README
   1 file changed, 2 insertions(+), 2 deletions(-)
   
   $ git push                                  # Send your local changes to GitHub
   

The following is a video demonstration of the process of cloning your GitHub repository and committing your first change.