Assembly Language: Class Project 2

From the syllabus:

Each project is 15% of your course grade, so it should have some pretty good stuff.  Conversely, the total end-to-end time for the project is only a few weeks, so keep it manageable!

Your final project grade is a multiplicative product of three factors:

• Ambition (or hubris) measures how much work you attempted.  A project with a high ambition score will attempt something significant but achievable.  A project with a low ambition score will attempt something trivial, like a 201 homework.
• Progress (or completion) measures how much you finished.  A project with a high progress score not only works, but includes a well-rounded set of features including a clear user interface, error checking, and self-checking.
• Comments (or style) measures how well the code is structured and documented.  To get a high grade, put clear high-level comments at the top of every file, document the major chunks of your code inline, and include a short clear README saying what the code does and why.  To get a low grade, use a haphazard comment style with poorly spelled sentence fragments, copy-and-paste big swaths of code instead of using small clean functions, and use comments primarily to mislead the reader or turn off chunks of non-working code.

Project Deliverables

   November 2014      
Su Mo Tu We Th Fr Sa  
16 17 18 19 20 21 22  
23 24 25 26 27 28 29   <- Thanksgiving break
   December 2014      
Su Mo Tu We Th Fr Sa  
    1  2  3  4  5  6       <- rough draft due
 7  8  9 10 11 12 13   <- project presentations
14 15 16 17               <- final exam, and final version of project

On Monday, November 24, I'd like you to describe in class your project topic.  We do these out loud so everybody can hear each other's ideas, making it easier to form group projects if you'd like to do so.

On Wednesday, December 3, I'd like your rough draft code, which should work and do most of what you want, but not necessarily do everything you want to do, or be fully polished or tuned. 

The presentation is a very short, 5-minute presentation in class on December 8 & 10.   Your presentation should clearly describe WHO you are, WHAT you did, HOW you did it, and WHY you chose to do it that way.  Bring a laptop to project your code, demo, slides, and/or figures, or email me your presentation materials the day before, if you'd like to present from my laptop.

The final code should be fully debugged, polished, tuned, commented, and include at least a short README explaining what it is, and what its results mean.  You'll be graded on a combination of ambition, correctness, completeness, and comments/style.  Style and clean code count!  Due midnight Wednesday, December 17, the day of the final exam.  (This is scheduled after the presentation, so you can follow any suggestions or ideas you get during the presentation.)

Typical grade breakdown: project grade = 30% rough draft + 20% presentation + 50% final code ambition * progress * comments

Example Project Topics

• Benchmark and then tune the performance of any existing program, including a homework from this or another class.  No assembly code is needed, although reading the disassembly can help you understand performance!
• Extend your project 1 project: make it faster, more interesting, more parameterizable, or run on a different language or machine.
• Do something interesting with SSE.  Almost any code where different floats do different things very interesting under SSE.
• Use signals or mmap to do something weird to any program.
• Write some ARM assembly language.
• Write or modify a program to do "something useful" in assembly language.  Useful things include:
• Interact with the user in classic CS 201 style.  This means lots of string processing, like gets and puts.
• Do anything interesting in assembly, like the bit rotate or bit-scan forward instructions.  Add a nice callable C++ interface.
• Switch between user-level threads.
• Create a PC Boot Block, which is actually just up to 512 bytes of 16-bit mode x86 machine code at the start of a (usually emulated) disk, that the (usually emulated) CPU loads and runs on startup.  Your boot block can do anything it wants to the machine at that point--it's effectively a tiny operating system! 
• Take off from any homework problem you like, and do something interesting with it.  
• Start with any interesting C++ program.  Disassemble it.  Figure out and add comments to each line of the disassembly--every time I do this, I learn things I didn't know I didn't know!
• Design a new CPU instruction set, and write a little CPU emulator to execute that instruction set.  This is easier than it sounds!
• Embrace and extend some assembly-related code from the net--but be sure to cite your sources, so I can grade you on what you've added, not what you started from.
• Write or modify a program to do something high-performance in assembly language.

Or pick your own topic!