A while back, I wrote a post about syllabus design while creating a syllabus for an iOS course. In the end I taught that course from the department’s existing syllabus, but this year, I’m designing a new course:
Title: Mobile Software DevelopmentDescription:
This course examines software engineering skills through the lens of mobile development. Students will leave with more confidence in their ability to debug, decipher complex software systems, test their code, navigate documentation, leverage version control, and learn new programming languages.
We’ll exercise these skills with both the Android and the iOS framework, but the goal isn’t to become fluent in a mobile stack; the goal is to practice the skills.
The course also capitalizes on the unique history of mobile handsets and tablets to talk about about accessibility, data privacy, sourcing ethics, and to what degree it is our responsibility as engineers to understand and prioritize these things.
I use mobile development examples as a substrate upon which to build software engineering skills and critical context. You can see all the posts in the “Designing a Course” series right here!
This post covers how I have begun to build the syllabus for that course.
I’m considering running an online version this spring for professionals (not students) to do some professional development after hours, with a much lower enrollment fee than a typical master’s course fee.
Please fill out this form if you think you might like to attend.
Step 1: Identifying what students will learn
My plan is to start with iOS, then move to Android. I wrote a list of things I’d like the course to cover and color-coded the list into three groups:
- Skills (specific programming practices and ideas)
- Concepts (general frameworks to help students think about building robust software)
- Context (broader software engineering topics for sparking discussion and building professional awareness).
Here is the exact list I made:
I coded “skills” in pink, “concepts” in yellow, and “context” in green. Some of these items overlap. A few of them, as you can see, have more than one color associated with them. Ultimately, more of them also probably fall under two colors.
I also added some symbols, like stars, to indicate which concepts rely on each other. I want to mark these relationships for determining how I arrange all these items in the syllabus relative to each other.
Step 2: Gathering Background
With this list in hand, I have created a list of resources to review for additional ideas about what to include in the class and how to structure it. That list currently includes:
- My slides and materials from teaching iOS Development
- Mastering SwiftUI
- Building Android Apps in Kotlin
- The One Device
- Building Flutter Apps
I’ll spend this week and the first week of March going through these materials and filling out the above list.
After that, I’ll move on to some additional steps:
- Determine which of these items to cover, in what order, in each of nine 3-hour sessions
- Design discussions and exercises specifically to introduce, practice, and ingrain the material
- Design homework assignments that maximize independent discovery and skill retention while minimizing time spend
- Design periodic surveys to send to students throughout the course to see how things are going and ensure that course goals are being met
I’m excited to see how this shapes up as I get into the later stages, and I’ll cover each of the steps in pairs as I finish them in future behind the scenes posts.
If you liked this piece, you might also like:
The three-part series on teaching a programming course
The rest of the behind the scenes series
The leveling-up series on advancing your own skills (which will soon be an audiobook read by yours truly. Preorder here).