Since I’m in my last semester of teaching for a little while, I figured I’d document what a typical computer science lecture looks like for me. As an added wrinkle, I even talk about the effects that COVID-19 has had on this process.
Table of Contents
Before I get into exactly what a lecture looks like, I figured I’d share some of the context. After all, we all teach in different classrooms and in different capacities, so it helps to explain exactly what that context looks like first.
Since August 2018, I have been teaching primarily introductory computer science at a large Midwestern university (The Ohio State University) as a graduate student. Over the last two years, I have taught two courses: introduction to Java (CSE 1223) and software components (CSE 2221).
Both of these courses are very similar. One (CSE 1223) is a true introductory programming course targeting a general audience. Meanwhile, the other course (CSE 2221) is more focused for individuals planning to head into the field. That said, the content largely overlaps, and it’s not until about halfway through the second course that we actually cover new material. This is to accommodate students from various programming backgrounds.
Both of these courses served roughly 40 students every semester. In addition, course formats were also very similar with a mix of lectures and labs. Lectures were just as you would expect: a 55-minute segment of time dedicated to computer science theory. Meanwhile, labs were an opportunity for students to apply their knowledge in a programming environment.
In terms of assignments, both courses had a nice mix of written and programming assignments. The written assignments gave students an opportunity to dive into more theoretical topics. Meanwhile, programming assignments gave students to apply practical concepts through a more formal assessment.
Finally, both course leveraged three exams: two midterms and a final. Finals were often cumulative with some weight toward later material.
The only real differences between these course were content and the role in which each course played in student trajectory through the program. Otherwise, they were largely the same. As a result, I’ll group them in my description of a typical lecture.
As I mentioned, my lectures are typically 55-minutes, and I get a surprising amount of control over how I use the time. In fact, in both course, I was allowed to teach however I wanted as long as I covered the material. Having not been formally trained, this was both exciting and scary.
Since I’ve had so much control over the past two years, I figured I’d first share what sort of materials I use first. Then, we can dig into the actual lecture structure.
First, I use a little tool called Top Hat. Basically, it’s classroom management tool like Canvas, but it’s more oriented toward active learning in the classroom. Specifically, I use it for a lot of different reasons. For instance, it:
- Allows me to take attendance by displaying a code which students can enter into an app (i.e. paperless attendance)
- Gives me a place to upload course materials like lecture slides
- Lets me interleave activities like peer instruction questions and discussions between slides
Of course, Top Hat has a ton of other functionality, but I typically use it for these purposes.
Second, I use Canvas (aka Carmen at OSU) to track student grades and collect student assignments digitally. For example, students can use Canvas to upload all of their assignment documents like homework PDFs and project code. Then, grades and feedback can be administered directly in the tool (i.e. again, paperless assignments).
Finally, we use Eclipse for Java development. Personally, I don’t love Eclipse. That said, we had to agree on a common environment, so grading would be fair and efficient. Also, it just alleviates so many tech issues when everyone agrees on the same software.
Beyond that, I typically use whatever the classroom has available—except document cameras. For example, I love to draw, so I often use the blackboard/whiteboard if they’re available.
With all that out of the way, let’s talk about what a typical computer science lecture actually looks like for me.
First, I try to arrive to class early. This gives me time to address tech issues if they come up. In addition, it gives me time to mentally prepare for the lecture. Of course, perhaps most important of all, showing up early gives me the opportunity to open up an anonymous discussion for students who might have questions or feedback for me.
Then, I kick of each class with any updates that I might have. For instance, I might have some information about an upcoming exam, or maybe I’ll remind students about upcoming deadlines or policy changes. In some cases, I might even share changes I’ve made to address feedback.
After updates, I like to run through student questions from the anonymous discussion—time permitting of course. Typically, these questions are related to assessments like projects, homework, and exams. Occasionally, students will ask about labs and content clarifications, but they mostly care about things that affect their grades.
With Q&A out of the way, I like to present an overview of the upcoming lecture. For example, if I’m teaching about trees, I might present something like the following:
- Tree Theory
- XML Documents
- XMLTree Component
This gives students an idea of the content to be covered for the day. In this case, we talk a bit of theory before diving into an application space.
After that, I spend the remainder of the lecture going through material. For me, that usually looks like presenting some slides in TopHat, asking guiding questions, and administering peer instruction questions. In general, I like to have a nice mix of lecturing and activities, so students don’t get bored. If you’re interested in the types of activities I like to run in a computer science class, here’s a nice list:
- How to Improve Coding Comprehension with Peer Instruction
- Democratic Synthesis: Taking Think-Pair-Share to the Next Level
Since I keep my classes active, we often run right up to the end of class. As a result, I don’t typically plan to end with anything formal, but it’s not a bad idea to close out with some learning objectives.
Changes Amid a Pandemic: COVID-19
Previously, I mentioned this being my last semester of teaching for awhile. The reason for that is that my current department only funds teachers for about two years. Then, we’re expected to get a research stipend.
To make things more complicated, I’m also switching departments. Since the new department has more of an engineering focus, I am choosing to move into research for now.
All that said, I was never expecting to have to completely change the way I teach in my last semester. Then, COVID-19 hit, and states began going into full quarantine. For instance, OSU closed its doors while we were all on spring break. However, we were all still expected to hold regular classes.
Over the next two weeks, our course went into overhaul. For example, one of my classes gave up on synchronous lectures. Instead, we had a single synchronous Q&A a week accompanied by recorded lectures.
In addition, many of my classes abandoned or redesigned assignments. For example, one of my classes got rid of two assignments and began administering digital checkpoint quizzes.
For me, the pandemic has meant a lot of different things. For one, it’s meant a lot of time spent at home staring a screens. Likewise, in terms of teaching, it’s meant a complete shift to digital platforms.
Fortunately for me, most of my work was already digital. I wasn’t handing out paper assignments, and I wasn’t commenting on paper copies of code. That said, I was administering paper exams, so that was the first major change. Luckily, my teaching team decided to convert to weekly online quizzes.
As for teaching, I decided to maintain the synchronous schedule using Zoom. Of course, I was aware that not all students were going to be able to attend the lectures, so I recorded the for their asynchronous viewing pleasure.
Also, lectures were already being provided by my course coordinator as videos, so I didn’t actually have to host lectures. Instead, I used the time to work through questions and host activities.
Otherwise, everything else was pretty much the same. That said, I did have to get very used to dealing with frantic emails. Suddenly, I was handing out extensions like Oprah (not actually my joke, but I thought it was funny enough to steal from one of the faculty members).
As mentioned previously, I have no plans to teach in the near future. However, I would like to teach at the university level if content creation doesn’t work out. As a result, I thought it would be a good idea to document my current routine for my future self.
If you got value out of this, let me know in the comments. I’d be interested in learning about your teaching routines and how you do things differently.
Otherwise, check out some of these related articles:
- Looking Back on My First Year of Teaching
- 5 Ways to Get Feedback on Your Teaching
- Dealing With Difficult College Students (Premium)
Likewise, here’s my list of ways you can support the site if you’re interested in that sort of thing.
In addition, here are a few related teaching books from Amazon (ad):
- Excellent Online Teaching: Effective Strategies For A Successful Semester Online
- The Online Teaching Survival Guide: Simple and Practical Pedagogical Tips
And with that, thanks for stopping by. Don’t be afraid to bookmark this site (do people still do that?), and come back later!
Kicking off a new series of reverse engineering content inspired by VirtualFlatCAD. Today, we're trying to roll our own uppercase function.
When it comes to capitalizing strings in Python, you have a few options. Use the tools Python provides or roll your own.