Coursework

Most of my programming knowledge has been acquired through coursework, with many of the later courses being the most influential.

CS 314: Software Engineering

CS 314, Software Engineering, was the first course I took that had the format of a single semester-long project where students worked in groups to complete the tasks. The project that the course focused on was a trip planner with the goal of providing users with the shortest possible trip given a list of destinations. While programming was a large portion of the course, it was not the main point. Instead, it provided an introduction to various tools and techniques that software developers need to know outside of programming.

On the technical side of the course, version control systems, primarily Git and GitHub, were taught. Version control systems enable version control, which Atlassian defines as “... the practice of tracking and managing changes to software code.” Previous course projects were small in scale and complexity, so version control was not needed. This course introduced a large-scale project that also involved multiple contributors, so some manner of version control was necessary to keep all the modifications organized. The course also enforced the usage of GitHub best practices to ensure students got practice with proper GitHub etiquette.

Several non-technical skills were also taught. In particular, agile development practices, such as Scrum, were used. Agile development is a particular method of developing software that allows for changes in requirements to be quickly addressed in order to deliver a functional solution, according to Opentext. Scrum was the agile methodology used, which Scrum mentions being focused on a Scrum team with each member being responsible for different portions of the project’s development. While providing a structure for development, Scrum also provided a structure for teamwork, which had not been a point of note in previous courses. Of course, other courses had group projects, but this was the first course to truly require teamwork in order to be successful.

CS 415: Software Testing

CS 415, Software Testing, utilized many of the skills taught previously in CS 314, but with a focus on testing produced software to ensure it functioned correctly. CS314 also required testing software, but it did not delve into proper testing practices. In this course, the project’s goal was a company project tracker that allowed workers with proper qualifications to be assigned to various projects.

Software testing aims to ensure that written code functions properly. For example, code that is designed to sum two numbers should output 4 if given 2 plus 2, and testing ensures that this is the case. Testing acts as proof that the code does what it is supposed to. However, it is almost impossible to fully test software, as the number of possible inputs to code is almost unlimited, so finding an adequate subset of tests is necessary.

Unit testing, checking that each component in a software system works, was one of the main areas of interest, and JUnit was used to achieve this. Testing software when portions of the code were not complete was achieved through Mockito. Multiple automatic test generation tools were also used to show their availability, but they were not used much, as the main focus was on user-generated tests.

CS 414: Object-Oriented Design

CS 414, Object Oriented Design utilized skills taught in CS 314, but built upon them with a focus on designing software prior to programming. With almost all the courses I had taken previously, planning was either done for the students or the programs were small enough not to require prior planning, so being required to plan a large-scale project was a different experience. The goal of this course was to create a site that would allow users to create accounts and play games of chess with other accounts.

Various planning methods were taught, such as user stories, which sought to understand customer needs, domain modeling, which sought to understand what each piece of the software would be responsible for, and class modeling, which sought to understand how the various items in the software would interact. Later in the course, these plans were implemented into working code. As the code was implemented, various assessment techniques were used to evaluate how good our design was and determine what changes needed to be made to the original plans.

The course also introduced several programming patterns, a particular way of writing a section of code to get a desired effect, which were later implemented in our code. However, these patterns were introduced after the initial designs, so it was necessary to go back and modify the original plan to include useful patterns.