Mips2C: programming from the machine up

Programming in C is close to the machine and the language was originally designed to code an operating system. The approach I take is to start from the machine layer, though in less detail than in a computer organization or logic design book, using the MIPS instruction set to illustrate principles. The first part of the book uses C syntax as “pseudocode” while demonstrating how to convert high level language code to MIPS assembly language. The second part of the book introduces C in more detail, building on the MIPS part. While using C as “pseudocode” is not strictly in keeping with the spirit of pseudocode, which is meant to be sketchy and leave out a lot of detail, the idea is to introduce those not familiar with C-style languages to the notation ahead of the second part of the book where C is introduced properly. Why MIPS? The MIPS architecture is simple and relatively easy to understand, and in wide use in embedded systems. The SPIM simulator is a handy and free learning tool. Why C? It is in wide use, and closer to the machine than other popular languages with similar syntax. Learning the hardware-software interface in C is a lot easier than in a language with a managed memory system and complications like classes and objects. Topics covered in the MIPS part include memory organization, alternative approaches to stack frames, local and global variables, the heap and dynamic allocation, function calls including parameter passing and recursion, how C relates to machine code (e.g., arrays as pointers) and – a brief segue out of C space – how objects and methods are implemented. I cover objects because they provide a useful example of a dispatch table, and a basic understanding of how method calls could be implemented is useful given how widespread object-oriented languages are. The C part builds on this, introducing C in a little more detail including how formatted input and output work, basic C constructs, the UNIX command line (basics of scripting and make), program structure, calling library functions with function pointers and bit manipulations. The book is tested on a second-year class whose prior courses used C#, but it could be used in an introductory class. The machine organization component is not very detailed; the idea is to present just enough to support the programming concepts. The principle aims of the book are provide
a foundation for understanding deeper programming concepts like recursion and
the background for courses that require an understanding of the hardware-software interface like compilers and operating systems.
The index contains separate entries for exercises so you do not waste time looking up a concept only to find the index entry points to an exercise. The test of how well this works is in how well students do in follow-up courses – so far, my experience has been positive and I hope yours is too.