Learning Outcomes

Software development used to be a highly fragmented process. After developers have completed a set of enhancements and defect fixes, a candidate version of a release would be handed off to Software Quality Assurance (SQA) teams, who would check the candidate for defects. Next, the SQA team would hand the RC off to release engineering teams, who would prepare the software for release. After completing the official release process, software operators would install and configure the RC in production environments, where users can finally interact with it.

This fragmented approach to software engineering has largely been abandoned in industry for two reasons. First, since large quantities of enhancements and defect fixes would be grouped together into one release candidate, releases would encompass a large amount of change in the software system. These large releases were deemed risky both from a development organization perspective (i.e., field-reported defects can invalidate weeks or months of development effort) and a user adoption perspective (i.e., with so much change in the software system, it may be difficult to migrate existing installations to the new release). Second, the stakeholders on different teams would solely focus on tasks that fall within their purview, often leading to a lack of oversight of the whole development, release, and operations processes. Instead, modern development teams have embraced the DevOps mindset, i.e., a holistic view of the development, release, and operations processes. Enabling this mindset is a vast array of development, release, and operations tools, techniques, and practices.

Modern software delivery teams are tasked with selecting appropriate software delivery tools and assembling them to produce integration, release, and deployment pipelines that connect development, release, and operations processes. The material in this course will mainly be delivered through hands-on experience in developing integration, release, and deployment pipelines.

More specifically, students will:

• Be introduced to the challenges of modern software delivery
• Gain experience with several key tools (build and test automation, version control management)
• Design and develop integration, release, and deployment pipelines for a large application

The main objective of this course is to provide students with the skills that are needed to design, develop, and maintain the integration, release, and deployment pipelines that are at the centre of modern DevOps-based software releasing practices.

Instructor

Dr. Majid Babaei
Email address: majid.babaei@mcgill.ca,
Personal website:www.majidbabaei.com,
Office: 680 Sherbrooke Street West, 13th floor, room#1324
Department: School of Continuing Studies.

Online live Sessions, over Microsoft Teams, are held on Fridays 3:30pm (by appointment). These sessions, usually, run for 30 minutes. However, they may also run for less than that in case there are no further questions or discussions.
Lecture slides will be posted over MyCourses. If you have questions and need clarifications about the lecture slides, then the live sessions will be the perfect location to get your questions answered and clarified.

Teaching Assistants

• Sarvin Ghiasi Khalehoghli sarvin.ghiasikhalehoghli@mail.mcgill.ca
  
  • Sarvin will be responsible for running tutorial sessions on Mondays and Wednesdays (1:35pm - 2:25pm) at RPHYS 118.
• Motahareh Pour Ahimi motahareh.pourahimi@mail.mcgill.ca
  
  • Motahareh will be helping me with marking lab assigments, quizzes and the final exam.

Course Textbook

I will be using a series of textbooks to teach this course:

1. Achieving DevOps : a novel about delivering the best of Agile, DevOps, and microservices
2. Learning DevOps
3. CODE REVIEW GUIDE - OWASP Foundation
4. Implementing effective code reviews : how to build and maintain clean code
5. Software build systems : principles and experience
6. Static Program Analysis
7. Introduction to software testing
8. Continuous Delivery

Course Schedule

Labs

Labs general directions:TBA

Lab Instructions and Files:

• Lab 1 (Lab_1.pdf) [due Sep 20th]->extended to Sep 27th
  In this lab, there are 12 (small) exercises. If you have never worked with any version control systems like Git the main challenge for you will be to understand the concepts, create an account and worke with the cloned repository. Your main task in this lab is to understand what kinds of benefits you will get by using a version control system rather than keep naming your file like: final.cpp, final2.cpp, reallyFinal.cpp, finalyReallyFinal.cpp, OMGfinal.cpp, etc. It is never ending! You never know which one is the actual final cpp file!

• Lab 2 (Lab_2.pdf) [due Oct 04th]
  In this lab, there is only three exercises. During this lab, you will be using Gerrit, GitHub and GerritHub to add a reviewer, make a change and ask the reviewer manually/automatically to check your changes. Then you will get a notification and try to address the feedback from the reviewer.
  In one part of this lab you should add TA and professor as the reviewer of your code! make sure you do that because if we don't get the message, you don't get the full mark!

• Lab 3 (Lab_3.pdf, Lab_3.zip) [due Oct 29th]
  This lab is challenging because it is your first time writing Makefile. In the first part of this lab, we will be working on a simple compilation process with just one source file. We will learn three main elements of a Makefile and how we can use them towards our goal which is (usually) generating an executable file. In the second part of this lab, we will consider a bit more complex scenario, where the source code is broken down into multiple files. It is more challenging because now we should first compile those files to object code, an intermediate compilation stage. Next we should compile multiple object files to assemble an executable file.

Quizzes

• Quiz 1 [on September 20th]
  This quiz covers lectures from week 1 to week 3, i.e., DevOps Practices and Git.
• Quiz 2 [on October 14th]
  This quiz covers lectures from week 4 to week 6, i.e., Code Review, Gerrit and build systems.
• Quiz 3 [on November 8th]
  This quiz covers lectures from week 7 to week 10, i.e., Static Analysis and Testing.

Final Project

Students will work on their final project in the same teams that they have worked on labs assignment. The task of each group is to use the concepts and tools that they have learned through the course to design, develop, test, and deploy a software project and provide a demo of their project. The following points need to be addressed in the final presentation of your project.

• The software has to have at least seven components (or classes) that are coded into different files.
• To manage different version of the software a version control systems like git must be used
• You should demonstrate that you code has multiple branches, e.g., main, bugfix/…,feature/…, etc. that are merged into your main line of development every couple of days.
• One student mush act as a code reviewer and send his/her feedback to the other student using code review system like Gerrit or GerritHub
• Each team must demonstrate how unitary and integration testing performed to ensure the software is free of bugs in each release.
• Each team must use an automatic build system.
• Each team must use a static code analysis approach in their project.
• Each team must use a continuous integration orchestration tool like Jenkins to build artifacts throughout the pipeline.

Note: You are free to choose any programming languages that you are more familiar with.

Late Submission Policy

• If you submit your work 15 minutes after the deadline, then you lose 5% of the total grade.
  
• If you submit your work 24 hours after the deadline, then you lose 10% of the total grade.
  
• If you submit your work 48 hours after the deadline, then you lose 20% of the total grade.
  
• If you submit your work 72 hours after the deadline, then your submission will not be considered.
  

Grade distribution

• Lab 1 weights 6.0%
• Lab 2 weights 6.0%
• Lab 3 weights 6.0%
• Lab 4 weights 6.0%
• Lab 5 weights 6.0%
• Quiz 1 weights 10.0%
• Quiz 2 weights 10.0%
• Quiz 3 weights 10.0%
• Final Project weights 10.0%
• Final Exam weights 30.0%
• Bonus point 10.0%

You can earn the Bonus point in two ways:

• If you give a presentation (up to 5.0%)
• If in your final project you add extra steps and making significant contributions in the labs (up to 5.0%)