TITLE: I'm Behind on Blogging About My Courses...
AUTHOR: Eugene Wallingford
DATE: June 09, 2015 2:48 PM
... so much so, that I may never catch up. The last year and
a half have been crazy, and I simply have not set aside enough
time to blog. A big part of the time crunch was teaching three
heavy preps in 2014: algorithms, agile software development,
and our intro course. It is fitting, then, that blogging
about my courses has suffered most of all -- even though, in
the moment, I often have plenty to say. Offhand, I can think
of several posts for which I once had big plans and for which
I still have drafts or outlines sitting in my ideas/
Thoughts on teaching Python stand out as especially trenchant even
many months later. The intro course is so important, because it
creates habits and mindsets in students that often long outlive
the course. Teaching a large, powerful, popular programming
language to beginners in the era of Google, Bing, and DuckDuckGo
is a Sisyphean task. No matter how we try to guide the students'
introduction to language features, the Almighty Search Engine sits
ever at the ready, delivering size and complexity when they really
need simple answers. Maybe we need language levels a lá
the HtDP folks.
Alas, my backlog is so deep that I doubt I will ever have time to
cover much of it. Life goes on, and new ideas pop up every day.
Perhaps I can make time the posts outlined above.
Right now, my excitement comes from the prospect of teaching my
compilers course again for the first time in two years. The
standard material still provides a solid foundation for students
who are heading off into the the world of software development.
But in the time since I last taught the course, some neat things
have happened in the compiler world that will make the course
better, if only by putting the old stuff into a more modern
context. Consider announcements just this week
in particular that the source code is being open-sourced and
the run-time ported to Linux. The moment these two things happen,
the language instantly becomes of greater interest to more of my
students. Its openness also makes it more suitable as content for
a university course.
So, there will be plenty to blog about, even if I leave my backlog
untouched. That's a good thing.
- readers' thoughts on teaching algorithms in 2014, along
with changes I made to my course. Short version:
The old canon still covers most of the important bases.
- reflections on teaching agile dev again after four years.
Short version: The best learning still happens
in the trenches working with the students, who occasionally
perplex me and often amaze me.
- reflections on teaching Python in the intro for the
first course for the first time. Short version:
On balance, there are many positives, but wow, there is
a lot of language there, and way too many resources.
- a lament on teaching programming languages principles when
the students don't seem to connect with the material.
Surprise ending: Some students enjoyed the course
more than I realized.