A decade as an Educationist - Part I - QCR

Following on from a brief preamble, here I note down my thought process as an educationist, and how that helped create one of the courses I teach.

As you start to walk on the way, the way appears – Molana Rumi        

While Namal transitioned from an affiliate college to a degree awarding institute to a university, I had the chance to teach the following set of courses over the past decade: Artificial Intelligence, Operating Systems, AI for Games, Introduction to Computing, Discrete Maths, Digital Logic Design, Neural Networks and Fuzzy Systems, Philosophy for computer scientists, Quantitative and Computational Reasoning, Analysis of Algorithms.

Some of these courses have had a chance for multiple offerings, some of them evolved over the years, but here I’ll be focusing on just the 4 courses that I’ve been offering recently. I’ll walk you through their design one by one, but first I’d like to disclose my method - how I go about thinking of creating an educational experience, for myself and my students. What goes into the design is a set of my own ideals, departmental ideals and finally the institutional ideals. Here’s a glimpse.

My own ideals/beliefs as an educationist:

1. As an educationist I sincerely believe in change through education, as opposed to change through politics or some other process. But educating the mind without educating the heart is no education at all, emphasized Aristotle.
2. If the world was inhabited by understanding, patient and creative thinkers, doers and self-governors the world would be a healing place - as opposed to the world created by myopic and self-entitled consumers, or jobbers with marketable skills.
3. Important things have names and names ought to stay true to their respective meanings and functions, for example PhD, BS, CS - as opposed to PhDs getting allergic reactions to philosophy and CS grads getting reduced to programmers.
4. Students are a reflection of their teachers; they have goodness to the degree their teachers are good. This means that if my own courses and its instruments are mere plagiarisms and not representative of my own mentioned ideals, I cannot expect my students to do anything other than plagiarize, in turn.

Institutional ideals:

1. Students to become tomorrow’s leaders, is the founder's vision.
2. Shaping those who will shape the future, is a beautiful and pragmatic motto.
3. Excellent graduate attributes define the above-mentioned shape, e.g. Faculty and students need to be: thoughtful, technically expert, great listener, great speaker, passionate towards education, self-accountable, respectful, experimenter, avid reader, trustworthy and trustful.
4. Points of curricular emphasis for Computer Science program:

• Programming tasks in almost every course.
• Report writing in almost every course, with stress on analysis of data/problem.
• Data science tasks in as many courses as possible.
• Python is the choice of our programming language.
• Integrated, end-to-end projects in as many courses as possible.
• University core with liberal arts foundations for nurturing critical thinking and essential humanity.
• Every course to meaningfully affect our excellent graduate attributes.

My design principles:

I need to translate the ideals to a minimal, meaningful and actionable set of bases, and I need to touch as many of these bases as meaningfully possible in the 4 years of every undergrad student that comes my way. This way I’m forced to have a course level view as well as a bird’s eye view of all my courses lapsed over a period of 4 years. Additionally, some of the students would make it into my research group and some of them would do final year projects with me. Keeping this integrated picture in view helps me think of what I do as a mini-program itself, through which each computing student passes. Lastly, each course of mine should at least be the kind of course I wish someone would have taught me when I was in my undergrad.

My mini program:

• Quantitative and Computational Reasoning – University core – Semester 1
• Introduction to Philosophy – University core – Semester 2
• Analysis of Algorithms – Computing core – Semester 5
• Artificial Intelligence – Computing core – Semester 6
• Final Year Projects and Deep-AI research group activities for some

The 8 permanent bases for each item in my mini program:

Based on whatever has been listed thus far, I've interpreted it as follows.

By the time our CS students graduate from Namal, they shall be:

1. Habitually thoughtful
2. Patiently scientific in inquiry
3. Sincerely creative in efforts
4. Compassionate in expression
5. Proficient in Python programming
6. Proficient in analytical writing
7. Proficient in data science projects
8. Proficient in integrated projects

Quantitative and Computational Reasoning (QCR)

As is obvious, QCR isn’t Intro to Computing or Programming in the garb. It truly aims to shape a non-gullible modern citizen of the world, where the citizen should be able to make use of his/her computational skills to make sense of the place he/she occupies using large data publicly accessible. But one has to gradually get there, as there are always some students in this first semester class who have never operated a desktop or a laptop. Bypassing the development of computational thinking in our students and getting straight to programming is an offense in my opinion, but one that is rampantly being committed almost all over the world.

It must be obvious to the academicians that the action verbs used in CLOs have a different vocabulary than the sterile labels prescribed by the accreditation industry, but “feels at home” has the exact meaning we want to attain regarding the situation of our students’ world.

Eventually, the course has to hand the students over to advance programming or object-oriented programming course, which means that all the fundamentals of structured programming are to be covered. We make them learn Python programming fundamentals of course, but not for the sake of doing it, but I have to sell them the idea of being a data scientist first, so that they can write programs to read large excel or cvs datasets and make sense of the world using their own algorithms and visualizations – something beyond Excel. It works!

The following mapping helps keep the course grounded.

If you want to kill the curiosity and aspirations of your students, only then stick to power point slides. Instead, I use all the help I can get for my multimedia projector.

We start off the course with Wing’s beautiful article on computational thinking, but since the first semester students cannot have a clue what the following sentence means, “Computational thinking is using abstraction and decomposition when attacking a large complex task or designing a large complex system. It is separation of concerns.”

I use one complete lecture just so they understand what this one line means. We do this through a variation on an unplugged activity which involves student volunteers and the entire class’ participation, where it shows how a CPU, bus, keyboard, I/O display unit, memory and programmer work together without any part of the computer knowing what’s going on.

We repeat the process for a few other fascinating sentences from Wing’s article, for the development of computational thinking in students.

It’s almost magical how in just one course we can spend credible time on computational thinking activities as well as Google and Microsoft suites and still cover all the fundamental programming constructs up till functions and libraries and still finish the course completing a great data science 101 project. I wish I had more time to unfold some of how it’s done in more detail, but I must mention one last teaching resource which needs more air time in the world – Hedy. It is a godsend. It is a gradual programming language, which is solely created by a programming educationist in Netherlands, which looks at a programming language from the lens of human language and human cognitive processes. It starts out with an encapsulated 3 word world at level 1 and by the time we get to level 14, we have so smoothly transitioned to Python. I only need to take our last code from Hedy and paste it into Python’s IDE. It’s modern day magic. We invest 3 weeks neatly sandwiched between computational thinking and Python programming. We end the course on computing the answer for the following question, ‘Pakistan aisaa kion hai?’ (Why is Pakistan, the way it is?) with the help of Gapminder.org dataset, which has 50 indicators across decades for every country in the world. Here's a couple of sample outputs from my dear students. In the process they come to understand a little bit about the world they've inhabited.

A definite shout-out to Educative support as their programming problem sets help us set up our labs for test-driven practice sessions. More on that in some other episode.

One last thing I must mention is that I am aware of where my students are coming from – Pakistan’s education system has happened to them, and I have to break their long term (bad) habits of studying in annual systems. I do that with the structure of course’ instruments, by keeping a uniform distribution, first of all, every instrument being equally important, and the final exam is diminished to just 25% of the course. The standard design of 30% of the course for midterm and 40% for final exam makes it psychologically seem like an annual system still, with the majority of weight pushed to 1 or 2 days. I break this habit through the structure and weight distribution of my instruments. It helps, in my opinion.

Part II will lay down details for the rest of items in my mini-program!