How To Create Curriculum¶
This guide presents some general guidelines and best practices on creating and presenting curriculum for LaunchCode programs. It is based on our experience in developing and running community-oriented coding classes for non-traditional learners, and on some accepted educational best practices.
This guide is evolving, and is not intended to be a firm set of rules to be followed. Feel free to adapt guidelines to your specific circumstance and to suggest improvements. If there is something you’ve found works well to facilitate learning that hasn’t been included here, let us know.
If you have questions about anything in this guide, or want some input on how to best approach your curriculum development, reach out to a member of the Education Team.
LaunchCode course curricula are typically broken into each of the sections below. Even if you leverage the components in different ways–emphasizing in-class learning over prep work–it is important to consider the role and benefit of each component in creating a course that helps learners obtain and master new skills.
Learning objectives define the intended outcomes of a lesson. Objectives state in specific detail the concepts students should learn, and to what depth they should learn them. Objectives can also be used to define how the attainment of knowledge can be verified.
You can think of learning objectives as your unit tests for your curriculum, and your curriculum development should follow a test-driven development pattern. Just as unit tests define the intended behavior of an application, learning objectives define the intended outcomes of a lesson. Just as unit tests are often used to create “self-documenting” code, learning objectives serve as documentation for your curriculum that can be useful to students, TAs, and LaunchCode staff.
Here are some examples of learning objectives from a hypothetical HTML lesson:
Explain what HTML stands for
Describe the difference between a markup language and a programming language, and give examples of each
Describe HTML document structure and associated elements, and properly use those elements:
Describe what an HTML tag is, and give common examples (e.g.
Describe what an HTML attribute is–including how attributes relate to tags–and properly use attributes
Each of these examples do one or both of:
Define the knowledge that a learner should obtain. That is, what is the mental concept that the learner will be able to demonstrate? Acquisition of the given conceptual knowledge is typically verified by the learner’s ability to explain the concept with concrete examples.
Define the skill that the learner should obtain. That is, what should the learner should be able to do? Acquisition of the given skill is typically verified by demonstrated use of the skill.
These two different types of objectives, while often overlapping in practice, are important to distinguish. We might care in some cases only that a learner can demonstrate the ability to carry out a certain task, and not that they demonstrate a full conceptual understanding of a task. For example:
Use the rules defined by a web framework’s object-relational mapping library to configure persistent model classes.
Here, we’re specifying that it is important for a learner to be able to use the defined rules for configuring persistent model classes, without understanding the full mechanism of how the ORM library actually carries out the work of persisting instances of these classes. So we may not care if a new programmer understands the full details of how data types of class properties are mapped to data types of columns in a relational database.
An example in the other direction–i.e. an objective that defines knowledge without a demonstrated skill–might be:
Describe how a web browser parses an HTML document and turns it into a rendered web page.
Here, we don’t intend that a learner can actually parse a document and render a page, but that they have a conceptual understanding of this process.
To return to the test-driven development analogy, we encourage you to use a test-driven approach:
Define the learning objectives for a lesson
Create or source lesson material that covers the objectives
Create or source activities for students to practice and reinforce and demonstrate the objectives
Many LaunchCode courses use a flipped classroom approach to deliver lesson content outside the classroom. This is beneficial for courses where in-class time is limited, allowing time with instructors and TAs to be focused on helping learners overcome specific difficulties and practice new skills.
Additionally, in an environment with learners of widely-varying backgrounds, skill levels, and learning styles, delivering primary learning material outside of class allows for students to work through material in their own way. Some learners may go over material multiple times, the first time to get a broad overview, the second to gain in-depth understanding, and a third to focus on difficult concepts not fully grasped in a first pass. Another learner may prefer to spend more time gaining hands-on experience with the new concepts.
The overall goal of prep work for a lesson is to expose learners to the concepts and skills they are to gain, and to give them a chance to identify which of those need additional clarification or reinforcement.
Once a learner has been exposed to a concept, valuable in-class time can be used to help them understand and practice more difficult concepts and to solidify their understanding. In-class time should not be used to completely rehash the material taught in prep work.
Some activities that can be useful to this end are:
Conceptual review and Q&A
Presentation of examples, focusing on potentially confusing and/or important areas of the lesson
Hands-on practice (aka “studios”) using an instructor-created activity
Peer-to-peer/group practice, such as pair programming, mob programming, or peer-to-peer coding challenges
Once a student has been exposed to a concept, it is vital that they have the opportunity to practice using the concept in a supported environment before going off to use it on their own in an assignment or project.
Assignments are critical to ensure learners fully obtain the desired knowledge and skills. When creating assignments, refer to the learning objectives for the associated lessons to ensure that an assignment covers the most important (if not all) associated learning objectives.
Assignments should have specifications (“specs”), which outline the objectives and tasks for the learner. A spec should include:
Starter code and/or setup instructions
Assignments will most often be graded via demoing with course staff. To that end, each assignment should have a grading rubric. This should consist of a set of specific items that the instructor or TA should check for to verify assignment completion. Assignment grades should be entered in Canvas.
Another tool to evaluate and reinforce learning is evaluation via quizzes or tests. These can be good compliments to coding assignments, since it is possible to cover assess more conceptual objectives.
If utilizing quizzes or tests, provide students with a set of learning objectives to study from (typically a subset of objectives from recent lessons). We also recommend Canvas, which provides functionality for automatic grading (for multiple choice questions), time limiting, and automatic grade entry.
For training on how to set up quizzes in Canvas, talk to an Education Team member.
Canvas is a learning management system (LMS) used to facilitate components of class cohorts using a packaged curriculum. Canvas is the centralized tool for:
Scheduling: slotting specific lessons and assignments into specific days based on the cohort schedule
Attendance: tracking student engagement
Grading: Grades entered by automatic mean (quizzes, Vocareum) or manual-entry (instructors and TAs entering grades)
Assessments (optional): administering and grading exams and quizzes
Communication: Announcements can be sent to courses, individual sections/tracks, and individual students
An important point to note is that curriculum content should not hosted in Canvas. Curriculum modules should be scheduled within Canvas, but hosted elsewhere. This allows multiple cohorts to be run using the same, centralized curriculum. It also enables version control and easier access to curriculum content.
Sphinx / GitHub Pages¶
Most curriculum content is hosted using GitHub Pages, using the Sphinx static site generator to generate static pages from Markdown and RST. These sites are set up and administered by LaunchCode staff, but access can be granted to course instructors for updating and modifying curriculum. Source code is stored in GitHub (links below).
Each site is a curriculum module which may be all or part of a given course. The links above collect all of the curriculum modules for LaunchCode Education programs.
Starter code for assignments and other activities will be hosted in GitHub in the LaunchCoderGirl organization. The general workflow for students should be to fork a repository into their own account, and work on the forked copy.
It is also encouraged that any code created for lessons be made available via GitHub and linked from the course site.
For access to course repositories, talk to an Education Team member.