Michael: Workflows, 2weeks

[MichaelMugaiga]

[my fork of module repository]()

Learning Objectives

🥚 0. Local Development Without Git

Practice the foundational workflows of software development by learning to write Markdown locally on your own computer using Visual Studio Code (VSCode), the Command Line Interface (CLI), and NPM scripts to automate your code's quality (formatting, linting and spell checking).

• [x] 🥚 Folder Structures: You can explain how files and folders are stored in your computer and can find, open or create files in your computer without using the Command Line Interface.
• 🥚 Command Line Interface (CLI): In a Unix shell you can ...
  • [x] open a new terminal window
  • [x] navigate up and down directories using cd
  • [x] list the contents of a directory using ls
  • [x] view the contents of a file using cat
  • [x] create new files using touch
  • [x] create new folders using mkdir
• [x] 🥚 Markdown: You can write a document in Markdown with no syntax mistakes that renders into a well-formatted document.
• 🥚 VSCode: You can complete these workflows in VScode, and can use keyboard shortcuts to complete them all:
  • [x] Opening a repository in a new window
  • [x] Opening the VSCode terminal
  • [x] Adding a new file
  • [x] Adding a new folder
  • [x] Deleting a file
  • [x] Deleting a folder
  • [x] Previewing a Markdown File
  • [x] Formatting a Markdown document
• [x] 🥚 READMEs: You can write a README file that describes the project you are working on, why it's helpful, and how someone can use it.
• 🥚 NPM: You can use NPM commands to verify your code's quality, this includes ...
  • [x] using npm install to install a project's dependencies
  • [x] reading a package.json file to find which scripts are available for the project
  • [x] use npm run <script> to execute an npm script
• 🥚 Formatting Code: You can use Prettier to make sure all the code in your project is well-formatted:
  • [x] You can use the Prettier VSCode extension to format a document while you are writing it
  • [x] You can use npm run format to format all of the documents in your project
  • [x] You can use npm run format:check to make sure all files are well-formatted
• 🥚 Linting Folder and File Names: You can ...
  • [x] use npm run lint:ls to check all folder and file names in your project
  • [x] you can fix all linting mistakes reported by npm run lint:ls
• 🥚 Linting Code: You can ...
  • [x] use npm run lint:md to check all Markdown files in your folder for linting mistakes
  • [x] you can fix all linting mistakes reported by npm run lint:md
• 🥚 Spell Check: You can ...
  • [x] use the Code Spell Checker VSCode extension to correct spelling mistakes in your Markdown documents while you are writing
  • [x] use npm run spell-check to check the spelling in all the files of your project
  • [x] update .cspell.json to add words that should be allowed in your project
• 🥚 File and Folder Naming Conventions: You can ...
  • [x] identify and follow the naming conventions for the project you are working on.
  • [x] use npm run lint:ls to check that all files and folders follow the project's naming conventions.
  • [x] you can correct any file and folder names to make them match the project conventions.
• [x] 🐣 File Extensions: You can identify all of the languages covered at HYF and give the correct file extension. You don't need to know the languages, just recognize them.
• [x] 🐣 Touch Typing: You can write a Markdown file without looking at your keyboard to find any letters, numbers or special characters. (slowly is ok!)

🥚 1. Local Development With Git

Practice using Git to save and organize your development process. You will learn how you can use Git to go back to previous versions of your project, and to work on different changes in parallel.

• 🥚 Git: Using the CLI you can ...
  • [x] Initialize a new git repository with git init
  • [x] stage changes using git add <path>
  • [x] check what is staged with git status
  • [x] commit changes using git commit -m <message>
  • [x] display your repository's git history using git log
  • [x] create a new branch using git branch <branch-name>
  • [x] check out a branch using git checkout <branch-name>
  • [x] create a new branch and check it out using git checkout -b <branch-name>
  • [x] merge changes from one branch to another using git merge <branch-name>
  • [x] return to a previous version of your project with git log and git checkout <commit-hash>
  • [ ] stash and retrieve uncommitted changes with git stash and git pop
• 🥚 .gitignore: You can use a .gitignore file to describe which files you don't want included in your git history.
• 🥚 VSCode: You can ...
  • [ ] use the Git Graph extension to to visualize your repo's commit history
  • [ ] use the Git Lens extension to investigate your repository's commit history
  • [x] explain how the file tree in VSCode can show you which files have uncommitted changes
• [x] 🥚 Atomic Commits: You can save your development progress using small commits with clear and helpful message.
• [x] 🐣 Feature Branches: You can organize your development process using branches. You can create a new branch for each part of your project and merge those changes to main when they are finished.

🥚 1. Local/Remote Development

Learn how you can connect your local Git repositories with a GitHub repository to add more structure to your development process and to share your projects.

• 🥚 Licenses: You can ...
  • [ ] explain why it's important to include a license for your code on GitHub
  • [ ] choose a license for your projects that matches how you want others to use your code
• [x] 🥚 GitHub SSH Key: You can connect your computer to your GitHub account using an SSH key, clone using the SSH link, and push/pull using your SSH connection.
• 🥚 GitHub Repositories: You can ...
  • [x] create new repository on GitHub
  • [x] write a description for your repository
  • [ ] turn on GitHub Pages
  • [ ] configure your repository to block pushing to main
  • [ ] configure your repository to block merging to main until Continuous Integration (CI) checks have passed
• 🥚 Git Remote/Local Connection: You can ...
  • [ ] clone a remote repository to your computer
  • [ ] initialize a new repository locally and connect it to an empty remote repository
  • [x] push and pull changes between remote & local branches
• [x] 🥚 Pull Requests: You can create a pull request between two branches in your repository and merge changes without causing any conflicts.
• [x] 🥚 PR templates: You can use a PR template to add a checklist to all of your PRs so you are sure the code is great before merging to main.
• [x] 🥚 Continuous Integration: You can use GitHub Actions to check your code's quality before merging a pull request to the main branch.
• [x] 🐣 Local/Remote Branching Workflow: You can use a branching workflow that keeps mistakes away from the main branch and prevents conflicts from happening in GitHub. For each contribution to the project you can ...
  1. Check out a new local branch and write your code
  2. Check out main on your local machine
  3. Pull changes from remote main to local main
  4. Merge changes locally from main to your new branch
     • Fix any conflicts on your new branch before pushing!
  5. Format and lint your code
  6. Push your new local branch to your remote repository
  7. Open a Pull Request from the new branch to main
     • Go through the PR's checklist to make sure everything is correct
     • Make sure all CI checks pass!
  8. Merge your new remote branch to main
     • You can delete the branch after it's merged if you want to

[MichaelMugaiga]

• [ ] I have pushed my progress to my fork of exercises repo

I Need Help With:

At the moment I don't need help.

What went well?

Working with Markdown, cloning the repository, creating branch as well as going from one branch to another using git checkout, committing and pushing any changes to my developments.

What went less well?

I had a challenge with my code verification using npm, some npm commands couldn't run because I had a lower version nodejs installed on my computer. I downloaded a new version and installed it. after upgrading nodejs I was able to run npm commands to verify my code.

Lessons Learned

I have learned that after any changes to the code or a software update during the process of committing code, we need to re-run npm install to verify our code again and thereafter proceed with committing and pushing the changes. This is because after upgrading my nodejs I didn't run this command again and went straight to the command that had earlier failed before the software upgrade, then during merging my pull request, my instructor Tugba highlighted some missing info, and advised me to re-run npm install. All was fine after re-running this command

Sunday Prep Work

I'm now going through Sunday's material.

What materials were most helpful (from HYF or elsewhere)?

I found two very helpful and interesting websites about GitHub. https://www.earthdatascience.org/workshops/intro-version-control-git/pull-request/ this has notes on git and GitHub and explains all commands used.

I recommend this for anyone who is trying to learn or get familiar with git hub. learngitbranching.js.org

[yildiztugba]

hi @MichaelMugaiga, you are going well!!

You did great with sharing the materials that was helpful for you on Slack.

I recommend this for anyone who is trying to learn or get familiar with git hub. learngitbranching.js.org

[MichaelMugaiga]

Workflows: Week 2

I Need Help With: At the moment I don't need help.

What went well? Creating discussions, linking a pull request to an issue, modifying code locally on my computer and using the git push to push the changes to the repo. Creating directories and adding files to them.

What went less well? I had challenge deleting a commit to files that I had already pushed to repo, it was challenging and eye opening to further information on github. For instance I added to commit package.json files and pushed to the repo, undoing this commit was challenging and it was new for me to do on already pushed files without any impact.

Lessons Learned I now have a clear and straight forward understanding of GitHub pull requests and how they are used to submit changes to a repo, github collaboration on who you want to review an issue or pull request and how issues are used to track changes as well as using discussions for changes in the github repo.

Sunday Prep Work Currently doing practice on HTML and CSS .