Week 1 Project Management

This week is all about planning, websites, version control, and documentation. Version control and git is important for Fab Academy because it gives an easy method to control failures, manage the versions and provide reproducabilitiy.

By the end of the week, I was able to:

  • Communicate an initial project proposal through a structured website
  • Identify and utilize version control using Git and GitLab
  • Explore and use Hugo as a static site generator
  • Deploy a personal documentation website using GitLab Pages

Version control is especially important in Fab Academy because it allows:

  • tracking changes over time,
  • recovering from mistakes,
  • collaborating across labs,
  • and ensuring long-term reproducibility of documentation.

Environment

Laptop Specifications:

  • Device: Macbook Air
  • OS: macOS Sequoia 15.6.1
  • Shell: bash
  • Code Editor: VSCode

I used the integrated terminal in VSCode, which allowed me to edit Markdown files and run Git and Hugo commands without switching tools.

Setting up Git

I already had git installed in my system, but to double check we can use the command:

git --version

Output:

git version 2.15.0

This confirmed that Git was available and ready to use for version control.

Setting up GitLab

My project and account was already set up in FabCloud and I could enter GitLab using the information from the email that came from Fabacademy coordination.

This repository serves as the single source of all my Fab Academy documentation.

SSH Setup

Using SSH keys is important to not type your account username and password every time you are commiting.

SSH keys are a pair of files that prove your identity to a server. Your computer has a “private” key and usually the server (or GitLab in our case) has the corresponding “public” key.

This website was useful when setting SSH up: https://medium.com/@viviennediegoencarnacion/manage-github-and-gitlab-accounts-on-single-machine-with-ssh-keys-on-mac-43fda49b7c8d

1) Generate Keys

ssh-keygen -t rsa -C "<your mail>" -f ~/.ssh/id_rsa_gitlab

This generated a public/private key pair specifically for GitLab.

2) Copying and Pasting the Keys

Copying:

pbcopy < ~/.ssh/id_rsa_gitlab.pub

The command above copies the keys generated directly to the clipboard.

Pasting: I then went to my GitLab account and pasted the copied key into:

GitLab --> edit profile --> ssh keys

3) Register the Key with the SSH Agent

ssh-add --apple-use-keychain ~/.ssh/id_rsa_gitlab

This allows macOS to securely store and reuse the key.

4) SSH Config for GitLab

Edit the ~/.ssh/config file by entering the command:

nano ~/.ssh/config

Paste the following in the file:

Host gitlab.com
  HostName gitlab.com
  User git
  IdentityFile ~/.ssh/id_rsa_gitlab
  AddKeysToAgent yes
  UseKeychain yes

This tells SSH to always use your GitLab key when talking to gitlab.com. This becomes very important when multiple SSH keys are on the same machine or when working with both GitHub and GitLab at the same time.

5) Test the SSH Connection

ssh -T git@gitlab.com

On success you should see a greeting like:

Welcome to GitLab, @<your-username>

Cloning Repo

I cloned my project that was already available on GitLab mehmet-bener:

git clone git@gitlab.fabcloud.org:academany/fabacademy/2026/labs/hisar/students/mehmet-bener.git
cd mehmet-bener

In addition to setting up my repository, I worked through a Git tutorial covering cloning, committing, pushing, and SSH-based authentication. The git tutorial covered:

  • cloning
  • committing
  • pushing
  • handling SSH authentication

Here’s a little cheetsheet I created to help me with git commands:

git status                     # Check the current state of the repository
git add .                      # Stage all modified and new files
git commit -m "message"        # Commit staged changes with a message
git push -u origin main        # Push commits to the main branch on GitLab
git pull                       # Fetch and merge latest remote changes

Local Site Setup

1) Install Hugo

I didn’t have hugo installed on my laptop so I installed it with the command:

brew install hugo

Hugo is a static site generator that converts Markdown files into a fast website.

2) Select a Theme from Hugo

I selected the beautifulhugo theme but you can select any theme you want from: https://themes.gohugo.io/

Themes decide the layout and visual appearance of the site.

3) Set Up Site

Create the site:

hugo new site <site-name>

Initialize git:

git init

Add the theme you want as a submodule:

git submodule add <github-link-of-the-theme> themes/<name-of-theme>

Now enter the hugo.toml file and change the following line:

theme = "<name-of-theme>"

4) Run Site Locally

Now run the site locally when in the root directory of the site and run:

hugo serve -D -F

The -D flag includes draft content, and -F includes future-dated posts, which is useful during development before final publishing.

This command runs a local development server.

Customize Site

Now I customized and edited the site locally until I was happy and ready to publish.

Firstly, I added the pages I wanted to see in the header by modifying the hugo.toml file and adding the parts below:

baseURL = "/"
languageCode = 'en-us'
title = 'Mehmet Bener Fab Academy Site'
theme = "beautifulhugo"

[params]
  mainSections = ["post"]

[menu]

  [[menu.main]]
    name = "Final Project"
    url  = "/page/final-project/"
    weight = 40

  [[menu.main]]
	name = "Weekly Assignments"
	url  = "/page/weekly/"
	weight = 40

Content Organization

Then, I created and wrote the .md files:

  • Inside the /content/page/ directory I created my weekly.md, student_agreement.md, prefab.md, week-01.md and final-project.md files and wrote their contents.

Example Post Content:

---
title: "About Me"
date: "2025-12-21"
type: "post"
---

Hello, I’m Mehmet

Hello! My name is Mehmet Bener, and I’m currently a sophomore at Hisar School. As an active member of the ideaLab Fablab, over the past few years, I have contributed to FRC team #6431, done research on HCI and robotics.

I'm part of the 2026 Fab Academy class at Hisar School ideaLab Fablab located in Istanbul, Turkiye. It's a place where we tinker, prototype, and bring ideas to life guided by the motto "Make, fail, learn, repeat". From CNC machining to 3D printing, we explore all things digital fabrication in our journey to become better makers.

As you can see, I explicitly specified the content type as post which makes Hugo see it as a blog.

Example Page Content:

---
title: "Final Project"
type: "page"
menu: "main"
weight: 20
---

My Project is an interactive learning device that takes inspiration from the "Quizlet" app and teaches students concepts that they want to learn using flashcards, questions, quizzes and even live competitions. Students can upload their notes through the website and an AI model can generate questions or flashcards for the user to study the material.

I specified the content type as page and added it to the main menu which allows it to appear in the websites nav bar.

While writing these files I could see the result of my changes by saving the files and running:

hugo serve -D -F

Note: I will be writing my documentations like this one from the Obsidian app and then exporting the docs as .md files and adding them to the /content/page/ directory.

Deploying Website

Add a .gitlab-ci.yml file at the root directory to automate deployment:

image:
  name: hugomods/hugo:exts
  entrypoint: [""]

variables:
  GIT_SUBMODULE_STRATEGY: recursive

pages:
  script:
    - hugo version
    - hugo --gc --minify --baseURL "$CI_PAGES_URL/" --environment production
    - test -f public/index.html
  artifacts:
    paths:
      - public
  rules:
    - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'

Also add a .gitignore file at the root of the directory:

public/
resources/
.DS_Store

This prevents generated files from being tracked by Git.

As we have done all changes needed locally, now we can push to git:

git add .
git commit -m "commit message"
git push -uf origin main

Pushing to git at least at the end of every work day is important to save and not lose your work.

After all of these commands I faced many errors while deploying to GitLab Pages because my account wasn’t fully set up yet. After verifying my account fully, the deployment was successful and I could access my website.

A fully automated documentation workflow was established, enabling reliable version control, local preview, and continuous deployment for all future Fab Academy assignments.

What I Learned?

  • Learnt the importance of structured documentation and planning for a long-term iterative process such as Fab Academia
  • Understand how versioning via Git and GitLab can track changes in a file, recover from errors, and make confident changes without breaking the code. Developed hands-on experience with major Git operations like clone, commit, push, pull, and the use of SSH authentication.
  • Avoid repetition in the input of login information by understanding the increased security and efficiency that come with the use of SSH keys. Learning how Hugo works and its importance to be a static site generator - it transforms Markdown files into a fast, structured one.
  • Understand the impact of content types, like post vs. page, and configuration files on how to drive a website and its behaviors.
  • Gained experience in debugging issues associated with deployment on GitLab Pages and understanding of the role of CI pipelines in automated website building. - Wrote a complete automation for local preview, version control, and continuous deployment of the documentation.

Overall this was a great and productive week which came natural to me as I have worked with Git and Version Control and Website Development before.