Archive for the 'course improvement' Category
last assignment, tile and map files

it might be useful to have a last assignment along the lines of “what in the course should be the same, what should be different, what should the instructor do the same, different” etc. like TASD had this year.

When people make their zip files, have them include in the zip the gb binary and the tile and map files (not the exported versions but the real, live editable versions).

next year’s installation needs an include directory for the standard libraries.

standard libraries should print out their version #s at assembly (perhaps date is version #?)

BigSprite optimization, dependencies etc.

BigSprite needs to be optimized.

  • It shouldn’t update all the sprites every time one BigSprite gets moved
  • Can collision detection be optimized?

The dependencies stuff needs to be cleaned up.

Some feedback from Austin Patten

This course has been of more value to me than any of my other programming courses by far.
I know we already went over jp, jr, call, and how to not hard code stuff, however that has been the hardest part for me.
I would like to see a tutorial on when to use jp or jr or call and which needs a ret and where ret actually returns.
Personally i just tried each until one worked, which isn’t the best way to go about things.
Another tutorial that would be nice is a hardcode vs modular code and how to go about that.
Finally a math tutorial would be extremely helpful. Figuring out how to multiply and
take the 3rd root of 16bit numbers is difficult.


more clarity, emphasis, reiteration on the goals for the course. What do I hope students will learn and how will they learn it? Distinguishing between information, process, design, etc.


give examples of using flags/variables for

  • concurrent operations (processing bullet while sprite moves in MainLoop, for example)
  • having things happen 1 time (triggering sound once on keypress, for example)

use a model such as The Little Lisper (book) as a way to drill in assembly language opcodes, programming, techniques…

  • need more examples of good and bad programming practice. Why use source code libraries? Why keep things modular? Distinguishing between generic and specific needs, self-documentation, importance of good naming of variables and labels…
  • more examples and explanation of hard coding versus dynamic functions and why to avoid hard coding.
I’ll prolly get boo’d for this…

…but I’m gonna throw it out there anyway.

I love the fact that we are getting to program gameboy games and stuff. In fact, this is probably my favorite class ever. I think I have learned more in this class than any other. I have no real complaints about the class, but I feel a lot this knowledge is going to go to waste. So here are a few of my suggestions:

  1. I think the assignments still need to be awesome and open ended and free, but I think some structural elements of programming should be required in them. For instance, require a game to use a dynamic linked list for something or a binary search tree, heap, or hash table (Ok the last two are pushing it). Maybe make them write a search or sort algorithm in assembly. I don’t know if a lot of these things are really possible for the z80, so you could make it a theoretical program and give them a STRUCT and SIZEOF command (Similar to what x86 has) and have them write out the logic needed to produce a certain data structure.
  2. With MANY new and well defined ideas on sprite control, sound and collision, these things can easily be put into a library which would allow students to express themselves in their programs freely, but focus more on the fundamentals of assembly and less on the fundamentals of z80ASM. I think it might be benificial to talk about some of the big differences between z80 and x86 (Like LD being MOV, different registers, etc), but I am don’t think a ton of time needs spent on that.
  3. Also, some form of written guide to assembler would be nice explaining of the basic concepts of assembly “how the computer must handle memory, how it can only execute three types of instructions (sequential, decision making, and looping) and what happens when a function is called.”<– What the CS department thinks you need to learn from Assembly.

With all that said, maybe it shows that I am a Computer Science major and tomorrow I have to figure out how to write a dynamic linked list and sorting algorithm it in x86 assembler so these things have been on my mind. I guess I will see how that goes.

more structure, more practice
  • have more traditional assignments in the first 1/2 of class that get people practicing use of the tools.
  • have a traditional assignment be rather simple but have a lot of them. For example “push and pop 3 values from memory onto the stack.”
  • the traditional assignments would not be shared as the current assignments are.
  • give models of how to emulate logic in C for example how to write a while loop, an if loop, etc. Give assignments to practice this structure
  • make example code more modular
  • set up an extra credit system for people who add meaingful content to the source code libraries (could still happen this year?)
  • skip the Z80 entirely. Just focus on the GB CPU.
  • go over logic of game more and support this with assignments: MainLoop, score, window, random…
  • more lab time?
  • skip everything we did at the beginning about the architecture. That’s for another class.
  • more distinction between routines and macros with practice assignments to support.
  • more detail in passing parameters, how to write a subroutine, etc.