Appendices
- Algorithm analysis <> A back of the envelope method to determine how algorithms and data structures scale.
- Conditional Compilation <> When you are unsure of which path to take while designing a program you can use conditional compilation to try them all. They are great for building tests into the build by setting a single flag. I use them when I create menus from the functions I have created.
- Data structures <> Data structures hold the data we process with computers. Choosing the correct data structure for the task at hand improves efficiency. Choosing poorly leads to sluggish behavior, followed by complaints.
- Data types <> There are a variety of data types from integers to floating point to strings. Knowing how much memory each requires aids us in building compact data structures.
- Define & declare <> We define functions starting with a fingerprint followed by lines of code. When we declare a function we are only providing the fingerprint portion so the compiler can put it into its lookup table. This makes the compiler complain much less.
- File I/O <> This is a short primer with examples of reading and writing data files. Storing all the data generated around the world fills many servers. These methods are used to store and retrieve all of that data.
- Formatting notes <> Formatting is very personal to programmers. Get three programmers in one room and they will all want to use different formats to write code. Some forms can be almost unreadable to those who use other methods. Luckily, we have editors which can switch from one style to another with a keystroke or two. Thank you :)
- History <> A little background on computers and my journey. I find it useful to know why certain things are done the way they are done. We all build on the work that was done before we came along. However, it is good to know why our forebears took a certain route over the other.
- Memory <> This is a short study on the various types of memory in a computer. From a hardware and an operating system perspective. Why should I use stack memory instead of heap memory? How volatile is the storage medium I am using? How much heap memory does any operating system give me when I start a process running?
- Philosophy of design <> Training, study, and experience formed my philosophy of design. I stress seeing things from the user's perspective. If they're not satisfied the people who they report to are not satisfied. That devolves to you. Make sure your design does not frustrate the user. Documentation is great, but when a user interface is intuitive, the user feels comfortable quickly. Then they can get their work done efficiently. Don't get in their way.
- Problem solving <> Here are some collected notes on how to solve various problems.
- Program structure & flow <> Here I discuss the various parts of a computer program. Knowing the parts lets you read other programmer's code more efficiently. You will be able to locate the various modules so you can determine the program's flow of execution and which data structures it uses. Reading code is a major part of this course. Doing it efficiently and effectively is important to your continued learning.
- Resources & resource compilation <> Windowing code requires certain resources such as menus, dialog boxes, windows, and icons. They need to be compiled and linked into your application. Here are a few notes on the process.
- Scanning large data sets with awk, sed, and grep <> There are many tools built into Linux, or in our case MinGW. These three are very useful for scanning large amounts of data quickly to create reports or locate data. awk is a language which can be used for text processing and extraction. sed is a text editor. grep is used to find regular expressions in your data set. Using these three tools lets you scan TB size data sets to extract just the parts you want.
- Scope <> An application is built from a number of parts. They could all be in one file or they could be spread over a number of files. Scope describes where any variable is accessible. Sometimes you only want a variable to exist within a function. Other times you want a variable which is active during the entire life of the application.
- Sofware engineering <> This is a set of notes on how to design an application or suite of tools. Software engineering also includes dealing with the client. Taking notes as you talk with the managers, supervisors, and end users of your prospective project. People and business skills are as important as the ability to craft code.
- Tail recursion <> I don't think recursion could be taught without using the Fibonacci series. Each level of the recursion stores its information on the stack. When the recursion meets its goal all of those stored frames pop off the stack to calculate the result.
- Workflow <> This describes the work process of editing, compiling, and testing. It shows how to use the editors, compilers, and operating systems to make life more efficient.
- Appendices zipped