I/Octopus

Infinite Sequences and Series Cheat Sheet

2013-05-11T17:37:00Z

Throughout my time tutoring Calculus II, I have found that oftentimes people have a hard time remembering all the series tests, so I put together this cheat sheet last year.

It contains all of the series tests, not including power series, that are covered in Chapter 12 of Stewart Calculus, 6th ed. Additionally, important definitions are included.

Most people will want the pdf: series.pdf but the source is also availble for modification: series.tex

Connecting to the UWPlatt network

2013-03-07T18:30:00Z

Connecting to the UWPlatt wireless network, a network on my university's campus, can be tricky. Below is a snippet from my /etc/wpa_supplicant/wpa_supplicant.conf. Be sure to replace your_netid_username and your_password with your actual username and password.

network={
        ssid="UWPlatt"
        priority=6
        proto=RSN
        pairwise=CCMP
        group=CCMP
        key_mgmt=WPA-EAP
        eap=PEAP
        identity="your_netid_username"
        anonymous_identity="anon"
        password="your_password"
        phase2="auth=MSCHAPv2"
}

Clojure/ClojureScript Notes

2013-02-11T23:58:00Z

These notes document an ongoing project and are not yet complete.

Useful links

Install Log

It was recommend that I use a build system called Leiningen to manage Clojure compilation.

Downloaded the lein script to my scripts folder (which has execute permissions).
Wow. That was easy. Now running lein repl form anywhere starts a repl that appears to work.

# I dont think that the following steps were necessary. # - Now to install ClojureScript: # - git clone git://github.com/clojure/clojurescript.git # - cd ./clojurescript # - ./scripts/bootstrap # - Took about a minute to install. No problems so far. # - export CLOJURESCRIPT_HOME=/home/aaron/scripts/clojurescript

Modern CLJS Tutorial

git clone https://github.com/magomimmo/modern-cljs.git
cd ./modern-cljs
lein ring server-headless failed. Got issued a warning that Leiningen was out of date.
lein update
lein ring server-headless works now.
CURRENT_END_OF_NOTES

Installing Hardened Gentoo with Full Disk Encryption

2013-01-20T20:55:00Z

These notes document an ongoing project and are not yet complete.

Useful Links and Documents

Install Log

Booted into the Gentoo minimal install live-cd.
Check hard drive (/dev/sda) for bad sectors: /sbin/badblocks -c 10240 -n -t random -v /dev/sda. Bad sectors can contain old information that could compromise data. This took several hours. No bad blocks were found.
Overwrite hard drive with random data: dd if=/dev/urandom of=/dev/sda. This operation took 74220.1 seconds, or about 20.6 hours. Creating random numbers must be hard work.
While I did this I set up wpa_supplicant to connect to my wireless network. Don't forget to start dhcpcd.
Partitioned disk. This is the first linux install where I haven't had to work around pre-existing partitions :)

Partition Device Size Reason for size

/boot /dev/sda1 512 MB Hold several kernel images

swap /dev/sda2 8 GB 2 GB Swap + (4 real + 2 swap) image

/ /dev/sda3 311.5 GB Remainder of drive
Load encryption modules: for i in dm-crypt dm-mod serpent sha256 blowfish;do modprobe $i;done
Running cryptsetup --help reveals that my live CD has the cryptsetup-luks executable
Set-up swap encryption for use during installation (from wiki page):

Partition	Device	Size	Reason for size
/boot	/dev/sda1	512 MB	Hold several kernel images
swap	/dev/sda2	8 GB	2 GB Swap + (4 real + 2 swap) image
/	/dev/sda3	311.5 GB	Remainder of drive

cryptsetup -c blowfish -h sha256 -d /dev/random create swap /dev/sda2 
mkswap /dev/mapper/swap
swapon /dev/mapper/swap

I want 64-bit AES module: modprobe aes_x86_64
Encrypt root partition with keyphrase generated using Diceware:

cryptsetup -y --cipher serpent-cbc-essiv:sha256 --key-size 256 luksFormat /dev/sda3

Create root mapping: cryptsetup luksOpen /dev/sda3 root
Format root to ext3: /sbin/mkfs.ext3 -j -m 1 -O dir_index,filetype,sparse_super /dev/mapper/root
Format boot to ext2: mkfs.ext2 /dev/sda1
Mount root: mount -t ext3 /dev/mapper/root /mnt/gentoo
Go to root: cd /mnt/gentoo
Downloaded stage3-amd64-hardened-20130110.tar.bz2 from a mirror. links http://www.gentoo.org/main/en/mirrors.xml
Checked tar.bz2 integrity with sha512sum.
Extract files: tar xvpjf stage3-amd64-hardened-20130110.tar.bz2
Created /mnt/gentoo/etc/portage/make.conf:

CFLAGS="-O2 -pipe -mtune=athlon64"
CXXFLAGS="${CFLAGS}"
MAKEOPTS="-j3"

Set mirrors in make.conf: ~mirrorselect -i -o >> /mnt/gentoo/etc/portage/make.conf

&& mirrorselect -i -r -o >> /mnt/gentoo/etc/portage/make.conf~. This had no effect. I will skip this step and come back later if it turns out I really needed it. TODO

Copy DNS info: cp -L /etc/resolv.conf /mnt/gentoo/etc/
Mount proc, sys, and dev:

mount -t proc none /mnt/gentoo/proc
mount --rbind /sys /mnt/gentoo/sys
mount --rbind /dev /mnt/gentoo/dev

Chroot!

chroot /mnt/gentoo /bin/bash
source /etc/profile
export PS1="(chroot) $PS1"

Unpack portage snapshot: mkdir /usr/portage && emerge-webrsync
I set the profile to "hardened/inux/amd64/" using eselect.
Set USE flags in make.conf.
Emerge the kernel sources: emerge -av gentoo-sources.
Update portage for good measure emerge -av portage.
Create an initramfs archive for early userspace:

cd /usr/portage/sys-apps/busybox
BUSYBOX_TARGET=`emerge -pvO busybox | grep -o "busybox-[-0-9.r]*"`
ebuild $BUSYBOX_TARGET.ebuild clean
ebuild $BUSYBOX_TARGET.ebuild unpack
cd /var/tmp/portage/sys-apps/$BUSYBOX_TARGET/work/busybox*
make defconfig
sed -i -e "s|# CONFIG_STATIC is not set|CONFIG_STATIC=y|" .config
sed -i -e "s|# CONFIG_INSTALL_NO_USR is not set|CONFIG_INSTALL_NO_USR=y|" .config

make # this failed at first, with output of
# > Failed: -Wl,--start-group -lcrypt -lm -Wl,--end-group
# > As a shot in the dark, I ran
emerge -av app-crypt/ccrypt # and
revdep-rebuild
# then running
make # resulted in
# > Trying libraries: crypt m
# >  Library crypt is not needed, excluding it
# >   Library m is need, can't exclude it (yet)
# But it built :)

make busybox.links
mkdir /build_initramfs
./applets/install.sh /build_initramfs --symlinks
# used links to download http://waku.info/uploads/misc/crypt_guide/init to /build_initramfs
cd ./build_initramfs
chmod 755 init
mkdir {proc,sys,new-root,etc,dev}
mknod --mode=0660 ./dev/null c 1 3 # note the dot in ./dev/null
mknod --mode=0600 ./dev/console c 5 1 # note the dot in ./dev/console
USE="static" emerge -av cryptsetup # I need it to be statically linked for the initramfs
cp -p `which cryptsetup` /build_initramfs/sbin/
# Then you need to do the equivalent of
# > cp /path/to/applets /path/to/build_initramfs/etc/ 
# I did this from the original busybox directory, using screen
sed -i -e 's/\/bin\/sh/\/bin\/ash/g' init # replace /bin/sh with /bin/ash in init
# script due to Busybox not including a /bin/sh applet in busybox >= busybox-1.1.3
find . | cpio --quiet -o -H newc | gzip -9 >/boot/initramfs-gentoo-crypt

Configure kernel as per http://en.gentoo-wiki.com/wiki/DM-Crypt_with_LUKS#Kernel_Configuration
- cd /usr/src/linux && make menuconfig
- Couldn't find the "Initial RAM disk (initramfs/initrd) support" though.
- Update: the option got moved to the "General Options menu".
- Update: letting the kernel make initramfs. Gave it "/build_initramfs".
Compiled kernal: make && make modules_install && make install for /usr/src/linux
Created /etc/fstab as per http://en.gentoo-wiki.com/wiki/DM-Crypt_with_LUKS#.2Fetc.2Ffstab
Followed steps from 8b to 10 in Gentoo install manual.
emerge -av grub
Created /boot/grub/grub.conf TODO post the file contents
Ran grub-install /dev/sda
Cleaned-up and rebooted … and blank prompt. Thinking back on it, I'm pretty sure I didn't mount /dev/sda1 before creating /boot, which means grubs config file is actually on /dev/sda3, not /dev/sda1 where it needs to be. Oops.
Fixed that. Now I get a grub boot menu.
Kernel panic - not syncing: No init found. Try passing init= option to kernel. Great.
Did some troubleshooting and found that the init script link on the wiki page was broken. Copied the script in its entirety to deckeraa.github.com/init.

Target System

Gateway NV5211u
AMD Athlon 64 X2 QL-65

Test-First Programming

2012-12-30T04:33:00Z

My most recent coding, an arkanoid clone written in Common Lisp, with a sprite library that I'm creating with an eye towards reusability, called for unit testing. I know, one should always unit test, but at school I am often forced to use tools e.g. Visual Studio, that obfuscate the build process and make it time-consuming to set-up unit tests.

Judging from this comp.lang.lisp thread, many lispers roll their own unit test frameworks. In lisp it is fairly trivial (following code taken from the referenced comp.lang.lisp thread):

(defun pick-greater (x y) y)
(defparameter *test-cases*
  '((+    (3 5)     8)
    (car  ((3 5))   3)
    (cdr  ((3 5))   5)
    (cons (3 5)     (3 . 5))
    (/    (6 4)     3/2)
    (cadr ((3 5 7)) 7)
    ))
(remove-if #'(lambda (fn+args+res)
               (equal (caddr fn+args+res)
                      (apply (car fn+args+res) (cadr fn+args+res))))
 *test-cases*)

The last s-expression returns ((CDR ((3 5)) 5) (CADR ((3 5 7)) 7)) when evaluated, showing which tests failed. Honestly, when I saw this, I was pretty impressed. A rudimentary, yet functional, testing framework in 4 lines of code. Lisp continues to impress me.

Peter Seibel has a chapter in Practical Common Lisp devoted to creating a unit-testing library. He demonstrates proper use of macros (the lisp kind, unrelated to the C kind).

I wanted something a bit more feature-full, yet still simple, so I took a look around at the available libraries. lisp-unit fits the bill. There is another page I referenced here. The big takeaway from that page was the use of (use-package :lisp-unit) at the start. I loaded the package using quicklisp: (ql:quickload :lisp-unit).

The main point of this post has surprisingly, against the best advice from writers of prose, not been introduced yet. The second page had a link to this "Xtreme" Programming article. While I agreed with most of the first portion, especially how writing unit test before code forces the requirements to be fully specified, I disagreed later on, mostly with the last paragraph:

There is a rhythm to developing software unit test first. 
You create one test to define some small aspect of the problem at hand. 
Then you create the simplest code that will make that test pass. 
Then you create a second test. 
Now you add to the code you just created to make this new test pass, but no more! 
Not until you have yet a third test. 
You continue until there is nothing left to test. 
The coffee maker problem shows an example written in Java.

The code you will create is simple and concise, implementing only the features you wanted. 
Other developers can see how to use this new code by browsing the tests. 
Input whose results are undefined will be conspicuously absent from the test suite.

So they are basically saying that all my funtions should be discrete, the domain of which consists entirely of points for which there are test cases. No! This is not the understanding that other people using your code will have. They will assume that your functions will work for all values of the input types specified. For example, I would expect, say, a function that determined if a point in a rectangle, to work given any point and any rectangle. Or at the very least, any point and any rectangle with a positive (non-zero) area. This is orthogonally opposed to the test-spec driven function being promoted in the article.

Oh, but we can go further. I can trivially follow the above advice by hard-wiring in output to match the test spec. Think of it like a function defined by a set of ordered pairs, (input output). Hopefully everyone can easily concieve of the folly of this sort of philosophy.

This concludes Rant #269.4, entitled "Test Specs do not constitute a function definition."

Lisp with SDL Notes

2012-12-22T17:14:00Z

Installing LispBuilder

Run the following in your lisp interpreter (for me it's SBCL)

(asdf-install:install :cffi)

That command stops and asks a lot about not reading the GPG key and also needs to re-initialize the central registry for every new package. No big deal though, both are offered as restarts.

Next, check-out lispbuilder.

svn checkout http://lispbuilder.googlecode.com/svn/trunk/ lispbuilder-read-only

Put the following in ~/.sbclrc. You will have to change the paths to match where you checked out lispbuilder to.

(pushnew "~/src/lispbuilder-read-only/lispbuilder-sdl/" asdf:*central-registry* :test #'equal)
(pushnew "~/src/lispbuilder-read-only/lispbuilder-sdl-mixer/" asdf:*central-registry* :test #'equal)

(asdf:oos 'asdf:load-op 'lispbuilder-sdl)
(asdf:oos 'asdf:load-op 'lispbuilder-sdl-examples)

Running (lispbuilder-sdl-examples:mandelbrot) yields a window drawing a mandelbrot, so it must have installed.

There is a really good user manual with examples and line-by-line explanations.

Using the REPL

A primary inspiration trying out lisp with emacs/slime is Bret Victor's talk on interactive programming. My distaste for the compile-test-modify cycle grew last semester when I had to compile C++ using Visual Studio … over a network. 12-second compile times were the norm. That and a bug in VS 2010 kept auto-complete from working in the Windows forms mode, combined with a stunning lack of quality documentation for the C++ Forms libraries turned the projects into an agonizingly slow guess-and-check "development" process. Anyhow, back to lisp.

I loaded the following code from the wiki and stated executing it:

(defparameter *random-color* sdl:*blue*)
(defun mouse-rect-2d ()
  (sdl:with-init ()
    (sdl:window 200 200 :title-caption "REPL without a cause")
    (setf (sdl:frame-rate) 60)

    (sdl:with-events ()
      (:quit-event () t)
      (:key-down-event ()
       (sdl:push-quit-event))
      (:idle ()
       ;; Change the color of the box if the left mouse button is depressed
       (when (sdl:mouse-left-p))
;;         (setf *random-color* (sdl:color :r (random 255) :g (random 255) :b (random 255))))

       ;; Clear the display each game loop
       (sdl:clear-display sdl:*black*)

       ;; Draw the box having a center at the mouse x/y coordinates.
       (sdl:draw-box (sdl:rectangle-from-midpoint-* (sdl:mouse-x) (sdl:mouse-y) 20 20)
                     :color *random-color*)

       ;; Redraw the display
       (sdl:update-display)))))

There is a screenshot here

Then I changed sdl:*blue* to sdl:*red*, pressed C-c C-c, and boom! the color changed. Nice.

Okay, so a global variable can be changed on the fly. Big deal. Any debugger can do that. What about redefining a function, recompiling, and executing on the fly? To test this out, I wrote the function (defun my_clear () (sdl:clear-display sdl:*red*)). I then replaced (sdl:clear-display sdl:*black*) with (my_clear) in the main event loop. Then, once I ran it, I could change the color inside of my_clear, redefine the function with C-c C-c, and have the already-running process change accordingly. This is powerful.

There is a tip here on the lispbuilder wiki with a tip about keeping the repl available when running a single-threaded lisp/sdl program. I haven't needed this yet.

Getting SLIME working on Gentoo

2012-12-21T20:54:00Z

I wanted to get SLIME working so that I could efficiently code lisp, which is my next learning endeavour. This turned out to be much more difficult than I imagined. I've decided to document the steps I took to connect SLIME to a running SBCL (my lisp implementation) on Gentoo. Although outdated, the video on this page (direct link) is a good overview of SLIME.

Emerge SBCL
```
sudo emerge -av sbcl
```
Check out the fairly-stable version of SLIME I put all the software I build from source by myself in ~/src, but you could put it anywhere.
```
cd ./src
cvs -d :pserver:anonymous@common-lisp.net:/project/slime/cvsroot checkout -r FAIRLY-STABLE slime
```

Create a "systems" folder for SBCL to find SLIME's swank.asd file in.

cd ./lisp
mkdir systems
cd ./systems
ln -s ~/src/slime/swank.asd

Add the following to ~/.sbclrc (create the file if it doesn't exist).

(require :asdf)
(push "/home/[user]/lisp/systems/" asdf:*central-registry*)

Add the following to ~/.emacs

(setq inferior-lisp-program "/usr/bin/sbcl" ; your Lisp system
    slime-startup-animation t) 
(add-to-list 'load-path "~/src/slime") ; your SLIME directory
(require 'slime)
(slime-setup '(slime-fancy slime-asdf))

Start up SBCL, and run the following:

(asdf:oos 'asdf:load-op :swank)
(swank:create-server)

Now running 'M-x slime-connect' in Emacs should start a REPL that looks something like
```
; SLIME 2011-11-03
CL-USER> 
```
Expect to be prompted for host name and port; accept the defaults.

Math Homework Template using Org-mode/LaTeX

2012-12-19T16:46:00Z

This past semester for my Discrete Math class I decided to type up most of my assignments. I needed an easy way to format the page and organize problems, so I used Org-mode, which comes built-in with Emacs. Then I also added a few lines to each file to get the page layout to work well with what I was trying to do. I've decided to post an org file with some representative problems so that others can employ the same sort of set-up.

To use this template, simply open the org file in Emacs. It should then start org-mode automatically. To export to a pdf, type C-c C-e to open the export buffer. Then type 'd' to export to pdf via LaTeX. Emacs will probably then ask if you want to allow BIND values; type 'yes' once and it won't ask again.

org file

pdf output

State Squid and I/Octopus

2012-09-13T15:23:00Z

Once upon a time, in a land so fine,
where analysis happened all the time,
lived a happy little class family.
Yes, it was in the land of OO, where lines
and boxes and use case scenarios
frolic playfully in the street and all
the happy classes live together with
minimal coupling and high cohesion.

Twas dusk one night at the coding class house,
where lived a family whose existence was due
to an assignment from a programming class.
Twas the RPN family of who
members were Susie Stack, sibling Quentin Queue,
RPNEval and Driver Class too.
Daddy Driver Class tucked them into bed
along with the state from their objects, he said.
Scary stories of high coupling he read,
but he assured them that all those bugs were long dead.

Those bugs were before we had UML,
now we have OO and life is just swell.
With those words he bid them all a good night,
he bid them sweet dreams and turned off the light.
He thought to himself, as he went to his room,
Their state is encapsulated, all that
talk from functional programmers, of doom
and despair from state was lame and old hat.
He had it all taken care of, put in each class,
the lambda and OO schools had reached an impasse.

But all through the night he had quite a fright,
unspeakable horrors passing through his mind's sight.
He dreamt of a kraken, no, just a huge squid,
that just stood and stared as he wondered what it did.
It's cavernous eyes peered deep into his soul,
this must be a prank, just a functional troll.
But there its singular figure remained,
on the UML of his soul it was firmly engrained.
Its tentacles were just lines, his face a mere shape,
But the diagram of his family it threatened to reshape.

Rebellion against father, but just in his dream,
for RPNEval was drinking from the forbidden stream.
That ethereal stream that is called I/O,
whose state at runtime, nobody knows.
The paternal class cursed in frustration, no fear he could quell,
he thought he had had it all planned out so well.
But his model was naive, much too simple to be good,
he hadn't modeled the state of the whole program like he should.
But now complexity, and inter-dependency too,
clamored around his program, like the monkeys at a zoo.

Now there is a moral to this story, something just for you,
model all the state in your program, or this too you will rue.

Style Guidelines Revisited

2012-09-10T03:25:00Z

Coding style guidelines are great. They keep code looking consistent and can improve readability. As a result, many quality, widely-accepted coding styles exist – K&R, GNU, Whitesmith are a few examples – and are already loaded into IDE's such as Emacs or NetBeans. This makes me wonder: Why do certain universities insist on creating their own style guidelines?

I was recently reading through the "programming ground rules" of a course at a certain university, which will remain unnamed. For context, this course uses C++ as the main language for the course. While many of the guidelines are good ideas and common sense, I came across some interesting rules.

"Use the // comment style."

"Only use the /* */ comment style to temporarily comment out chunks of your program for testing and debugging." I must admit I was a little confused by this one. Comments compile out. Additionally, all the editors I know of are able to deal with both commenting styles. I just can't see how this affects readability.

Every function needs a doc banner. Even getters, setters, and the following function.

class Stack
{
public:
   // -----------------------------------
   // Returns true if the stack is empty.
   // -----------------------------------
   bool isEmpty() { /* . . . */ }
   // ...
};

Thankfully, a few rules from previous courses were noticeably absent. Arguments no longer must be labeled in a comment block as "in, out, or in/out". Do I have a problem with such labels? No, but when they are unnecessary they tend to reduce the readability of the comments. Take the following two functions for example. Yes, the function is deliberately simplified, but how much of your C++ code consists of such functions?

// isOutOfBounds( int x, int y)
// Returns true if the coordinates are in bounds.
// Returns false otherwise.
// ARGS: IN, IN
bool isOutOfBounds( int x, int y );

// Checks to see if the given coordinates are in bounds of the window.
// Note that x and y are expressed in screen coordinates.
bool isOutOfBounds( int x, int y );

The second declaration, though not rigidly formatted, provides far more information than the first. Also note the use of upper-case to convey that 1960's COBOL kind of feeling.

Also gone from the rules is the "30-line function limit", where points would be taken off for any function longer than 30 lines. While written to encourage modular design, the rule also encourages "code golf", where esoteric programming constructs and obscure evaluation rules help to fit the function inside of the line limit.

Take the following code snippets. Do they do the same thing?

void push( float obj_to_push )
{
   stack_data[current_index++] = obj_to_push;
}

// or

void push( float obj_to_push )
{
   current_index++;
   stack_data[current_index] = obj_to_push;
}

They do not do the same thing. The post-fix increment operator is evaluated after the assignment operator. Encouraging code golf with line limits encourages language constructs that, while clever and loved by language lawyers, are a pitfall for the creation of bugs.

Why then are programs graded according to criteria that at times are only tangentially related to good programming and at other times are actually opposed to proper coding? It would seem that the university system feels a need to conform programming into the standardized testing/grading paradigm currently embraced by many educational institutions, but has failed to quantify good programming practices.

How then, do we teach proper coding to students still struggling to master even the simplest aspects of programming such as language syntax? To be honest, I do not have an answer, and it would be preposterous if I purported to be qualified to propose proper pedagogical procedures. One thing I have noticed, however, is the inordinate amount of time spent learning language-specific constructs ( where the semi-colon goes ) in courses that advertise themselves as being about things such as "data structures".

Perhaps the way to go is to use a language with little syntax such as Scheme. Hal Abelson and Gerald Jay Sussman employed such a method in their book Structure and Interpretation of Computer Programs and their MIT course by the same name ( video lectures can be found here). Roughly one lecture covered the syntax of Scheme, rather than half of a semester using, say, Java ( as an aside, I would have to posit that Java's object reference system cannot be properly understood without first understanding the idea of pointers in a language such as C).