This is the archived website of SI 413 from the Fall 2013 semester. Feel free to browse
around; you may also find more recent offerings at my
teaching page.

Overview

This is the main part of your project, and it consists of writing a
slightly-more-substantial program in your language. There is no starter
code here; you have to write the program "from scratch".

You must choose one of the problems listed below for your program to solve.
Some of these problems are rather open-ended, meaning they aren't as precisely
specified as most of the assignments and labs in this class. On each language's
page, I've suggested which problems might work best for that language, but
this is only a suggestion, not a hard-and-fast demand. This means first
of all that you will need to tell me, via a README.txt text file
included with your submission, exactly what your program does (like which
problem you are solving) and how it
works at a high level. It also means that you have some more decisions to make.
If you are at all unsure how to proceed, just ask! And keep in mind when
deciding which problem to tackle and how to make your program work that:

It is your job in this phase to convince your instructor that you
have learned the most important features and quirks of your programming
language. Notice that I said "your job". This is actually explicitly
worked into the grading scheme (see below). So for example if your Clojure
program looks exactly like a Java program, and doesn't take advantage of
or show off any of the aspects of Clojure itself, you will not receive a
very high grade. If you choose a simple problem for Ruby, and therefore solve
it in a 30-line program that anyone could write,
your grade will reflect this lack of demonstrated expertise.
If your brainfuck program consists 90% of copied code from the internet
(even if it's all properly attributed/documented),... you get the idea.
Again, this is not meant to be stressful but rather
freeing - there is little chance of you missing some "stupid little detail"
and being highly penalized for it. Again, if you're unsure or anxious,
ask!

Grading

Phase 2 counts as 50% of your total project grade. Remember that it is
your responsibility to choose a problem and a way of solving that problem
that shows off your mad skills in the language. Here's a break-down of
how your grade will be computed:

30%: Coding style. Remember that the "audience" of your code is someone
who might not be that familiar with the language. This means you need to be
extra careful to document clearly and extensively what is going on.

30%: Appropriateness. What I mean by this is, how well does this
program show off the features of your programming language and demonstrate
that you have begun to master it? Does your program represent a significant
accomplishment? It should represent more work than a lab, for example!

40%: Correctness. Your program needs to work. It needs to solve the
problem specified. It should behave as you describe in the README.txt
file. Note: it will be very bad for you if, say, it doesn't compile!

The Problems

Remember, these are open ended so you can add or subtract aspects of the
problem if that is more appropriate for your language. But if you do that,
you should definitely run it by your instructor first! My suggestions of
which problems might be best are listed on your language's page, so start
there.

Compiler
Write a compiler, i.e., a program that translates from one language to
another. There are actually (potentially) three different languages here:
the language you compile from, the language you compile to, and the language
the compiler itself is written in. Of course one of these must be the language
of your topic! It's OK if, say, the compiled-from language is a somewhat
simplified version of a popular, standard language. Make sure you check
with your instructor on the choice of languages for this.

Make
Write your own
version of the popular *nix utility make You definitely
don't need to include all the features of the "real" make, but
you should also add some new features. For example, if your language supports
concurrency, you could have the program keep running in the background
forever, automatically re-making any target whenever any of its prerequisites
is changed. That would be neat-o!

Matrix Calculator
Write a program that can read in matrices (filled with integers), print them
out, assign names to them, add, subtract, multiply, and any other operations
you want to support. Many of your languages will have easy-to-find libraries
that will do these computations for you - don't use them.
You will have to define (and document!) the format of
the input, as in, how to type in a matrix. Additional operations you might
support are determinant, transpose, or adjoint. Ask if you need help in
figuring out the math - that's not supposed to be the hard part!

Image Creator
You prompt for or otherwise read in a specification of an image, with
things like circles, rectangles, lines, triangles, text, or anything else
you like. Each "component" of the image must specify things like what its
dimensions are and where it goes. The "where it goes" part might just be
(x,y) coordinates or if you want to be fancy you could also allow it to be
relative to another component. Then you produce a gif or bmp or png or
ppm file with that image in it. You will have to define (and document!)
the precise format of how the input is specified, of course.

Game Scheduler
In most organized sports with set schedules, many factors are taken
into consideration in making a schedule for the season: rankings from
the previous season, which division/conference each team is in, balancing
home and away games, bye weeks, etc. For example, check out the
way it's done in the NFL. Make a program to compute a valid,
random schedule, given whatever the constraints are (and team names, and
any other information) for the league. You might just make a valid
NFL schedule, or you might need to be more general than that - it depends
on your language and how you decide to do it.

Hangman
Write a program to play hangman. A word or phrase should be randomly
selected from a (possibly huge) text file, and then the user gets to
guess letters. If the letters are in the word, they get filled in, and
otherwise a part of the man gets drawn. When the man is completely drawn...
well hopefully you are familiar with this game. This could be console-based
or fancier with GUIs.

TODO list
Write a "to-do" list program. This should (at a minimum) be able to read
in new to-do items, and mark existing items as "done" in some kind of nice way.
Other features that would be nice are persistence (save/load from a file so
that exiting a program maintains the list), and concurrency (program can
be running on two different terminals at the same time, and they are
checking and updating some shared file, displaying updates immediately
as they are entered).

Vending Machine
Make a program that simulates the actions of a vending machine. At the most
basic level, there could be just one price, and the program waits for
just a few different keystrokes indicating nickel, dime, or quarter,
until that amount has been paid. Then the change is given (probably by
printing out some indication of which coins it includes)
and the program terminates. To make the
program more sophisticated, you could have multiple items with different
prices, allow more denominations of money (penny, 1/5/10/20 dollar bills, ...),
or read some or all of these specifications from a text file.

Game with hidden agenda
Write a simple game (maybe hangman from above, or battleship, or tic tac
toe, or...) that secretly does numerical computations in the background
while the user is playing. For example, the program might be searching
for extremely large prime numbers, or trying to factor a reasonably large
number (perhaps for RSA cracking). These computations should be running in
one or multiple threads without affecting the gameplay. The input and output
from the numerical computations should come from text files in the directory,
according to your specifications in the README.txt file.
Importantly, when the game exits, the computations should halt immediately.

Frequency count
Read in a text file and count, record, and finally display the frequency of
each letter, or each digit, or each word that appears. If you want to be
fancier, count the frequency of words, stripping away all punctuation and
ignoring whitespace and capitalization, and sort the results to only display
the 50 most popular words, along with their frequencies.
You had better count words instead of letters if your language
is in this list!
A possible extension would be to count frequencies in multiple files
simultaneously and only display the accumulated results when all counts finish.

Guess the language
Like the frequency count, but in this problem you want to figure out what
(human) language the input is written in. You compare each word in the
input with the words in a bunch of plain-text dictionary files, one
dictionary for each language. For EVERY
dictionary that you find the word in, you increase the "count" for that
language. At the end, you return the name of the language with the highest
count, that is, the (human) language that contained the most words that were
input. To help you out, there are some languages' dictionaries
in the folder /courses/roche/413/dicts.

Find the missing digits
I remember some math problems from grade school where you get a
long-number addition or multiplication problem where some of the
digits are x's, like

4x89x
+ 32xx7
-------
7x150

and you have to figure out a possible setting for all of the "x" digits
that makes the math work out correctly. (Notice that each "x" can be a
different digit!) Write a program to solve this problem, by taking
the three numbers as input (with x's in them), and the choice of operation
(+, -, or *). There may be many solutions to a single problem; you decide
whether your program will just produce one of them, or all of them, or
give you one and ask if you want to see more, etc. This isn't grade school
so your program should be able to handle some big numbers!

Sports Ticker
Read a list of sports teams, or leagues, or maybe even specific games,
and then make an interface that continually gets updates for the relevant
games and displays the score updates on the screen. Depending on your language,
the output could just be in the terminal, or it could be some kind of
GUI. I recommend the ESPN API for this purpose:
here it is.
Note: you will have to register for a free "developer key" and your program
will be limited to 3 lookups per second and 7500 lookups per day.

Rock, Paper, Scissors
Write a program that will play the Rock, Paper, Scissors game
against a human opponent. A good "strategy" for your computer
player might be to count the frequency of which move the human
has made most often, and then choose the counter-move to maximize
your computer strategy. The game should keep track of the total
win-loss-tie numbers as the game progresses.
There are many small variations you could do here, depending
on how complicated you want your program to be:

Make the
computer AI strategy more sophisticated

Introduce
a configuration file which would allow variations such as
Rock-paper-scissors-lizard-Spock.

Make it a multi-player network game

...

???
If you have a better idea for a problem to solve in your language,
I'm open to it. Of course you should run it by your instructor first!
But it doesn't need to be a formal proposal or anything like that. A short
description like for any of the other problems above would be fine.

Submission

Unless otherwise indicated, I will compile/run your program the same was
as I did in Phase 1 of the project, as specified on your language's page.
You should submit all the code, as well as a README.txt
file describing what problem you solved and how, using the normal
submit program that we use in labs, as
"413 proj 02". Be sure to check the list of files that actually get
submitted in case there are any missing. And as always, submit early and
submit often!

Material contained above is made available
for the purpose of peer review and discussion and does not
necessarily reflect the views of the Department of the Navy or the
Department of Defense.
Some links above are to sites that are not
located at the United States Naval Academy. The USNA is not
responsible for the content found on these sites. In addition, the
content of these sites does not reflect the opinions, standards,
policy or endorsement of the Naval Academy or the United States
Government.