andrew.scm

                      (define (ntbf-eval 
                  x h d) (unless (null? x) (case 
              (car x) ((#\>) (ntbf-eval (cdr x) h 
             (+ d 1))) ((#\<) (ntbf-eval (cdr x) h 
            (- d 1))) ((#\+) (begin (vector-set! h d 
           (+ 1 (vector-ref h d))) (ntbf-eval (cdr x) 
            h d))) ((#\-) (begin (vector-set! h d (- 
            1 (vector-ref h d))) (ntbf-eval (cdr x) 
           h d))) ((#\.) (begin (format #t "~a" (
          integer->char (vector-ref h d))) (ntbf-eval 
         (cdr x) h d))) (else (error "invalid non turing 
        brainfuck statement"))))) (define (prog-table) (let 
       loop ((i 0) (accum '())) (if (< i 128) (loop (+ 1 i)
       (cons `(,(integer->char i) (,i #\+) (1 #\.)) accum))
        accum))) (define (rld ps) (let ((char (cadr ps)))
          (let loop ((i (car ps)) (accum '())) (if (> i 
            0) (loop (- i 1) (cons char accum)) accum)
            ))) (define fragments (prog-table))(define 
            (make-prog s) (let ((ls (string->list s)))
              (let loop ((ls ls) (accum  '()))  (if
                (not (null? ls))  (let ((p (assoc 
                 (car ls) fragments))) (if (not 
                  (null? p)) (loop (cdr ls) (
                    append accum (append (cdr 
                     p) '((1 #\>))))) (error 
                    "I only do ASCII"))) accum
                  )))) (define (decode ls) (apply 
               append (map rld ls))) (begin(ntbf-eval 
              (decode    (make-prog "LinkedList NYC")) 
              (make-vector 100         0) 0) (newline)) 

                    ;; LinkedList Ice Cream Bowl
                    ;; By Andrew Gwozdziweycz

brian.js

/*
  Why try to go out and generate words when, like, you can find all the
  words and letters you need in the trash, man?

  This will allocate a byte of memory without initializing it and see if
  what was left in there can be used to make part of the word we are
  looking for. If not, it tosses it aside and goes on to the next byte.

  The amount of iterations it took to find each letter as well as the
  total iterations will be printed to stderr. Feel free to throw that
  shit into the black hole that is /dev/null if you just want the
  string.

  Usage:
    node recycle.js <words-to-find>

  Example:
    $ node recycle.js 'Sweet, half eaten sandwich!'
    { characters:
       [ { chr: 'S', foundAfter: 1351 },
         { chr: 'w', foundAfter: 812 },
         { chr: 'e', foundAfter: 2121 },
         { chr: 'e', foundAfter: 2121 },
         { chr: 't', foundAfter: 1974 },
         { chr: ',', foundAfter: 1231 },
         { chr: ' ', foundAfter: 1896 },
         { chr: 'h', foundAfter: 1836 },
         { chr: 'a', foundAfter: 2102 },
         { chr: 'l', foundAfter: 1716 },
         { chr: 'f', foundAfter: 1224 },
         { chr: ' ', foundAfter: 1896 },
         { chr: 'e', foundAfter: 2121 },
         { chr: 'a', foundAfter: 2102 },
         { chr: 't', foundAfter: 1974 },
         { chr: 'e', foundAfter: 2121 },
         { chr: 'n', foundAfter: 618 },
         { chr: ' ', foundAfter: 1896 },
         { chr: 's', foundAfter: 726 },
         { chr: 'a', foundAfter: 2102 },
         { chr: 'n', foundAfter: 618 },
         { chr: 'd', foundAfter: 2113 },
         { chr: 'w', foundAfter: 812 },
         { chr: 'i', foundAfter: 271 },
         { chr: 'c', foundAfter: 1305 },
         { chr: 'h', foundAfter: 1836 },
         { chr: '!', foundAfter: 1329 } ],
      bytesExamined: 2121 }
    Sweet, half eaten sandwich!

  Known Issues:
    - If the phrase contains regexp characters that need escaping things
      will fuck up.
    - This can theoretically run forever if you have impeccably clean
      memory.
    - I kinda feel like it's cheating to reuse a single found byte for
      filling in multiple holes in the string.
*/

var pathutil = require('path');
var util = require('util');

function isSparse(array) {
  var len = array.length;
  while (len--)
    if (typeof array[len] === 'undefined')
      return true;
  return false;
}

function findInGarbage(words) {
  // Initialize a sparse array. We'll populate it in order as we find
  // discarded characters that are in totally perfect good condition,
  // why would anyone throw away a character like that? People these
  // days, geez.
  var result = Array(words.length);
  var iterations = 0;
  var wordsRe = new RegExp('['+ words +']');
  var chr;

  while (isSparse(result) && ++iterations) {
    // Dig a fresh byte of memory out of the dump and inspect it with
    // your grubby, hobo-gloved hands. If it's not to your liking, just
    // throw it away and move on.
    chr = String.fromCharCode(Buffer(1)[0]);
    if (!chr.match(wordsRe)) {
      delete chr;
      continue;
    }

    // `replace` in this context is a misnomer -- I'm just using it so I
    // can get detailed information about each match, specifically the
    // index it matches to in the expected string.
    words.replace(new RegExp(chr, 'g'), function (chr, idx) {
      result[idx] = { chr: chr, foundAfter: iterations };
      return chr;
    });
  }

  return {
    characters: result,
    bytesExamined: iterations
  }
}

function inspect(thing) {
  var color = require('tty').isatty();
  return util.inspect(thing, null, null, color);
}

if (!module.parent) {
  var scriptName = pathutil.basename(process.argv[1]);
  var args = process.argv.slice(2);
  var string, result;

  if (!args.length) {
    console.log('Usage: node %s <words to find>', scriptName);
    process.exit(1);
  }

  result = findInGarbage(args[0]);
  process.stderr.write(inspect(result) + '\n');
  process.stdout.write(result.characters.map(function (o) {
    return o.chr;
  }).join('') + '\n');
  process.exit(0);
}

danny.py

#!/usr/bin/env python
import sys
import logging
import requests
from BeautifulSoup import BeautifulSoup

logging.basicConfig(level=logging.ERROR)

# indices of the characters of "LinkedList" in the first sentence of the
# "Greek Language" wikipedia article
indices_greek = [444, 26, 27, 4, 2, 108, 444, 26, 81, 116]
BASE_URL = 'http://en.wikipedia.org'

def main(word):
    """ Query wikipedia until you hit the philosophy page
        Phrase must be a non-empty string
    """
    if not word:
        word = raw_input('First word that comes to mind: ')
    url_path = _format_phrase_for_wikipedia(word)
    phrase = _query_wikipedia_loop(url_path)
    print "\n\n{0} NYC\n".format(phrase)

def _query_wikipedia_loop(url_path):
    """ Helper to run the queries"""
    print "checking page: {0}".format(url_path)
    full_url = BASE_URL + url_path
    resp = requests.get(full_url)
    if not resp.ok:
        logging.error("sorry, broke on link: {0}".format(url_path))
        return None
    link, output = _get_link_or_output(resp.content)
    if output:
        return output 
    else:
        return _query_wikipedia_loop(link)

def _get_link_or_output(content):
    """ Find the first link in the body of text of a wikipedia page
    """
    soup = BeautifulSoup(content)
    page_body = soup.body.find(id="mw-content-text")
    first_link, content = get_first_link_and_page_content(page_body)
    # if we made it to one of the "attractor" pages, parse the entry for the
    # "linked list" string
    title = soup.body.h1.span.text 
    if title == "Greek language":
        output = _get_linked_list_from_string(content.text, indices_greek)
        return None, output 
    return first_link, None

def get_first_link_and_page_content(page_body):
    """ Returns the first link in the body of text.  You should pass in the
    #mw-content-text div from the wikipedia page
    """
    # search the paragraphs in order for the first link
    for content in page_body.findAll('p'):
        # sometimes the first link is bad, we only want ones that are
        # wikipedia pages i.e. start with "/wiki/"
        first_link = _search_links_for_first_nice_link(content.findAll('a'))
        if first_link:
            return first_link, content
    # sometimes it's a "list" page, with no links in the paragraphs
    for list_item in page_body.findAll('li'):
        first_link = _search_links_for_first_nice_link(list_item.findAll('a'))
        if first_link:
            break
    return first_link, content

def _search_links_for_first_nice_link(links):
    """ look through the list of links for the first one that is in the normal
    wikipedia format
    """
    # shuffle them for fun, and it's no longer an attractor
    #import random
    #random.shuffle(links)
    for link in links:
        href = link.get('href') or ''
        if href.startswith('/wiki/'):
            logging.debug('href starts with /wiki/')
            first_link = link.get('href')
            return first_link
    return None


def _get_linked_list_from_string(string, indices):
    """ Get the phrase "linked list" from the string
    """
    logging.debug("pulling linked list from: " + string)
    return "".join(string[i] for i in indices)


def _format_phrase_for_wikipedia(phrase):
    """ Capitalize every word and replace spaces with underscores, the way that
    wikipedia urls are formatted
    """
    formatted = '_'.join(a[0].upper() + a[1:] for a in phrase.split(' ')
            if len(a) > 0)
    return "/wiki/{0}".format(formatted)

if __name__ == "__main__":
    word = sys.argv[1] if len(sys.argv) > 1 else None
    main(word)

elliott.asm

; 'LinkedList NYC' printed out using a Linked List implementation in ASM
;
; Elliott Carlson  -  x@sublim.nl

    extern malloc
    extern free
    extern putchar

%macro init 1
    mov         dword [%1], 0
%endmacro

; Append mactro to add one or more passed items to the linked list procedure
%macro append 1-*
    %rep %0 
        push    dword %1
        push    linkedlist
        call    ll_append
    %rotate 1
    %endrep
%endmacro

; Print out the linked list
%macro print 1
    push        dword [%1]
    call        ll_print
%endmacro

; Cleanup the linked lists allocated memory
%macro cleanup 1
    push        dword [%1]
    call        ll_cleanup
%endmacro

section .data
    size_i:
    struc node
        info:   resd  1
        next:   resd  1
    endstruc
    len:        equ $ - size_i

section .bss
    linkedlist: resd  1

section .text
    global      main

; Main
main:
    ; Save the stack
    push        ebp
    mov         ebp, esp

    ; Initialize list as empty
    init        linkedlist    

    ; Append the hex codes of the message 'LinkedList NYC' to
    ; the linked list via the append macro
    append      0x4c, 0x69, 0x6e, 0x6b, 0x65, 0x64, 0x4c
    append      0x69, 0x73, 0x74, 0x20, 0x4e, 0x59, 0x43

    ; Print out the contents of the linked list
    print       linkedlist

    ; Clean up allocated memory
    cleanup     linkedlist

    ; Restore stack
    mov         esp, ebp
    pop         ebp
    ret

; Linked list append
; Add an element to the linked list
ll_append:
    ; Save the stack
    push        ebp
    mov         ebp, esp

    ; Save registers
    push        eax
    push        ebx

    ; Get the allocated memory of the linked list - push to eax
    push        len
    call        malloc
    
    mov         ebx, [ebp + 12]
    mov         [eax + info], ebx
    mov         dword [eax + next], 0

    ; Check if the linked list is currently null
    mov         ebx, [ebp + 8]
    cmp         dword [ebx], 0
    je          ll_append_null

    mov         ebx, [ebx]

ll_append_next:
    ; Find the address of the last element in the linked list
    cmp         dword [ebx + next], 0
    je          ll_append_last

    mov         ebx, [ebx + next]
    jmp         ll_append_next

ll_append_last:
    ; Set the pointer to the address of the last element
    mov         [ebx + next], eax
    jmp         ll_append_exit

ll_append_null:
    ; Set pointer to first element
    mov         [ebx], eax

ll_append_exit:
    ; Restore registers
    pop         ebx
    pop         eax

    ; Restore stack    
    mov         esp, ebp
    pop         ebp
    ret         8

; Linked list print
; Print all elements out from a linked list
ll_print:
    ; Save the stack
    push        ebp
    mov         ebp, esp

    ; Save register
    push        ebx

    ; Get the address of the first element in the list
    mov         ebx, [ebp + 8]
    ; If ebx is 0, then the list is empty - bothing to print
    cmp         ebx, 0
    je          ll_print_exit

ll_print_next:
    ; Loop through the linked list and print each character    
    push        dword [ebx + info]
    call        putchar
    mov         ebx, [ebx + next]
    ; As long as ebx doesn't equal 0 (end of list) then loop
    cmp         ebx, 0
    jne         ll_print_next
    
    ; Print a new line character at the end
    push        dword 10
    call        putchar

ll_print_exit:
    ; Restore stack
    pop         ebx
    mov         esp, ebp
    pop         ebp
    ret         4

; Linked list cleanup
; Deallocate memory used by the linked list
ll_cleanup:
    ; Save stack
    push        ebp
    mov         ebp, esp

    ; Save register
    push        eax

    ; Get address of the current position of the stack in the linked list
    mov         eax, [ebp + 8]
    ; Check if we have passed the end of the linked list
    cmp         eax, 0
    je          ll_cleanup_exit

    ; Go to the next available address in the linked list and loop
    push        dword [eax + next]
    call        ll_cleanup

    ; Set the address of the current element and free it from memory
    push        eax
    call        free
    add         esp, 4

ll_cleanup_exit:
    ; Restore register
    pop         eax

    ; Restore stack
    mov         esp, ebp
    pop         ebp
    ret         4

fabrizio.lua

local response = http.request {
	  url = 'http://www.linkedlistnyc.org'
	}

s = response.content

lk = string.match(s, "<title>(.*)</title>")

local twilio = require('webscriptio/lib/twilio.lua')
 
local ACCOUNTSID = '<YOUR TWILIO ACCOUNT SID>'
local AUTHTOKEN = '<YOUR TWILIO AUTH TOKEN>'
 
local response = twilio.sms(
  	           ACCOUNTSID,
	           AUTHTOKEN,
		   '<YOUR TWILIO NUMBER>',
	           request.form.phonenumber,
		   lk
                 )

if response.statuscode == 201 then
  return 'Text message sent. '..lk..'\n'
else
  return 'An error occurred. Check the phone number you used.'
end

hannah.java

import java.util.Scanner;
public class IceCreamGame {

	/**
	 * @author Hannah Chen
	 * hannahelainechen@gmail.com
	 */
	
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		String[] questions = {
				"4C in decimal? " ,
				"Number of US Senators plus how many pints of ice cream I might get? " ,
				"Number of stories of each of the towers of the former WTC in New York? " ,
				"Section number of Copyright Law regarding Fair Use? " ,
				"HTTP status code indicating server acknowledging request to switch protocol?  " ,
				"Number of days of summer divided by 5. You know, that movie with that Zooey girl. " ,
				"Street number of Amsterdam Ale House? " ,
				"How many years of solitude? Add five to that. " ,
				"Atomic number of element used to make zombies in Call of Duty?" ,
				"Number of years that the Hundred Years' War lasted? " ,
				"Number of teeth of a full set of adult teeth? " ,
				"Number of cards that make up a typical tarot deck? " ,
				"TI calculator that made high school math so easy... " ,
				"Prefix code to block caller ID for a prank call? " };
		String a = "LinkedList NYC";		
		
		System.out.println("Test your useless trivia! Answer some questions!");
		System.out.println("Oh, and if you get any wrong you have to start over...");
		
		boolean end = false;
		while(!end) {
			for (int i = 0; i < a.length(); i++) {				
					System.out.println(questions[i]);
					if (input.nextInt() == (int)a.charAt(i) ) {
						if (i == a.length() - 1) {
							System.out.println(a);
							end = true;
							break;
							}
						continue;
					}
					else {
						System.out.println("Start over.");
						break;
					}
			}
		}
	}
}

harold.java

import java.util.*;
import java.util.concurrent.Callable;

public class AcronyMiser {

    /* Remove all non-uppercase characters from s.
     *
     * This is the algorithm for which we want to find the best List implementation!
     */
    private static void acronymize(List<Character> s) {
        Iterator<Character> i = s.iterator();
        while(i.hasNext()) {
            if (!Character.isUpperCase(i.next()))
                i.remove();
        }
    }

    private static final int N = 100000; // number of runs per List implementation
    public static void main(String[] args) throws Exception {
        // the string to acronymize:
        final List<Character> s = asList(args[0]);

        // Callables for each List implementation, which return a new copy of the string when called:
        Callable<List<Character>>[] constructors = new Callable[] {
            new Callable<List<Character>>() {
                public List<Character> call() {
                    return new ArrayList<Character>(s);
                }
            },
            new Callable<List<Character>>() {
                public List<Character> call() {
                    return new LinkedList<Character>(s);
                }
            },
            new Callable<List<Character>>() {
                public List<Character> call() {
                    return new Vector<Character>(s);
                }
            },
            new Callable<List<Character>>() {
                public List<Character> call() {
                    List<Character> stack = new Stack<Character>();
                    stack.addAll(s);
                    return stack;
                }
            },
        };

        // try each implementation N times, outputting stats to stderr, and keep track of the best:
        long bestTime = Long.MAX_VALUE;
        List<Character> bestList = null;
        for (Callable<List<Character>> constructor : constructors) {
            List<Character> list = constructor.call();
            System.err.println("=" + className(list) + "=");

            long t = System.nanoTime();
            for (int i = 0; i < N; i++) {
                list = constructor.call();
                acronymize(list);
            }
            t = System.nanoTime() - t;
            System.err.println((t / N) + "ns");

            if (t < bestTime) {
                bestTime = t;
                bestList = list;
            }
        }

        // we have our winning List implementation!
        // print its name and value to stdout:
        System.out.println(className(bestList) + " " + asString(bestList));
    }


    //
    // utility methods //
    //

    private static List<Character> asList(String s) {
        // there are easier ways to do this, but not without referencing a particular List implementation,
        // and i wanted to avoid picking favorites :'(
        char[] chars = s.toCharArray();
        Character[] characters = new Character[chars.length];
        for (int i = 0; i < chars.length; i++)
            characters[i] = chars[i];
        return Arrays.asList(characters);
    }

    private static String asString(List<Character> characters) {
        StringBuilder s = new StringBuilder();
        for (Character c : characters)
            s.append(c);
        return s.toString();
    }

    private static String className(Object o) {
        String name = o.getClass().getName();
        return name.substring(name.lastIndexOf('.') + 1);
    }
}

michael.coffee

$(->
  linkMeBabyOneMoreTime()
)

pixel_map = [
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,1,1,1,0,1,0,0,0,1,0,1,0,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,0,1,0,0,1,1,0,0,1,0,1,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,0,1,0,0,1,0,1,0,1,0,1,1,0,0,0,1,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,0,1,0,0,1,0,0,1,1,0,1,0,1,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0],
  [0,1,1,1,0,1,1,1,0,1,0,0,0,1,0,1,0,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,1,1,1,0,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,0,1,0,0,0,1,1,0,0,0,1,0,0,0,0,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0],
  [0,1,1,1,0,1,1,1,0,1,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
]

linkMeBabyOneMoreTime = ->
  # set some size variables
  xScale = pixel_map[0].length
  yScale = pixel_map.length
  bigger = if xScale >= yScale then xScale else yScale
  pixel_size = Math.ceil(100 / bigger) # round up to get some overlap
  delay = 75 # for animation

  # add the divs
  for y in [0...yScale]
    for x in [0...xScale]
      $('body').append "<div class='offscreen' style='left: #{x * pixel_size}%; top: #{y * pixel_size}%; width: #{pixel_size}%; height: #{pixel_size}%;' />" if pixel_map[y][x] == 1

  # remove the offscreen class to trigger the animation
  $('div').each (i)->
    setTimeout(=>
      $(this).removeClass('offscreen')
    , i * delay)

  # show my credit
  setTimeout(->
    $('footer').fadeIn('slow')
  , ($('div').length + 3) * delay)

ricky.py

import mechanize
import urlnorm
import urllib2
import re
import sys

VALID_CHARS = '^([-A-Za-z0-9+&@#/%=~_()| ]*)$'

def validate_search_term(search_term):
	return bool(re.search(VALID_CHARS, search_term))

def print_url(url, letter_index, max_index):
	if (not url or letter_index == -1):
		print ''
	else:
		padding = ' ' * (max_index - letter_index)
		print '%s%s %s %s' % (padding, url[0:letter_index], url[letter_index], url[letter_index+1:])

def find_matching_links(br, target_word, result, visited):
	if (not target_word):
		return result
	else:
		current_URL = urlnorm.norm(br.geturl())
		current_letter = target_word[0].lower()
		if (current_letter.isspace()):
			return find_matching_links(br, target_word[1:], result + [('', -1, ' ')], visited)
		else:
			matching_index = current_URL[7:].find(current_letter)
			if (matching_index == -1):
				return []
			else:
				new_result = result + [(current_URL, matching_index + 7, current_letter)]
				links = list(br.links())
				for link in links:
					try:
						link_URL = urlnorm.norm(link.absolute_url)
						if (link_URL not in visited):
							br.open(link_URL)
							new_visited = visited.copy()
							new_visited.add(link_URL)
							# print "visiting: " + urlnorm.norm(br.geturl())
							new_visited.add(urlnorm.norm(br.geturl()))
							child_result = find_matching_links(br, target_word[1:], new_result, new_visited)
							if (child_result):
								return child_result
 					except Exception, e:
						continue
	return []


def main():
	if (len(sys.argv) < 3 ):
		print "usage: python ll-print.py <url> <search term>"
		print "example: python ll-print.py http://www.hunch.com 'hunch team'"
		exit(0)
	root_URL = sys.argv[1]
	search_term = sys.argv[2]
	if (not validate_search_term(search_term)):
		print "Invalid search term.  Please only use valid url characters and spaces."
		exit(1)
	first_letter = search_term[0]
	first_letter_match = root_URL.find(first_letter.lower())
	if (first_letter_match != -1):
		try:
			br = mechanize.Browser()
			br._factory.is_html = True
			result = []
			br.open(root_URL)
			# print "visiting: " + urlnorm.norm(br.geturl())
			visited = set([urlnorm.norm(br.geturl()), urlnorm.norm(root_URL)])
			result = find_matching_links(br, search_term, result, visited)
			if (result):
				max_index = max(result, key=lambda u: u[1])[1]
				for l, i, c in result:
					print_url(l, i, max_index)
		except urlnorm.InvalidUrl:
			print "Invalid root URL"
		except urllib2.URLError, e:
			print "Error opening root URL"
			print e
		except Exception, e:
			print e
		finally:
			exit(1)

if __name__ == "__main__":
    main()

zach.clj

(ns secd.linkedlistnyc
  (:use [secd.core])
  (:gen-class))

(defn -main []
  (do
    (do-secd* [:nil :dum
               :ldf [:ld [0 0] :null
                     :sel
                     [:join]
                     [:ld [0 0] :car :writec
                      :nil :ld [0 0] :cdr :cons
                      :ld [1 0] :ap :join]
                     :rtn]
               :cons
               :ldf [:nil
                     :ldc [76 105 110 107 101 100
                           76 105 115 116
                           32
                           78 89 67
                           10]
                     :cons
                     :ld [0 0] :ap :rtn]
               :rap])
    nil))