C – Antti Juustila

Archiving old course materials

Returning back to this post from two years ago, I am archiving here the course material which was last updated in March 1999. Course was on programming a multiple document interface Windows app with C.

The material, written as a short booklet, instructs the student to implement, step by step, an app to draw simple shapes. The app also uses components as the drawing code is placed in a dynamic library (dll).

The material ends at the point the app can be used to draw simple lines in multiple windows.

Students are supposed to extend the functionality to draw other simple shapes, filled or not, and saving and reading the drawings to/from files.

Unfortunately I think I’ve lost the code and the .doc file for this material. Don’t even have a Windows PC anymore so… Could try out if the code still works, using Windows in virtual machine on my Mac. Would this still be compatible with current Windows API:s, don’t know.

Ohjelmointiympäristö Download

Blasts from the past

Two blasts from the past. Sorry for the long post but hey, this is a frigging blog, not some social media service for attention spans of mere seconds.

First “blast”

When teaching (exercise support sessions) over Zoom, we course teachers have a private chat in Slack to coordinate who goes to which breakout room to help students asking for help. When there’s no acute problems to address, we occasionally chat about random topics.

Yesterday I was participating from the bed using my laptop since I’ve got the flu but was well enough to participate somewhat.

I have had this idea to write the Data structures and Algorithms course materials into a book format. Not to be sold in book stores, but just shared to the students as a single PDF / eBook file.

I remembered doing exactly that, very very long time ago in a discontinued course, and happened to mention this to the other teachers in Slack; that I couldn’t find the book in my computer archives.

“Hold my beer”, said one of the teachers, and voilá, he uploaded that course pdf “book” from 1999 to the Slack channel! As it happens, he was at that time or just before, a student on that course and had archived the material! He is a lot better than me in archiving, apparently, so thanks JLa for that! He also participated in teaching (also) this course, as far as I can remember.

A snippet from the course material for Programming environments course.

The course, Programming environments, was originally a Mac programming course, by our Department Mac guru who left us a long time ago to work in the industry (good for him). Then later, I implemented the course for programming with C in Windows (thanks to Petzold’s book). Even later I also implemented a version to teach Symbian C++ programming in Nokia devices.

Anyhows, I liked the idea to provide the material in a “book” format to the students, and even distributed the book in an eBook format for them to read. A total of 45 pages. I wish I’d find the original editable document somewhere from my external backup drives or USB drives, would be fun to have it.

Maybe I’ll do this sometime again for some course. Writing can be fun.

The second “blast”

A thing I did find when browsing through my archives, was a department plan to arrange teaching for the study year 2009-2010.

Especially interesting for me was to check out the list of courses our team (software engineering focused teachers/courses) at the department taught that study year (table below).

I will just list the courses about programming or strongly programming related or strongly technical courses:

Finnish course name	English course name
Algoritmit	Algorithms
C ohjelmointi	Programming in C
C++	C++ programming
Johdatus kääntäjiin	Introduction to compilers
Johdatus ohjelmointiin	Introduction to programming
Johdatus tietorakenteisiin	Introduction to data structures
Logiikka	Logic
Ohjelmistojen testaus	Software testing
Ohjelmointikielten periaatteet	Principles of programming languages
Ohjelmointityö I	Programming assignment I
Ohjelmointityö II	Programming assignment II
Ohjelmointityö III	Programming assignment III
Ohjelmointityö IV	Programming assignment IV
OHJY/MacOS/iPhone	Programming environments / Mac/iPhone
OHJY / Windows	Programming environments / Windows
OHJY / Unix	Programming environments / Unix
OHJY/ Symbian	Programming environments / Symbian
Olio-ohjelmointi	Object oriented programming
Projekti I	Term project for external customers, programming
Projekti II	Term project for external customers, often included programming
Rinnakkainen ohjelmointi	Parallel / concurrent programming
RTCS	Real time computer systems
Tietokantojen perusteet	Introduction to databases
Unix perusteet	Introduction to Unix

In some of those courses, doing actual programming by the students might have been a relatively small part of the course. And some of the courses were not offered every year. Just not to inflate the amount of actual programming done in some of these courses.

But – if you compare these strongly programming focused courses of that time to the list of current programming or strongly technical courses in the study program:

Finnish course name	English course name
Laitteet ja tietoverkot	Devices and Data networks
Ohjelmointi 1	Programming 1
Ohjelmointi 2	Programming 2
Tietorakenteet ja algoritmit	Data Structures and algorithms
Tietokannat	Databases
Ohjelmointi 3	Programming 3
Ohjelmointi 4	Programming 3
Ohjelmistojen laatu ja testaus	Software Quality and testing
Bachelor project	Programming project for external customers
Master’s project	Systems development /analysis project for external customers

So at that time around 2010, we had a total of 24 very technical/programming courses in old study program. Currently we have only 10.

There are courses on software engineering and such nowadays too, but they usually do not include learning to construct things and spending a relatively significant amount of time doing that – that is what I mean by a technical course here, and what was done earlier.

The current study program at the MSc level does not have a single course focused on programming. No more than 5-6 years ago, we still had at least one, Embedded software development environments, focusing (mostly) on distributed mobile programming (taught by me and some other teachers). Before that, we (including me) taught, together with Tampere University of Technology, Mobile systems programming course (Symbian, J2ME). All discontinued.

Currently we have nothing about parallel / concurrent programming in the study program. Last week I did one very small demo to at least show an extremely little thing about concurrency in my course on Data structures and algorithms. To let the students at least to be aware that something like this actually exists and could be done. So like 15 minutes of that topic in the whole study program.

Principles of programming languages, logic, compilers — totally gone from the study program in just over ten years.

You know (and I know) that there are as many opinions than there are you-know-what, but in my personal honest opinion, this is not good. Considering the needs of the local software industry.

Of course the technical topics of today would be perhaps different and obviously should be up to date with modern technologies. But if these kinds of topics and the deeply technical perspective on things is missing, there is not even the chance to discuss if they would or should be updated.

…

Well, maybe this is just another case for this:

Image of an old man yelling at the clouds from the Simpsons — Old man yelling at cloud, again

Useless but fun

As you, my dear reader, may have already noticed from my previous posts, I am currently teaching a course on how computers work for first year students. Very high level, simplified stuff since there’s only ten hours of lectures and ten hours of exercises for this.

One course exercise is about logic gates. After the lectures on the topic, students use the Digital Logic Sim tool to design some simple logic gates. Starting from AND and NOT gates, they build a NAND (the universal) gate and then OR, NOR and XOR gates using these gates in the project of theirs.

Building an OR gate using three NAND gates.

After this, students design two gates handling a byte (eight bits). Logic gate (or chip) ISZERO, checking if a byte has a zero eight bit integer value. ISEVEN gate checks if a byte is an even number.

Finally, they combine these two gates to check if the value in the byte is an even number and greater than zero. In the end they will meet the question whether the byte is actually signed or unsigned. Since then they need to take into account if the most significant bit (msb) is zero or one. In a signed byte, the msb value of 1 means the value of the byte is actually a negative integer.

Anyhows, in one of the lectures I mention that:

Anything that can be implement in hardware, can also be implement in software. And anything that is implementable in software, can also be implemented in hardware.

So a thought popped in my head out of nowhere: “Should I implement a demonstration in C that actually does implement these gates in software, starting from the boolean operators && and !, not using the ones already in the language?”

Of course I had to do that. Useless and fun. Suits me just fine.

Logic gates AND and NOT are quite simple to implement using boolean operators of C:

bool and(bool x, bool y) {
	return x && y;
}

bool not(bool x) {
	return !x;
}

Then implementing the NAND gate using NOT and AND:

bool nand(bool x, bool y) {
	return not(and(x, y));
}

And the final example here, the OR operator implemented using three NANDS (compare this to the image of the OR gate above):

bool or(bool x, bool y) {
	return nand(nand(x, x), nand(y, y));
}

The rest you can find following the link above, including a demo app in gates.c and an output file from the app.

What I would like to change in the implementation is to have two implementations of the ISZERO gate, since signed and unsigned bytes should implement this gate differently.

But enough of these uselessnesses. For today, at least.