Syllabus, SWE 626: Software Project Laboratory (Spring
2016)
Class Hours: Tuesday,
4:30pm Ð 7:10pm 201 Research Hall
Grades: Blackboard
Resources: https://piazza.com/gmu/spring2016/swe626
Instructor: Prof. Thomas
LaToza
tlatoza@gmu.edu
http://cs.gmu.edu/~tlatoza
Twitter: @ThomasLaToza
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.
ES6 (a.k.a.
ECMAScript 2015, ES2015): ES6
is the current version of Javascript, enabled for
current browsers by including Òuse strictÓ;. ES6 includes a number of new features,
including collection classes and a new syntax for declaring classes.
Jasmine 2.0: Jasmine
is a unit testing framework for Javascript.
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.
Ace: Ace is an embeddable code editor written in Javascript,
including many of the features of modern code editors and maintained as the
editor for Cloud9. In this course, we will use Ace as the code editor for SeeCodeRun.
Esprima: ESprima is a parser
for Javascript code written in Javascript.
In this course, we will use it to parse and manipulate Javascript
code.
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.
In-class demos:
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.
Feature teams:
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
Pair programming:
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.
Code reviews:
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.
Unit testing:
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:
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.
Makeups:
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.
Grading:
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.
Honor Code:
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.
Privacy:
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.