Week 1 - introduction¶

During this week, you will find your team, set up the necessary tools and external environments, and prepare for the development of your project. The goal is not to write a lot of application code, but to build a stable and automated foundation for entire development cycle work.

Introduction¶

Welcome to the first practical lab session. The most critical phase of any project is the beginning. Decisions made this week about tooling, communication, and workflow will impact your team's efficiency for the entire semester.

This week's objective is to go from zero to a fully configured project repository. By the end of this lab, your team should have a chosen tech stack, a Git repository with a clear branching strategy, and a basic CI pipeline that automatically runs when repository events take place.

Challenges¶

Before diving into the tasks, consider the core problems we are trying to solve this week. These are common failure points in real-world projects.

• Team Alignment & Communication: How will your team communicate effectively? How do you make decisions about technology or code style? What happens when there are disagreements? Establishing a clear communication protocol is the first step.
• Reproducible Environments: The classic "it works on my machine" problem is a major source of wasted time. How will you ensure that every team member — and the future CI pipeline — runs the application with the exact same software versions and dependencies?
• Defining and Enforcing Quality: How do you ensure all code committed to the repository maintains a consistent style and is free of common errors? It is inefficient to rely on manual code review for style issues. We require an automated method to establish and enforce a quality standard.

Development project¶

This week's focus is on the project scaffold, not the application features. Your aim is to create a minimal application that can be launched without any errors. It does not need to do anything useful yet. For example, it could be a backend that exposes a single /health endpoint or a frontend that displays a "Hello, World!" message. This ensures your development environment and pipeline are working before you add complexity.

Environments and tools¶

Version control:

• Git for version control
• UT CS GitLab for Git repository hosting and collaboration, also CI/CD tools

Everything else:

• At the moment no other tools or environments will be provided by us.
  • You will be developing locally and using provided version control tools.
  • Choose a tech stack that you are comfortable with.
  • More info in the tasks section.

Tasks¶

This is the list of tasks you will be working on this week:

• Form your team!

  • Organize yourself into teams of three people.
  • Decide on a team name!
  • Let the teaching staff know your team name, the members of your team and the lab time you will be attending.
  • Recommended: Create a Slack channel for your team.

• Setup your GitLab project

  • Once the teaching staff has invited you to the GitLab group, create and setup your team's group and projects.
  • Decide on the branching/merging strategies, and general workflow.

• Choose your tech stack

  • You'll be developing a platform similar to Reddit.
  • Decide on which programming languages and frameworks you will use.
    • You will eventually do linting, unit tests, containerization, observability etc. Keep that in mind.
  • Decide on how you will structure the projects:
    • Whether to use a monorepo or a multi-repo approach.
    • Whether to separate the frontend and backend, or have a monolithic application.
    • Recommended: do basic systems modelling and design before deciding.
  • Important: You can use any language, frameworks and tools you want, but it's up to you to work with them for the rest of the course.
    • In general, teaching staff can help with Python/Go for the backend, Javascript/Typescript for the frontend.
    • Some teaching staff members have experience with other languages and frameworks, but don't count on it.

• Create a local environment

  • Configure your preferred IDE to work with your chosen tech stack.
  • Create a "scaffold" (basic template) of your application. Focus on just getting something to run.
  • Make sure you can run the application locally.

• Figure out the code quality standards and tooling

  • Decide which tools you will use based on the chosen tech stack.
  • Configure the code quality tools to enforce your chosen standards.
  • Try the code quality tools out locally.

• Implement the initial CI/CD pipeline

  • Create a .gitab-ci.yml file in your GitLab projects.
  • Decide on your CI/CD pipeline stages, and create a "Hello World" job, that runs on every push to the main branch.
  • Make sure your CI/CD pipeline runs.

• Test out the full development workflow

  • You should be able to pull/push code to your GitLab projects.
  • Pushes should trigger CI pipeline execution.
  • You should be able to create and use merge requests.

• Recommended: Start writing documentation about your project.

  • Write a README file.
    • Write a technical design document - how the application is structured, how the different components interact with each other, etc.
    • Write a development document — how to run the application locally, how to run the tests, etc.

Organizational¶

Next week¶

In the next week, we will start implementing the features of the application. You'll be given a list of requirements, and you'll need to implement them.

You will also start working on the linting and testing CI/CD pipeline, to ensure that your code is always in good shape throughout the semester.