Syllabus, SWE 626: Software Project Laboratory (Spring 2016)
Class Hours: Tuesday, 4:30pm – 7:10pm 201 Research Hall
Instructor: Prof. Thomas LaToza
Office: 4431 Engineering Building; (703) 993-1677
Office Hours: Anytime electronically, Wed 3-4:30, or by appointment
Overview and Course Outcomes:
This course will offer the opportunity to gain experience with current web development tools and technologies in the context of a team software development project. At the end of this course, you should be able to:
(1) Use current web development tools and technologies to design, implement, test, and release software
(2) Lead the use of a tool or technology within a software development project, learning best practices and mentoring other developers in its use
(3) Use software development data to derive your own best practices and communicate these practices to a development team and beyond
As the focus of this course will be on a software development project, there will be no exams. Instead, coursework will focus on contributing to the project and leading the use of a tool or technology over the course of the semester.
Team software development project:
To offer the opportunity to work with leading tools and technologies in a context close to a real world project, you will work with the other students in the course as part of a single software development project. The project experience will be designed to be as real as possible. Through the course of the semester, you will design and implement features that provide value for (potentially real) users. The project will be organized into two week sprints and will release a new version of the system at the end of every sprint. Feature teams will be responsible for the design and implementation of specific area of the system. You will be responsible for unit testing all of the functionality you create. The software development project will be open source, with all artifacts, history, and issues publicly available through Github. The instructor will serve as the client and help in crafting the overall vision and requirements of the software project. For Spring 2016, the software project will be SeeCodeRun, a collaborative debugging community for using, sharing, and authoring visualizations of program execution traces.
Tools and technologies:
In this course, you will use a number of current software development tools and technologies.
Github: Github is a cloud-hosted Git version control provider. In this course, we will use Github as the version control system, for code reviews, as the issue tracker, and to host Wiki pages.
Slack: Slack is team messaging system, replacing email and IM with a unified channel based communication system. Slack can also be used to upload and share documents and links. We will use Slack for all project-related communication and collaboration.
Google Drawings: Part of Google Docs, Google drawings can be used as an online collaborative whiteboard and for sharing design sketches.
Balsamiq: Balsamiq is a tool for creating UI mockups.
Cloud9: Cloud9 is an online IDE, enabling multiple developers to edit code and interact with a single workspace at the same time. In this course, we will use Cloud9 (together with Skype) for distributed pair programming.
Bootstrap 3: Bootstrap is a UI framework offering UI components and styling.
Firebase: Firebase is a NoSQL cloud database, enabling real-time synchronization and storage of JSON data between between browser clients. We will use Firebase as a backend for storing system data and as a hosting platform for hosting the system itself.
D3.js: D3 is a framework for creating visualizations.
Aurelia or Angular 2.0 (TBD): Aurelia and Angular are frameworks for architecting UIs with an MV* framework, templates, and databinding.
Owning tool or technology practices:
You will be responsible for owning the practices by which students in the course use one of the above tools or technologies. Over the course of the semester, you will become the resident expert, helping other team members get up to speed, answering their questions, and researching and defining best practices. You will create and maintain a Wiki page on Github, explaining the basics of how to get started, addressing frequently asked questions, and documenting best practices. Others will ask questions on the corresponding Slack channel, and you will be responsible for answering their questions.
As owner of the technology, you will ultimately be responsible for making project team members as productive as possible. What this means, and how to do it, will be yours to determine. For tools, this may include making sure students are aware of features and know how to use features to accomplish common activities (e.g., creating a personal branch on Github). For technologies, this may include setting guidelines and coding standards, offering example code snippets, or explaining how something works.
In some cases, the team as a whole may realize they face an important issue related to your tool or technology (e.g., how do we merge branches) and identifying its existence may be easy. In other cases, it may be hard to determine what aspects of a tool or technology are most difficult to use or are having the biggest impact on productivity. In these cases, you may seek additional insight through several forms of data, including looking at commits or watching screencasts to understand how others are using your tool or technology and what problems they might be experiencing.
To show off your contributions to the project, you will give a demo every other week of at least one feature you’ve built in the last sprint. Demos will be completely informal, offering you an opportunity to give a show and tell of a feature you’ve built and get comments and feedback from other students.
You will work as part of a feature team that will together be responsible for the design, implementation, testing, and maintenance of the features in its area. For this semester, the three feature teams will be:
(1) Pastebin platform – infrastructure for authoring and editing code; infrastructure for authoring, testing, and finding execution visualizations; overall UI for frontend; extensions to code editor to support execution visualization overlaid on code
(2) Execution trace platform – infrastructure for collecting execution traces, searching and filtering execution traces, and derived views of execution traces such as slices
(3) Execution visualization platform – reusable components for depicting visualization of execution traces; sample execution trace visualizations illustrating the use of the reusable components
To help share knowledge, pair programming will be used for all programming in this course. During each programming session, you may pair with a different partner. To find a partner, you can check Slack to see who is online at the moment or to schedule a session. During the session, you will program with your pair using a shared Cloud9 workspace and can chat online using Skype or other chat provider.
To help tool and technology owners understand how others are using the tools and technologies within the course, all programming sessions will be recorded through SnagIt. At the conclusion of the session, screencasts will be uploaded to a DropBox folder.
To help ensure the quality and maintainability of the codebase, all code commits will be code reviewed. After completing work on a change, you will first commit the change to your branch and then create a pull request to merge the commit into the main branch. Before the commit is merged, you will ask another student to review the code. In reviewing the commit, the reviewer should look for potential bugs, ensure the code is adequately tested with unit tests, and ensure the code is adequately documented and follows the best practices for any relevant technologies. After a commit has been reviewed and any discovered issues addressed, it can be merged into the master branch.
You will be responsible for ensuring the correctness and robustness of the code that you write, which will be a component of your course grade. To ensure the quality of your code, you will create and maintain unit tests for your code using the Jasmine unit testing framework.
Class meetings will be primarily used as a venue for team meetings, helping to discuss whatever is currently in need of discussion. This may include tool and technology best practices, features and requirements, architecture and design, and planning the next sprint.
Technology blog posts:
During the semester, you will write two blog posts reflecting on your experiences leading the use of a tool or technology within the team development project. The first blog post will focus on getting up to speed, and the second will focus on best practices for improving productivity. Blog posts may include reactions to existing best practices (e.g., we tried x, and it didn’t work for us because of y), war stories and anecdotes about the use of the tool or technology within your project, existing guidelines and best practices you have found most helpful, and your own guidelines and best practices you have created for your own project.
Assessments of your contributions will be made at the end of each sprint based on the work you have done during the two-week sprint. No arrangements will be made for assessing work done outside of the sprints.
78%: Sprint assessments
22%: Tool or technology blog posts
At the end of each sprint, you will be assessed on each of the following:
-- Value of designed and implemented features contributed to the project
-- Quality of code contributed
-- Quality and value of code reviews contributed
-- Use of pair programming
-- Responsiveness and helpfulness in answering questions on your tool or technology on Slack
-- Documentation of tool or technology best practices on the Github wiki
Grades will be determined both by the instructor’s review of your contributions and by assessments made by your peers.
Additionally, each of the two tool or technology blog posts will be worth 10% of your overall grade.
GMU is an Honor Code university; please see the Office for Academic Integrity for a full description of the code and the honor committee process, and the Computer Science Department’s Honor Code Policies regarding programming assignments. The principle of academic integrity is taken very seriously and violations are treated gravely. What does academic integrity mean in this course? Essentially this: when you are responsible for a task, you will perform that task. When you rely on someone else’s work in an aspect of the performance of that task, you will give full credit in the proper, accepted form. Another aspect of academic integrity is the free play of ideas. Vigorous discussion and debate are encouraged in this course, with the firm expectation that all aspects of the class will be conducted with civility and respect for differing ideas, perspectives, and traditions. When in doubt (of any kind) please ask for guidance and clarification.
Accommodations for Disabilities:
If you have a documented learning disability or other condition that may affect academic performance you should: 1) make sure this documentation is on file with Office for Disability Services (SUB I, Rm. 4205; 993-2474; http://ods.gmu.edu) to determine the accommodations you need; and 2) talk with me to discuss your accommodation needs.
Students must use their MasonLIVE email account to receive important University information, including messages related to this class. Seehttp://masonlive.gmu.edu for more information.
Other Useful Campus Resources:
Š Writing Center: A114 Robinson Hall; (703) 993-1200; http://writingcenter.gmu.edu
Š University Libraries: Ask a Librarian
Š Counseling and Psychological Services (CAPS): (703) 993-2380; http://caps.gmu.edu/
Š University Policies: The University Catalog, is the central resource for university policies affecting student, faculty, and staff conduct in university academic affairs. Other policies are available at http://universitypolicy.gmu.edu/. All members of the university community are responsible for knowing and following established policies.