As someone who teaches as a grad student, I sometimes dream of the days where I’ll have a bit more control over my course schedule. As a result, I thought it would be fun to share some of my course preferences.
Table of Contents
Not too long ago, I wrote about some courses that ought to be taught in computer science. As I get closer to becoming a professor myself, I’ve been thinking about how I’m going to market myself as an educator. Specifically, I’ve been planning out how I might answer a question about my interests in teaching.
To aid in that planning, I thought I’d take a moment to get some of my thoughts on paper. Not only do I want to be able to state which courses I want to teach but also why I want to teach them. As a result, the plan for this article will be to share my top choices for courses I’d love to teach.
At the same time, I think it’s also useful to flat out reject certain courses upfront. That means I’ll also be sharing my thoughts on where I wouldn’t be a good fit as an educator.
Without further ado, let’s get into it!
Top Courses by Interest
Different schools handle computer science differently, so it’s often hard to say “I want to teach a data structures course” when not every university might have one. That said, it’s also hard to say things like “I want to teach algorithmic thinking” because it’s probably a component of many courses. As a result, the way I’d like to approach this list is by sharing my primary interests as an educator. That way, I can meet the institution in the middle with their existing course catalog.
Introductory Programming: 1000-Level Courses
By far, my main interest as an educator is introductory programming. There are a few reasons why I prefer that space over middle and upper level courses.
First, introductory courses are always major gatekeepers. As gatekeepers, these courses push students out who would otherwise would be excellent software developers. Ultimately, I see it as my role to break the cycle and provide introductory education that maximizes retention of folks who really want to be there.
Second, introductory courses are often open to a more diverse set of students. For example, I previously taught an introductory Java course that was open to all majors. As a result, I had students from the colleges of arts and sciences. This sort of openness made the course a lot more fun to teach because students brought a wide variety of experiences and perspectives. Likewise, the overall vibe of the course was more positive than other computer science exclusive courses.
Finally, introductory courses allow me to have an overall impact on the way students are socialized. Much of the issues I have with gatekeeping actually propagate to the students. Naturally, this creates a sort of ruthless environment where students would rather compete than cooperate. If I can step in at the front line, I can I have an positive impact on department culture and morale for the future.
With all that said, I have a preference for introductory programming courses covering Java, C#, or Python. If possible, I’d love to teach Python, but I know most universities are still teaching Java and C/C++. If possible, I would like to avoid teaching C/C++ at all costs.
Intermediate Programming: 2000-Level Courses
While my overwhelming interest is working with first-year students, I’d be lying if I didn’t say I like teaching some of the intermediate programming topics. After all, teaching syntax can be a bit dry at times—even if you share all the coolest bits like I do.
Of course, as students move from introductory to intermediate coursework, the topics go from generalized to more specific. They aren’t quite as specific as courses like “computational audition”, but that does mean there are some intermediate courses that I wouldn’t be interested in teaching. As a result, here are some specific topics that I would enjoy teaching:
- Software Craftsmanship
- Data Structures
- Digital Logic
- Open-Source Software
- Software Testing
- Continuous Integration
In other words, I like teaching some of the tougher concepts like how to write good code, how to organize data, how computers work, and how to maintain your code. To me, the most interesting course would be an intermediate programming course that covers good design principles with a heavy focus on ethics and empathy.
Advanced Programming: 3000-Level+ Courses
Overall, I have very little interest in teaching upper-level courses. Given how much institutions beat the life out of students at that point, it’s hard to make a serious impact. And for my own mental health, I’m not trying to work with students who fight with me on everything.
With that said, I have expertise in graphics and programming languages, so there are a handful of courses that I’d enjoy teaching:
- Data Visualization
- Game Design
- Programming Languages
Generally, I don’t think I’m enough of an expert in these topics to teach them, but I’m sure I could work out the kinks after a semester or two. And at the very least, my interest in these topics will keep me invested in improving the course.
Project-Based Design: Any Level
Given that the first three areas of interest were in programming topics, I should mention that programming isn’t my only interest. As an educator, I’m also interested in teaching nontraditional courses—no matter the topic. Specifically, I’d love to run a project-based course where students are in teams working on something of value to them.
Traditionally, these project-based courses occur near the end of a student’s degree in the form of a senior design course. In my experience, however, there are other forms of project-based courses. One field that does this really well is game design which incorporates an extremely diverse set of interests into a single design. Likewise, I’ve seen similar project-based courses for first-year students with robotics.
As a result, I would be happy teaching any of the following courses:
- Project-based Robotics
- Project-based Game Design
- Project-based Senior Design
If I had my way, I’d run some of the introductory courses this way. It would be really cool to teach programming in an exploratory way, but I’ve never seen it done.
Technical Writing/Communication: Any Level
As someone who writes nearly every day, I find it funny that we spend basically no time teaching students how to do it. Not only is writing critical to getting information across, but it’s also a key component of software development. If you write any software, the least you could do is write a proper API and a how-to guide.
To me, writing is a form of empathy to the reader. Obviously, our field has suffered drastically from a lack of empathy, and it can be seen in the way we neglect to write documentation. As a result, my main interests with a course like this would be any of the following:
- API Documentation
- How to Guides
Personally, I do a lot of blogging, and I’ve recently dabbled in Python documentation. It’s a lot of fun, and I’ve noticed that doing it well will get more folks to engage with your work. In other words, “if you build it, they will come” is not quite as true as our field likes to believe.
Study Abroad: Any Level
Okay, listen. I like to travel, and I haven’t been able to do much of it since I started my grad program. One of my dreams is to start up a study abroad program at whatever institution I end up at. As a result, the course content really matters less than my ability to travel. Selfish, I know.
Over the years, I’ve been to Mexico, Poland, Germany, the UK, and Belgium. In the future, I’d love to take students to other places on my wish list like Japan! And the sooner I can build up connections with folks abroad, the easier I imagine something like this would be.
As far as course content is concerned, I’m not too picky. Any coding course will do! I know some folks who learned thermodynamics abroad, so how hard would it be to learn code?
Certainly, there are other courses I’d love to teach. For instance, I wouldn’t mind teaching and education course to grad students. With that said, I think it’s worth mentioning that there are courses I definitely don’t want to teach. Rather than give deep descriptions, here’s a quick list:
- Artificial Intelligence
- Machine Learning
- Discrete Math
- Operating Systems
- System Architecture
- Web Development
- Systems Programming
- Information Security
This may seem like a long list, but it basically boils down to a few gripes I have with computer science education. First, many of these courses are heavy on theory (e.g., discrete math, algorithms, etc.). Whereas, I prefer practice. Second, many of these courses are niche topic areas of which I have little interest (e.g., AI, ML, OS, etc.). Finally—and this isn’t a gripe with CS education—I lack experience in some of these topics (e.g., networking, information security, etc.).
Certainly, these are courses I could handle to a certain extent, but I would definitely prefer the courses previously listed. With that said, I think I’ve covered my bases as far as teaching is concerned. Maybe next time I’ll cover my interests in service.
In the meantime, if this interested you at all, why not check out some of these related posts:
- Post-Positivist Thinking Is Holding Tech Education Back
- I Won the Graduate Associate Teaching Award!
- Lessons Learned From Two Years of College Teaching
As always, if you’d like to support the site, check out my list of ways to grow it. Otherwise, take care! See you next time.
Recent Teaching Posts
As someone who collects a lot of feedback, I sometimes underestimate how much work goes into processing, so let's try!
My 7th semester of teaching wrapped up in early May, and I'm just getting around to reflecting on it.