• Unix editors (vim, emacs, nano), Appendix 2 of Dive into Systems
• to learn vim (and vi), run vimtutor
• The CS Deptment's Vim Tips and Tricks checkout Vi reformatting awesomeness
• Vi Quick Reference
• Using vi
• vi reference card
• Vi Lovers Home Page
• The VIM (Vi IMproved) Home Page
• Unix is a Four Letter Word... and Vi is a Two Letter Abbreviation by Christopher Taylor, a Unix and vi guide
• Emacs Commands

tools for creating documents:

• latex: Unix's Word Processing Software.

  I have example latex documents for producing slides and papers that show examples of importing image files, using bibtex and using latex's math mode. You can grab a copy and use it as a starting point for your document. Look in my public directory (start with the README file):
  /home/newhall/public/latex_examples/ In the paper subdirectory is an starting point for a CS research paper or thesis that uses bibtex. It describes how to organize CS technical papers and it shows many examples of latex formating:

    cp -r /home/newhall/public/latex_examples/paper/* .
    cd paper
    cat README
    make
  

  Here are some other latex and bibtex links:
  some latex info written for Swarthmore students
  a latex tutorial
  Wikibooks Latex pages
  www.latex-project.org
  www.bibtex.org
  ShareLaTeX's latex documentation

• openoffice: an application for creating and editing .doc, .ppt, and .xls files. You can veiw Windows documents in openoffice, and save files in Windows or OpenOffice formats. Its interface is similar to that of Microsoft Word, Excel and Powerpoint. To run:

  libreoffice               # create a new file
  libreoffice file.doc      # edit an existing one
  

  tools for drawing figures:

• xfig and gimp: for drawing figures that can be saved in postscript, gif, jpeg, and other formats and incorporated into webpages, latex documents, etc.
• openoffice may also be useful for this

  tools for creating graphs:

• gnuplot another graph/plotting application
  I have examples in: /home/newhall/public/gnuplot_examples
  a gnuplot tutorial: A gnuplot tutorial
  some demo scripts for creating all different types of plots: gnuplot demo scripts
• xgraph create line and bar graphs. Some examples: /home/newhall/public/xgraph_examples
• The pylab Python library can be used to create graphs.
  I have a simple example here: /home/newhall/public/pylab

  tools for capturing windows and editing images:

• gimp can be used to capture the contents of a window to a file.
  1. start gimp
  2. choose File:Create:screenshot
  3. make sure the window you want to capture is not overlapped by any other windows
  4. in the Screenshot window, you can select or unselect "include window decoration", and then click on the Snap button
  5. click on the window you want to take its screen shot and it will appear in the Gimp window. In Gimp you can resize and crop using the Image and Tools menus.
  6. once you have edited the figure in Gimp, choose File:SaveAs, and add the extention to the file name of the format in which you want Gimp to save it (filename.jpg for JPEG, filename.gif for GIF,...)
• xwd (X Window Dump) can also be used to capture window contents to an image file.

  xwd > outfile.xwd	# then click on window to capture in outfile.xwd
  

  You can convert xwd format to other formats using gimp or the unix command line utilites. For example, here I'm converting it to jpeg by first converting to pnm and then to pnm:

  xwdtopnm outfile.xwd > outfile.pnm 
  pnmtojpeg outfile.pnm > outfile.jpeg
  

  converting between image formats:

• gimp is useful for editing figures in many formats and converting from one format to another (jpg, gif, bitmap, etc)
• There are also many unix utilities to convert a file to another format. They are in files named (format1toformat2 or format12format2). For example, ps2pdf converts a postscript file to a pdf file. Some of these (the to ones) require that you redirect the converted form output to an output file, others (the 2 ones) automatically create the new file of the converted format. For example:

  # pnmtopng requires explicit output re-direction to a file
  pnmtopng fig1.ppm  > fig1.png
  
  # ps2pdf does not (it will create fig2.pdf):
  ps2pdf fig2.ps 
  

• Using revison control software: git, subversion, CVS and RCS
  and my git guide written for students using git for CS labs/projects

  
  the CS department CS Dept git guide for students using git and the Swarthmore GitHub Enterprise for CS labs/projects

• Setting File Permissions to Share with Specific Users ACLs and group file permissions

• I have some example bash scripts that may be useful starting points for writing your own scripts to run experiments. Copy over this directory:

    cp -r ~newhall/public/bashscript_examples .
  	

  See the README file for a description of what each demostrates.

• Intro to Shell Programming from Dive into Systems
• Bash Shell Programming
• Advanced Bash Scripting
• Bourne Shell Programming by Robert P. Sayle

• use screen (or tmux) for long running experiments These tools let you log into a machine, and run things inside a screen or tmux session that you detach from and then you can log out (your tmux or screen session are still running and you can login and reattach later to see the progress of your experiements).
  • using screen:
    1. In any window, type screen to start a screen session. The window will clear, and you will get a shell prompt
    2. Run your program (or run script).
    3. Type Ctrl-a d (control-a, then the d key) to detach. At this point you can log out and your program keeps running.
    4. To reattach to a screen session, log into the same machine (or in a different window on the machine running the screen session), type screen -r.
    5. When done with a screen session, just type exit.

  • tmux is similar to screen, but it allows you to create multiple windows and multi-paned windows in a single tmux session. This is nice for an editing window(s) and a compiling window. The CS department help pages has some information for using tmux: tmux help written for Swarthmore students.

    tmux cheatsheet
    tmux shortcuts

    Here is a simple script for setting up a tmux session with three panes:

    #!/bin/bash
    # This is an example shell script for creating 
    # and attaching to a tmux session
    # you can call with a command line argument for the 
    # name of session or not:
    #  ./mytux cs44      # create tux session named cs44
    #  ./mytux           # create tux session named mySession 
    #
    if [ $# -gt 0 ] ; then  
      Name=$1
    else
      Name="mySession"
    fi
    tmux new-session -s $Name -d
    tmux split-window -h
    tmux resize-pane -L -x 80
    tmux resize-pane -R -x 40
    tmux split-window -v
    tmux -2 attach-session -d -t $Name
    

  When using screen and tmux, be careful about not leaving a lot of old screen and tmux sessions of yours running on lab machines. If you ssh into a particular machine each time you run tmux or screen (ssh you@machinename.cs.swarthmore.edu), that is one way to avoid leaving one running on a machine that you forget about. You can get cs machine names from the cs machines page.

• Write and use scripts. If you have a lot of experiements to run, write a bash, or perl, or python, or ..., script to run the set of experiements and save the results to files (one way to do this is to use script to capture console ouput to to a file). You can also write scripts to setup your experiemental environment, and to process large experiment ouput files and create input files for xgraph, gnuplot, etc. (pythong, perl or awk are more useful than bash for file processing). By using scripts, you take the time to write the script once, but you can easily run the script over and over.
  bash shell programming links.

• script and dos2unix to capture a terminal session to a file.

• cron You can add a cron job to run command (a run.sh script for example) at a particular date and time by editing the crontab file (crontab -e) on the machine on which you want to run experiments. Here is a very simple example:

  $ crontab -e
  
    # sytax:
    # min hour day month day-of-week  command 
  
    # run my killmytests.sh script at 8pm (20:00), on January (1) 31:
    0 20 31 1 * /home/me/cs31/killmytests.sh
  
    # run my run.sh script at 4:15 am on February 13 
    15 4 13 2 * /home/me/cs31/run.sh 
  

  see the man page for cron and crontab for more information

• CS project etiquette page information about using nice, screen, and where to find disk space for huge files.

• Using Condor on our system

• time will measure the total runtime of the a.out program, and will give the breakdown of user and system time. For example, the following call to time ./myprog says that my program took 10.083 seconds to run, 0.000 seconds (less than 1 ms) of user-level CPU time and 0.004 seconds of system-level CPU time (my program was sleeping and not scheduled on the cpu for most of its 10 second runtime):

  % time ./myprog
  real    0m10.083s
  user    0m0.000s
  sys     0m0.004s
  
  # here is time for a cpu-bound program.  you can see almost all of its 
  # 7.931 seconds of execution time were due to user-level cpu time
  %time ./a.out
  real    0m7.931s
  user    0m7.928s
  sys     0m0.000s
  

• /proc: /proc is a pseudo file system that provides a file interface to the operating system. Through /proc you can get information about system-wide resource usage and about individual processes running on the system. For example, cat'ing out the /proc files meminfo, swapinfo, loadavg, will give you information about a machine's memory usage, about its swap space usage, and about its cpu load averages. See the man page for proc for more information (man 5 proc).
• gettimeofday: you can add timing calls to sections of code directly. In C, you can call the gettimeofday function around code you want to time. Be careful about not timing code fragments with debug output, because the debug output can distort the real time of the code fragment you are measuring.
• gprof is a profiler for C and fortran programs. To compile, use the -p option:

  % gcc -g -p -o myprog foo.c
  

  when you run your program, a file named gmon.out is created that contains profiling information of the run of your program. You can view this file by running gprof (see the man page for gprof for more information):

  % ./myprog
  % gprof myprog gmon.out 
  

• Valgrind tools valgrind has a set of performance tools including thread race detection, call graph, cache and heap profilers. Documentation for the tools is here: valgrind tools documentation

• ntop.org a tool for network traffic measurement
• Paradyn a performance tool for parallel programs

• Introduction to C programming for CS31 Students Part 1: variables, I/O, branching, loops, functions, arrays, strings
• Introduction to C programming for CS31 Students Part 2: structs, pointers, "pass by reference", dynamic memory allocation (malloc, free)

• char in C ascii, ctype.h functions
• strings in C string.h and stdlib.h functions
• file I/O in C stdio.h functions
• pointers in C including pass by reference
• arrays in C
• command line arguments in C (and C++)
• linked lists in C
• binary search trees in C

• Building and Linking Libraries in C (or C++)
• The C compilation cycle and tools to examine .o, a.out, .so files, nm, objdump, gdb, ldd, readelf, strings, hexedit, ...
• Some Cool C libraries: readline for reading in user input, getopt for parsing command line options, ncurses a terminal-independent library for text based user interfaces (and ascii escape codes for an easier way to do some of this functionality)

C Tutorials and Language References:

Some Other Assembly Languages:

cat /proc/meminfo             # list total and free memory (RAM) in system and how it is allocated/used
cat /proc/iomem               # lists expanses of RAM addresses and what is mapped in there
                              # (note extents for mem mapped drivers, and Kernel memory space)

(an older reference for using QEMU for OS course projects)

Sockets, http:

MPI and PVM:

GPU computing:

Parallel Algorithms: