1. Gamification (taught by the University of Pennsylvania)

Gamification is the application of game elements and digital game design techniques to non-game problems, such as business and social impact challenges. This course will teach you the mechanisms of gamification, why it has such tremendous potential, and how to use it effectively.

2. Model Thinking (taught by the University of Michigan)

In this class, you will learn how to think with models and use them to make sense of the complex world around us.

]]>

1. Completed the Learn to Program: The Fundamentals course taught by the University of Toronto and offered through Coursera with an astounding 94.3%

2. Completed the Introduction to Systematic Program Design – Part One taught by the University of British Columbia and offered through Coursera with a solid mark of 87.8% (passing with distinction)

Some post class thoughts:

- Both classes were extremely valuable in getting my feet wet in the area of programming
- The methods presented in the systematic program design course are now just second nature when approaching a problem and I think that was the overall point of the class.
- I like Python better than Racket/Scheme as a programming language

]]>

It gives you some ideas and also gives you some supporting files.

- Beginnings: a set of simple projects when you have little to work with.
- First Steps — little to work with.
- Arithmetic: Input some numbers, do some simple arithmetic, output results.
- Gasoline: Input some numbers, do some simple arithmetic on gas and oil quantities, output results.
- Measurement: Input some numbers, do some simple arithmetic to do silly conversions such as furlongs/fortnight, output results.
- Population: Input some numbers, do some simple arithmetic to estimate today’s U.S. population, output results.
- Time Travel: Input some numbers, do some simple arithmetic to calculate travel time between stars, output results.

- Simple Programs.
- Einstein: Solve a simple number puzzle attributed to Einstein.
- MacArthur: Solve a simple number puzzle attributed to MacArthur.
- Tones: Calculate frequencies to generate tones on a computer speaker.
- Turtle Graphics Angles: Use Turtle Graphics to draw two lines and the calculate the angle between them.
- Turtle Graphics Polygon: Use Turtle Graphics to draw a polygon and fill it in with a color.

- First Steps — little to work with.
- Control: With selection and repetition we can begin to do something.
- DigitCount: Input a number and a digit; count occurrences of the digit in the number.
- LatinSquares: Input two numbers: order and start. Build a Latin square of that order with that starting number.
- Number Theory: Persistence: Numbers can have interesting properties. Here we look at additive persistence where you sum the digits of a number and then sum the digits of the sum—continue until you get a single digit.
- Number Theory: Pologinal: The ancient Greeks found number properties to be interesting. A pologinal number is a particular geometric arrangement of a number of balls. Here we find two triangular number that form a given square number.
- Ancient Egyptian Multiplication: Weird Multiplication: To muliply A by B repeatedly multiply A by 2 while dividing B by 2 until the division has a remainder. If B becomes odd, add A to it. Sum the resulting A and B.
- Calculator: Make a simple, basic arithmetic calculator. Accept an expression in the form “number operator number”, and calculate the result.

- Working With Strings.
- Palindomic Integers: Use the 196-algorithm to construct palindomic integers starting from any integer.
- Number-Guessing Game: Create a number-guessing game that provides hints on the number and position of correct digits in the guess (similar to Mastermind).
- Hangman: Create a hangman game (without the graphics of the hangman itself).
- Mastermind: Create a Mastermind game.
- Caesar Cypher: Encode and decode strings using a Caesar cypher.
- Rock Paper Scissors: Create a game of Rock-Paper-Scissors.

- Functions (simple)
- WeFeelFine: Use functions from a module to gather data for analysis from the “We Feel Fine” page. The result is a collection of people’s feelings scraped from blogs.
- GDP vs. Employment: Using GDP and employment data from the web, prompt for a year and provide the data for that year.
- Scrambled Words: Research shows that scrambled words can be read if the first and last letter are not changed, e.g. “Elingsh uinervtisy.” Read in a file and scramble the words except first letters, last letters, and punctuation.
- Cracking a Caesar Cipher: Decrypt Caesar Ciphers using letter frequencies.

- Lists and Tuples
- Basketball: Who is best basketball player in the NBA? Get data from the web and analyze it.
- Latin: Search for Latin roots, suffixes, and prefixes in a file.
- Anagrams: Given a word find all the anagrams of that word in a word list.
- Data Mining: Data Mining of online Google stock data.
- Build Query to Search Files: Build a simple query to search files ignoring stop words.
- Sunspots: Using NOAA data from the web analyze sunspot data to predict the next sunspot peak.
- Pascal’s Triangle: Construct Pascal’s Triangle to a specified depth.
- Auto Mileage: Using online data on automobiles, gather engine size and mileage data. Use least squares to find a linear regression and correlation. Graph it.
- Packaging: Minimize the amount of cardboard used to box a set of glasses with specified dimensions.

- Dictionaries and Sets
- TagCloud: Build a tag cloud of the 2008 vice-presidential debates.
- Movies & Actors: Using the online Internet Movies DataBase build a dictionary of movies and actors. Given two movies find all the actors in the movies (AND), find the common actors in the movies (OR), find the actors in either movie but not both (EXCLUSIVE_OR). Given an actor, find all the co-actors that actor has acted with.
- BMI: Body Mass Index: Using real data from the Internet on a set of people, calculate their BMI, and then use least squares to find a linear regression and correlation. Extra credit: graph it.
- Breast Cancer Classifier: Build a cancer classifier from breast cancer study data to predict if a given cancer is malignant or not.
- Income Classifier: Build an income classifier from individuals’ characteristics (over 30K records from the Internet) to predict if the individual’s income will be greater than $50K or not.
- Vocabulary Quiz: Build a vocabulary quiz program.
- SpellCheck: Build a file spell checker that includes suggestions.
- Natural Language Processing: Calculate unigrams and bigrams in a text file.
- Natural Language Processing II: Create Markov chains from a given text and then use the chains to create new text.

- Classes: using instructor-designed classes to prepare for designing classes. We have found solitaire to be an excellent medium: we provide card and deck classes; students build a game. There are numerous variations on solitaire: e.g. World Of Solitaire.
- BlackJackSquare: Solitaire with blackjack-style scoring.
- EastHaven: A solitaire variation where cards from the stock go to all tableau columns.
- Golf Relaxed: Another solitaire variation.
- Aces Up: A solitaire variation that is a kids game.
- Spider: Yet, another solitaire variation.

- Class Design
- Elevator Simulator: Create three classes (Building, Elevator, and Customer) to use in simulating an elevator.
- Face Drawing Program: Create five classes of facial features (using Turtle Graphics) and build a face drawing tool around them.
- Minesweeper: Create a Minesweeper class and design a Minesweeper game around it.
- Protein Transcription: Create a transcriber class so you can take in a sequence of DNA bases, use a mapping of amino acids to codons, and yield a sequence of amino acids.
- Queue Simulation: There are four ATM machines in the student union. Should students form one queue or four? Create an event class and build an event-driven simulation around that class. Use the simulator to answer the question.
- Game of Life: Create a class for the Game of Life and then build the game around it.
- Traveler’s Dilemma: Write a program that plays the Travler’s Dilemma using at least one class and one exception. Test your game with ten different pairs of people. Analyze the results.
- Dilbert’s Carpet Fishing: A Dilbert cartoon has him playing an office game he calls “Carpet Fishing.” Using at least one class, write the game.
- Turtle Classes: Create a set of classes of graphical components of your own design for use in creating a TurtleGraphics picture of your own design.
- Dating Service : Create a dating service with your own matching algorithm supported by classes of your own design.
- Dominos: Create a Dominos game supported by classes of your own design.
- TurtleCar: Create a library of classes to support drawing a car using Turtle graphics.

This page lists Racket projects which are feasible for people who don’t have a lot of experience with the Racket code base. They’re mostly small, self contained, and would be extremely useful. Some involve writing a new library that would be useful to lots of other people, and some help fix or clean up some aspect of the existing Racket code base.

The best place to ask for help with any of these is on the users mailing list.

These are intended to be a collection of fun topics to explore, intended as exercises or mini-projects, but also interesting in their own right. If you implement one, then leave a link: different solutions can lead to comparisons of style and constructive suggestions. Finally, add more ideas …

- Graphics
- Draw some fractals: Mandelbrot set; Julia set; L-systems; Sierpinski gasket; Koch snowflake; space-filling curves
- Make a random maze; animate the drawing
- Tile a plane: rectangles – grid or herringbone; triangles; hexagons; Penrose tilings; quilt designs
- Animate a classic looking clock
- Animate a word clock

- Wordplay
- Find anagrams
- Find palindromes
- Make a scrabble or crossword helper
- Scan a text for haikus

- Puzzles
- zebra puzzle
- sudoku solver
- sudoku generator

- Calendars
- Day of the week of any given date
- When is Easter (and other holidays) in a given year?

- Cryptography
- Encrypt / decrypt simple ciphers and codes
- rot13
- Crack simple ciphers

- Programming tools
- Reimplement some standard library operations
- Reimplement some of the standard Unix tools

- Classical mechanics
- Animate a bouncing ball, then balls
- Simulate planets in orbit
- Pendulum
- Newton’s cradle

These are self-contained projects. Just create a new github repository, and start hacking. When you have something that works, release it on PLaneT.

- Implement a Rosetta code task: http://rosettacode.org/wiki/Reports:Tasks_not_implemented_in_Racket
- You could also re-implement or improve an existing Racket solution

- Math: Try some project Euler exercises: http://projecteuler.net
- Implement mini versions of classical programs (can be used as extended examples on the web site):
- Notepad using racket/gui
- Paint
- Calculator

- Data structures: hash array mapped trie, 2-3 finger trees, other purely functional data structures (some already implemented here).
- Code for doing OAuth
- Now available here
- Also available as part of ryanc’s webapi PLaneT package.

- Write bindings for libgit
- Work started here

- Write bindings to Authorize.Net
- Write libraries to interact with Wii Remotes
- Technical details on the Wiimote
- wiiuse has code for the Wiimote’s protocol, as well as Win/Linux bluetooth code
- Mac OSX Bluetooth Dev info

- Write libraries to interact with game controllers
- Write bindings to various Google APIs
- Authentication would be useful
- Other interesting things: docs (esp. around spreadsheets), maps

- Write bindings to the Github API
- Write bindings to the Twitter APIs
- Write bindings to the Facebook APIs
- Write bindings to Amazon AWS.
- Eric Hanchrow has some pitiful first steps which might be inspirational.
- Staying in the pitiful vein, a typed/racket effort by Ray Racine which is actively being developed.
- Greg Hendershott has untyped Racket code for the S3, SDB, SES, SNS, SQS, and CloudWatch services: PLaneT package, Github.

- Write XMPP bindings
- A starting point can be found here

- Bindings for a text to speech engine
- IRC log highlighter
- IRC client library (can be based on the gabot code (contact Eli), which is better for a library than rudybot)
- Bindings for Apple’s Core-* Libraries
- Write a better s-exp diff tool
- Write bindings to gobject introspection
- Use the Racket examples on Rosetta Code and the snippets on the http://racket-lang.org home page to make
`demo.racket-lang.org`

that show cases programs and snippets written in Racket. There’s a start of explanations of the home page snippets here: https://github.com/samth/racket-examples

For the more ambitious Racketeer …

- Make a web page (demo.racket-lang ?) that contains Racket snippets. Use the programs from http://rosettacode.org/wiki/Category:Racket to get started.
- Write a markdown parser (important: lots of tests; support at least popular variants that are used by stackoverflow and github)
- Norman Gray has a WikiCreole parser on PLaneT. It’s reasonably clear how to generalise that to cope with markdown, and Norman is working on this as a background project.
- Also available here.

- Write a YAML parser
- Now available on PLaneT.

- Write a gitolite replacement in Racket (contact Eli)
`#lang scsh`

— or better: write just a library for similar bindings (macros & functions), and make it into a language that has shell-like syntax- Write a blogging framework
- Write a Common Lisp compatibility layer (same functionality, but not all the core language features that would make this extremely difficult; for example: keep immutable pairs)
- Write a Clojure compatibility layer
- Started on one here but it needs a lot more work.

- Write bindings to SDL (note that there are Allegro bindings on planet).
- Work started here

- Integrate the existing parser-tools SRE with Racket regexps.
- Write some code metrics tools (number of functions, number of lines, etc) and integrate them with DrRacket’s module browser.
- Write image filters example

- Understanding GitHub: A Journey For Beginners, Part 1 (readwrite.com)

From their website:

Project Euler is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve. Although mathematics will help you arrive at elegant and efficient methods, the use of a computer and programming skills will be required to solve most problems.

The motivation for starting Project Euler, and its continuation, is to provide a platform for the inquiring mind to delve into unfamiliar areas and learn new concepts in a fun and recreational context.

The intended audience include students for whom the basic curriculum is not feeding their hunger to learn, adults whose background was not primarily mathematics but had an interest in things mathematical, and professionals who want to keep their problem solving and mathematics on the edge.

The problems range in difficulty and for many the experience is inductive chain learning. That is, by solving one problem it will expose you to a new concept that allows you to undertake a previously inaccessible problem. So the determined participant will slowly but surely work his/her way through every problem.

]]>

]]>

as well as a Computer Science 101 course.

The database course at least might compliment my efforts towards the Microsoft certification I mentioned in one of my previous post:

**Microsoft Technology Associate (MTA)**

]]>

So I wanted a way to recall these recipes within the shell so in the beginning I can always follow the recipe when I’m designing, in this case, functions.

So in python, it was easy, just created my own module and wrote the following functions (one expandable one so when I Learn more recipes I can add them in, and a second one for immediate use):

def recipe(n):

if n == “htdf”:

print(“Step One: Examples”)

print(“Step Two: Type Contract”)

print(“Step Three: Header”)

print(“Step Four: Description”)

print(“Step Five: Body”)

print(“Step Six: Test”)

else:

return “”

def htdf():

print(“Step One: Examples”)

print(“Step Two: Type Contract”)

print(“Step Three: Header”)

print(“Step Four: Description”)

print(“Step Five: Body”)

print(“Step Six: Test”)

But I was having trouble in Racket(BSL), although I cheated a bit by using an image, it doesn’t really work as a function… this is what I have so far but I haven’t been able to emulate what I did in Python in the Racket(BSL) shell DrRacket:

(define (RECIPE n)

(if (string=? n “HTDF”)

[I put a jpeg of the receipt in point for here]

“false”))

Now the problem with my cheat is that I can’t call the function remotely, and have been using the (require module_name) that loads it right at the beginning and not as a callable function.

So if anyone has any ideas on how to replicate what I’ve done in python in racket(BSL), I’m all ears!

]]>Here’s the intro:

“The character wakes up in a strange place populated by gnome-like creatures. She has been sent here to learn the ways of magic. The gnomes are in need of her help, they know a little magic, but don’t have enough to accomplish simple tasks. They need her help, and she needs theirs.

With some guidance from the gnomes, she takes her first faltering steps with magic. She begins to master her power bit by bit, while trying to prepare for a scary and dark future.

Through a series of quests initiated by the denizens of the Enchanted Crater, she begins her training as a master wizard.”

Essentially master wizard in this case means master coder/programmer.

So I did a little digging and found some more games that do the same (see related article below).

- Games that teach programming: A brief overview (gamasutra.com)