Mobile Apps for Social Change
(CMSC 395 at Haverford College)
Note that–especially since this is my first offering of 395–parts of this syllabus are subject to change with adequate notice.
- General programming maturity, at least CMSC 105-106 / 107, preferably CMSC 245.
- Ability to pick up new languages on demand. The course will be conducted in Java.
- 3 lecture hours per week
- 1 lab hour per week
- This will be a lab / project intensive class. Approximately 6-10 hours per week outside of class will be expected from students. I recommend against taking this course concurrent with other project-heavy courses.
- Code-review sessions with other students and professor
Cap: 20 (may be lifted to 24)
This is a course on software engineering. We will learn how to design large pieces of software (multiple thousands of lines) by working on apps that will provide benefit to our communities. The course will consist of both individual projects (where you write code) and a semester-long group project building (and eventually launching) an app intended to mobilize some form of social change (more on this farther down).
The course will be run largely in the Java programming language, which I will expect you to learn within the first two weeks. Individual groups may supplement their apps with pieces of their system written in other languages (for example, a group may decide to write part of a backend with which the app interacts in Python). The coursework will consist as a mix of individual work and group assignments, along with an in-class coding exam (which will involve writing code and tests, along with debugging broken code) and written exam. Along with all of this, there will participation credit derived from a mix of things specified below (this is more than just “showing up to class”).
As the semester progresses, the major focus of the course will be a group project to develop an app, where each group proposes a problem they want to help solve. The problem needs to be one that will benefit other people in our community (broadly interpreted, either our local Haverford community or our world community) and doesn’t currently exist (e.g., have a popular app people actually use). Students will be graded on groupwork using a systematic formula to ensure they make substantial contributions to the app and are also communicative and professional with other group members.
Lab meetings will serve two purposes: providing basic proficiency in topics apropos to Android (e.g., creating an app with a basic screen, spinner, etc..), and also providing a conduit for interaction with teammates.
The course will begin in a fairly structured way: the instructor will give lectures on software engineering and provide live-coding demos to develop various features of apps. As the course progresses, students will be expected take a more active role in the course: each group will prepare part of a lecture to demonstrate a technical piece of the Android framework (or associated framework relevant to app development).
We will cover parts of the following topics, adjusted for time and pace of the course, along with student interest in each area.
- Java programming language
- Inheritance, templates, standard library, etc…
- Object-Oriented Design at Scale:
- Language features relevant to software engineering (inheritance, mixins, etc..)
- Design patterns (visitor, observer, command, flyweight, adapter, etc…)
- Data-structure decisions
- Testing your code
- Tooling and infrastructure (CI, etc..)
- Backend Interaction
- Software Engineering Ethics and Professionalism
- Etc… The course will expand along with the interests of the students.
Projects and Labs
The course will involve various individual projects (think of this as homework) and a semester-long group project. Labs serve as collaboration time, extended-office hours, and code-review.
I will set out the schedule for the semester-long project as the class gets underway. Roughly, you should expect to spend the first week or two getting your bearings with Android and finding group members. Then, in the third week, we’ll do project selection and group work.
The class will consist of two exams, both will (tentatively) be in-class. There will be a written exam–largely focusing on particulars of object-oriented design. There will also be an in-class coding exam, which will include debugging and implementing new parts of apps.
- Exams: 45%
- Coding exam: 22.5%
- Written exam: 22.5%
- Participation and Code-Review: 10%
- Projects: 45%
- Individual Projects: 15%
- Group Project: 30%
Evaluation for group projects will be based on mutual student feedback and may include oral exam with individual group members. I will post a rough outline of grading expectations during the middle of the term.
Grades may be adjusted based on how the class is doing. I expect projects and exams will be a bit tougher than the average CS class, so if the average student does very poorly on one assignment (say the in-class coding exam) I’ll adjust grades. I will only adjust grades at the end of the course. The reason has to do with fairness. Say that you do particularly well on an assignment that most of the course tanks, so I curve that assignment, but it doesn’t really help you, because you already did well. But then, you tank an assignment most of the class finds super easy. Then you get the short end of the stick. Per-assignment adjustments necessarily end up who fall at atypical ends of the spectrum, so I just don’t do them.
Participation is 10% of the grade and will be derived from the following criteria:
(5 points) Participate in code reviews with other class members
(2 points) Find a bug in someone’s code during a code review (at any point during the course).
(3 points) Deliver (with your groupmates) in-class presentations / demos on a topic particular to Android.
No formal books required for the course. I recommend “Thinking in Java” (though it is long) as an introduction to Java. I also strongly recommend Mark Murphy’s free books on Android.