DEV Community: Bello Osagie

Fast & Clean TypeScript Workflow with Environment Variables, Bun, and ts-node-dev

Bello Osagie — Fri, 18 Jul 2025 21:38:09 +0000

Here's how to bootstrap and evolve your Express‑style TypeScript app step by step:

1. Project Initialization

Initialize your project and TypeScript entry point:

npm init -y
mkdir src
touch src/app.ts .env.local .gitignore

Your package.json now has defaults, and you have:

src/app.ts – your app entry
.env.local – development env file
.gitignore – to protect sensitive files

2. Environment Variables in `.env.local`

# .env.local
PORT=5000

This file sets PORT=5000 for development, allowing differentiation from production.

3. TypeScript & `@types/node` Setup

Install type definitions for Node.js to fix lint issues like process.env.PORT:

npm install -D @types/node

@types/node provides TypeScript types for built-in Node APIs, improving IDE feedback.

4. Reading Env & Demo Outputs

// src/app.ts
const PORT = process.env.PORT;
console.log(`PORT is ${PORT}`); // undefined w/o loading env file

enum MyEnum { A, B }
console.log(MyEnum.A);

// Type stripping demo with Node
const calcSum = (a: number, b: number) => a + b;
const calc = calcSum(4, 10);
console.log(`The sum is ${calc}`);

With node src/app.ts, .env.local is not loaded, so PORT is undefined.
Node runs TS by stripping type annotations, even if types mismatch—it doesn't type-check at runtime.

5. Scripts & Loading `.env.local`

In package.json:

"scripts": {
  "dev": "node --env-file=.env.local src/app.ts"
}

npm run dev now loads .env.local, so PORT logs 5000.
For production, switch to .env with "start": "node --env-file=.env src/app.js".

6. Safe `.gitignore`

.env
.env.local
node_modules
dist

This prevents secrets and build artifacts from leaking to GitHub, and node_modules is rebuilt via npm install, avoiding bloat.

7. Enable Watch Mode

Improve dev workflow:

"dev": "node --env-file=.env.local --watch src/app.ts"

This watches for file changes without extra tools (no nodemon or ts-node).

8. Node’s Inline Type Stripping: Behavior

Node v23.6+ strips types automatically (no --experimental-strip-types needed). E.g.,:

const calcSum = (a: number, b: boolean) => a + b;
console.log(calcSum(3, true)); // logs 4 — no type-checking

TypeScript errors won’t be caught at runtime—types serve only as editor aids.

9. Faster Dev with `ts-node-dev`

Install:

npm install -D ts-node-dev

Use in scripts:

"scripts": {
  "dev": "tsnd --respawn src/app.ts"
}

ts-node-dev keeps TypeScript compiler in memory and restarts faster than node-dev or nodemon.
Remove --transpile-only to enable full type-checking before runtime.
--respawn ensures clean restarts on file change.

10. Build Output is In-Memory

Even with tsconfig.json configured (rootDir: "src", outDir: "dist"), ts-node-dev runs in-memory—so no dist folder appears unless you compile manually.

11. Bun—Fast, but Selective Support

You experimented with Bun:

"scripts": {
  "dev": "bun --watch src/app.ts",
  "check": "tsc --noEmit",
  "build": "bun build src/app.ts --outdir dist",
  "start": "bun run dist/app.js"
}

Bun is extremely fast and first-class TS, but OS support is not as universal as Node.
Like Node, Bun strips types only and relies on editor + tsc for type-checking.

Summary Workflow

Phase	Command	Notes
Dev	`npm run dev`	Loads `.env.local`, watches files, no type-check
Build	`npm run check && tsc && bun build`	Type-check + compile to `dist/`
Production	`bun run dist/app.js` or `node dist/app.js`	Run compiled code for consistency across OS

TL;DR

Use .env.local for dev, .env for prod, and ignore both in Git.
Node/Bun auto-strip TS types—they don’t type-check at runtime.
For speed: use ts-node-dev or Bun’s watch.
For safety: run tsc --noEmit during build or CI.
Choose Node as your runtime for maximum OS compatibility; Bun is optional for speed gains.

Set Up VS Code Extensions the Right Way — Express.js Series (Ep. 1 Highlights)

Bello Osagie — Wed, 16 Jul 2025 18:41:18 +0000

In the first episode of our Express.js Series, we covered how to set up your macOS development environment using tools like Homebrew, VS Code, and Node.js via NVM. But we also dove deep into an often overlooked aspect of developer experience — properly configuring VS Code extensions and Amazon Q shell integration.

Even though you may have installed everything correctly, some tools don’t just work out of the box unless you configure or activate them. Let’s walk through what we learned in the video 👇

Installing Extensions in VS Code

VS Code makes it easy to install extensions — either:

Using the Extensions sidebar (click the Extensions icon on the left panel)
Or installing them via a Brewfile or Chocolatey if you're on Windows

But installation is just the first step. Some extensions need manual activation or configuration.

Amazon Q Extension in VS Code

Even if you installed Amazon Q (the AI-powered coding assistant) from the VS Code Marketplace or via a Brewfile, it won't work until you sign in:

After installing Amazon Q:

Click the Amazon Q icon in the VS Code sidebar
Click the "Sign In" button
Complete the sign-in process via your browser

Once signed in, it should begin offering code suggestions and inline assistance.

GitHub Theme Not Working?

If you installed the GitHub Theme but don’t see any visual changes, here’s what’s probably missing:

After installation, VS Code does not automatically apply the new theme.
You need to manually select it by:

Pressing Cmd + Shift + P (Mac) or Ctrl + Shift + P (Windows)
Typing Color Theme
Clicking "Set Color Theme"
Choosing the GitHub theme from the list

Now you’ll get that clean GitHub look.

Material Icon Theme Not Applied?

Same issue here. Installing the Material Icon Theme isn’t enough. To activate it:

Open the Command Palette (Cmd/Ctrl + Shift + P)
Search for "Set Icon Theme"
Choose Material Icon Theme

Once activated, you’ll notice your file icons change to the familiar Material Design styles.

Postman Web: Sign In to Use It

If you're using the Postman web app (instead of the desktop version):

You must sign in before making requests
Click the Sign In button (usually top-right)
Complete the authentication process
Once signed in, you can start making requests just like the desktop app

Extensions That Work Automatically (No Config Needed)

Some extensions work instantly without additional steps:

Markdown All in One
→ Just open a .md file like README.md
→ Use Cmd/Ctrl + Shift + P and select Markdown: Open Preview to see a live preview
Prettier and Biome
→ These can auto-format your files on save if VS Code is set to format on save
→ No additional config needed for basic usage

Global Tools: Amazon Q in Terminal (Shell Integration)

Besides the VS Code extension, Amazon Q also offers a global shell assistant that works in the terminal (both standalone and in VS Code).

But here's the key: it doesn’t work until you set it up correctly.

Search for Amazon Q from your system search bar (Spotlight on macOS)
Open the app and click:

"Get Started"
"Install Shell Integration"
"Sign In" (if not signed in)
1. In the Amazon Q window, go to Help & Support
Make sure:
- Shell Integration is Enabled
- Accessibility is Enabled

Once set up:

Open a new terminal (outside VS Code) and try typing a command
You’ll get inline suggestions from Amazon Q
Press Ctrl + K to expand the full suggestion

Bonus Tip: It also works inside the VS Code integrated terminal, but only if:

VS Code is restarted after shell integration is enabled
Or run exec $SHELL in the integrated terminal to reload it

If Amazon Q Isn't Working in Terminal...

If you’re on macOS, check for the Amazon Q icon in the top menu bar.

If it's not working:
- Click the icon
- Check for any "Not Logged In" messages
- Click "Login" or "Settings" and re-authenticate

Amazon Q shell support may be limited or unavailable on Windows at this time.

Final Thoughts

Setting up your environment goes beyond installing software — it’s about knowing what to configure and when.

If you want a smoother experience with your development tools:

Sign into cloud-based tools (Amazon Q, Postman)
Don’t forget to activate themes and icons after installing
Use the Command Palette (Cmd/Ctrl + Shift + P) for most setup tasks

Want to go deeper? Check out the full setup video on YouTube or read the full blog post:
👉 Set Up Node.js + VS Code the Right Way on macOS – Express Series Ep. 1

Git and GitHub Crash Course for Express.js Developers

Bello Osagie — Mon, 14 Jul 2025 22:50:16 +0000

A practical guide to version control, GitHub CLI, and managing branches using Git and GitHub with Express.js projects — no fluff, just real-world workflow.

Introduction

Whether you're a beginner or working your way through a Node.js + Express.js project, using Git and GitHub is essential for version control and team collaboration. In this guide, you’ll learn how to:

Set up Git and GitHub from scratch
Use Git in the terminal
Use GitHub CLI to create and manage remote repositories
Connect your local project to GitHub
Create and switch between branches
Work with GitHub directly from your browser via GitHub.dev and VSCode.dev

This guide is hands-on and practical — no prior Git knowledge needed!

Prerequisites

Make sure you have the following installed:

Git (brew install git on macOS, choco install git on Windows)
GitHub CLI (gh)
A GitHub account

You can also use:

VSCode.dev – Web-based VSCode
GitHub.dev – Open any GitHub repo in browser with .dev

Step-by-Step Guide

1. Create or Sign In to Your GitHub Account

If you don’t already have a GitHub account, sign up here. This will allow you to push your code to the cloud and collaborate with others.

2. Open VSCode.dev or GitHub.dev

Visit https://vscode.dev for a blank editor
Or go to any GitHub repo and press . to open github.dev (web-based IDE)

Great for quick edits without local setup.

3. Initialize Git in Your Local Project

Navigate to your Express project folder and run:

git init

This sets up a .git directory and prepares your project for version control.

4. Configure Git Author Info

Set your username and email. You can use --local (for this project) or --global (applies to all repos):

git config --local user.name "Your Name"
git config --local user.email "you@example.com"

To confirm config:

git config --list

5. Stage and Commit Your Changes

Add all files:

git add .

Commit them:

git commit -m "Initial commit"

6. Create a GitHub Repository Using GitHub CLI

Use gh (GitHub CLI) to create a new repo:

gh repo create your-repo-name --public --source=. --push

This automatically:

Creates the repo on GitHub
Connects it to your local repo
Pushes your code

If you don’t have the GitHub CLI yet:

brew install gh  # on macOS
choco install gh  # on Windows

7. Create and Switch to a New Branch

git checkout -b feature/branch-name

Example:

git checkout -b feature/2025/01-basic-dev-setup

This is useful when working on a new feature while keeping the main branch stable.

8. Push Branch to GitHub

git push -u origin feature/2025/01-basic-dev-setup

This creates a remote branch and links it to your local one.

Summary Commands Cheat Sheet

Task	Command
Initialize Git	`git init`
Configure Git	`git config --local user.name "Your Name"`
Add all files	`git add .`
Commit changes	`git commit -m "message"`
Create branch	`git checkout -b branch-name`
Push branch	`git push -u origin branch-name`
Create repo (CLI)	`gh repo create`

Useful Tools

📽️ Bonus: Watch the Full Video Tutorial

🎥 Git & GitHub for Express Developers – Full Guide
🖥️ Subscribe to Techstack Space for more tutorials.

Final Thoughts

Now that you know how to set up and use Git and GitHub in your Express projects, you’re one step closer to becoming a professional full-stack developer.

If you found this useful, share it, and let me know your questions in the comments!

Support This Project

If you find value in this content, consider supporting Techstack Space:

☕ Buy Me a Coffee
🌐 Visit Our Website

Setting Up Your Windows Dev Environment for Node.js & Express (The Right Way)

Bello Osagie — Sun, 13 Jul 2025 01:41:20 +0000

This is Part 2 of my Express.js Series — setting up a solid foundation before we start writing any backend code.

Whether you're just diving into backend development or setting up a fresh environment, this guide walks you through a clean, scalable Windows development setup tailored for Node.js and Express.js.

Why the Setup Matters

Before jumping into building APIs, it's important to make sure your environment is consistent, efficient, and manageable. A cluttered or misconfigured system can lead to debugging nightmares.

Instead of manually downloading everything, we'll use Chocolatey, NVM for Windows, and curated VS Code extensions to streamline and future-proof your setup.

What We’re Setting Up

By the end of this setup, you’ll have:

Chocolatey managing your dev tools
Node.js versions managed cleanly via NVM
A curated VS Code setup with powerful extensions
MongoDB tools and CLI
Git, Postman, a modern browser, and more

Two Ways to Install Software on Windows

Just like macOS, there are two main methods:

Manual Downloads from Websites
(e.g., download VS Code installer from the official site)
Command-line Installs with Chocolatey (Recommended)
Automate and simplify your entire setup with repeatable scripts

💡 For devs, I strongly recommend using Chocolatey. It's the Homebrew of Windows.

Installing Chocolatey

Run PowerShell as Administrator and paste this one-liner:

Set-ExecutionPolicy Bypass -Scope Process -Force; `
[System.Net.ServicePointManager]::SecurityProtocol = `
[System.Net.ServicePointManager]::SecurityProtocol -bor 3072; `
iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

Confirm it’s working:

choco --version

Installing Tools with Chocolatey

Create a script file or run each command manually in Admin PowerShell:

choco install git -y
choco install vscode -y
choco install postman -y
choco install googlechrome -y
choco install arc-browser -y
choco install warp-terminal -y
choco install mongodb-compass -y
choco install mongodb-database-tools -y
choco install gh -y
choco install bun -y
choco install nvm -y

Some packages may need Chocolatey community extensions enabled. If prompted, just follow instructions or run:

choco feature enable -n allowGlobalConfirmation

In the tutorial, a file named choco-packages.config was created in the express-app project directory, located at C:\Users\YourUserName\Documents\express-app\config.

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="git" />
  <package id="gh" />
  <package id="bun" />
  <package id="nvm" />
  <package id="mongodb.install" />
  <package id="mongodb-compass" />
  <package id="mongodb-atlas" />
  <package id="postman" />
  <package id="vscode" />
</packages>

Install all packages with the command:

choco install C:\Users\YourUserName\Documents\express-app\config\choco-packages.config\choco-packages.config

Managing Node the Right Way: Use NVM

Why not use the global Node installer?

Global installs can lead to version conflicts, especially when tools like MongoDB CLI bring their own Node dependencies.

NVM for Windows is better.

NVM lets you manage multiple Node.js versions side by side and switch between them effortlessly.

Steps to Use NVM (After Chocolatey Installs It)

Open Command Prompt (not PowerShell) and run:

nvm install 20.12.2
nvm use 20.12.2
nvm list

Switch versions:

nvm install 18.17.0
nvm use 18.17.0

Remove a version:

nvm uninstall 18.17.0

Confirm you're using the right version:

node -v
npm -v

VS Code Extensions to Install

Open VS Code and install these from the Extensions Marketplace:

esbenp.prettier-vscode – Prettier code formatter
mongodb.mongodb-vscode – MongoDB integration
Postman.postman-for-vscode – Postman in VS Code
yzhang.markdown-all-in-one – Markdown tools
PKief.material-icon-theme – Better file icons
GitHub.github-vscode-theme – GitHub's official theme
biomejs.biome – All-in-one linting/formatting
bengreenier.vscode-node-readme – Auto README generator
AmazonWebServices.amazon-q-vscode – Amazon Q AI assistant

You can also install them via CLI using:

code --install-extension esbenp.prettier-vscode
code --install-extension mongodb.mongodb-vscode
# ... and so on

Recap: Tools We Installed

Tool	Purpose
VS Code	Code editor
Arc & Chrome	Browsers
Git & GitHub CLI	Version control
MongoDB tools	Database management
Postman	API testing
Bun	JS runtime alternative
NVM for Windows	Node version management
Warp Terminal	Modern dev terminal

Watch the Video Tutorial

Prefer to see this step-by-step? I walk through the entire setup process visually in this episode:

Watch on YouTube

What’s Next?

In the next part of the series, we’ll initialize a real Express.js project and start building APIs with proper structure and tooling.

Subscribe so you don’t miss it!

Feedback?

Drop your thoughts, suggestions, or questions in the comments — I’m always happy to help or improve future tutorials!

Setting Up Your macOS Dev Environment for Node.js & Express (The Right Way)

Bello Osagie — Fri, 11 Jul 2025 21:46:04 +0000

This is Part 1 of my Express.js Series — setting up a solid foundation before we start writing any backend code.

Whether you're a beginner diving into backend development or an experienced dev ready to streamline your setup, this guide walks you through a clean, scalable macOS development environment tailored for Node.js and Express.

Why the Setup Matters

Before jumping into building APIs with Express.js, it's important to ensure your environment is clean, consistent, and developer-friendly.

Instead of installing everything manually from random websites, we’ll leverage tools like Homebrew, NVM, and VS Code extensions — automating the process and making it repeatable.

What We're Setting Up

By the end of this setup, you’ll have:

Homebrew managing your dev tools
Node.js versions managed cleanly via NVM
A curated VS Code setup with key extensions
MongoDB tools and CLI
Git, Postman, Arc, Warp Terminal, and more

Two Ways to Install Software

When it comes to installing tools on macOS, you have two main choices:

Traditional GUI Installers
Downloading installers from each software’s website (e.g., vscode.dev, postman.com)
Command-Line Install with Homebrew
Automating setup with brew, brew cask, and even managing VS Code extensions

I prefer Homebrew, especially for developers, because it makes your setup easier to track, reproduce, and maintain.

Installing Homebrew

If you haven't already installed Homebrew, use this one-liner in your terminal:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Setting Up with a Brewfile

We’re using a Brewfile to install all our tools in one shot. You can create one at:

~/Documents/express-app/config/macOS/Brewfile

Paste this into the file:

brew "gh"
brew "git"
brew "mongodb-community@6.0"
brew "mongodb-atlas-cli"
brew "oven-sh/bun/bun"
brew "mongodb/brew/mongosh"

cask "amazon-q"
cask "postman"
cask "arc"
cask "visual-studio-code"
cask "warp"
cask "mongodb-compass"

vscode "mongodb.mongodb-vscode"
vscode "bengreenier.vscode-node-readme"
vscode "yzhang.markdown-all-in-one"
vscode "Postman.postman-for-vscode"
vscode "esbenp.prettier-vscode"
vscode "GitHub.github-vscode-theme"
vscode "PKief.material-icon-theme"
vscode "biomejs.biome"
vscode "AmazonWebServices.amazon-q-vscode"

Then run:

brew bundle --file=~/Documents/express-app/config/macOS/Brewfile

This installs all listed apps, CLI tools, and VS Code extensions.

Fixing Node.js the Smart Way: Use NVM

Why not just use the global Node installation?

Tools like MongoDB CLIs often install Node.js as a dependency. But that’s not ideal. You don’t want multiple tools messing with global Node.

Here's what I did:

1. Uninstall Node via Brew:

brew uninstall node

2. Install NVM (Node Version Manager):

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Then restart your terminal or run:

export NVM_DIR="$HOME/.nvm"
source "$NVM_DIR/nvm.sh"

3. Use NVM to manage Node:

nvm install node       # Installs latest version
nvm use node
nvm ls                 # Lists installed versions
nvm alias default node # Sets default
nvm uninstall 20       # Example: Uninstalls a version

Now you're in full control of your Node versions—perfect for development and debugging.

Recap: Tools We Installed

Tool	Purpose
VS Code	Code editor
Arc & Warp	Modern browsers/terminals
Git & GitHub CLI	Version control
MongoDB tools	Database management
Postman	API testing
Amazon Q	AI pair programmer
Bun	JS runtime alternative
NVM	Node version management

Watch the Video Tutorial

If you prefer to follow along visually, check out the video that walks through this exact setup step-by-step:

Watch on YouTube

What's Next?

In the next episode, we’ll initialize our Express.js project and start building real APIs!

Make sure you subscribe to stay updated and follow along.

Feedback?

Drop a comment below or on the video if you ran into any issues or want to recommend more tools for the setup!

Git & GitHub Setup Guide for Beginners

Bello Osagie — Fri, 28 Mar 2025 17:52:44 +0000

Introduction

This guide provides a structured approach to setting up Git, GitHub, Homebrew (for macOS), and Chocolatey (for Windows). It also covers the installation of essential tools like Amazon Q, Arc Browser, and Warp Terminal. Whether you're a beginner or an experienced developer, follow this guide step by step to configure your development environment efficiently.

1. GitHub CLI (`gh`) and Authentication

The gh command-line tool allows you to interact with GitHub directly from your terminal. It simplifies repo management, pull requests, issues, and CI/CD workflows.

Authenticate GitHub CLI

gh auth login

Once configured, you can see your Git global settings:

git config --list --global

To remove GitHub authentication data:

gh auth logout -h github.com
rm ~/.git-credentials
rm -rf ~/.ssh/
rm ~/.gitconfig
echo "url=https://github.com" | git credential reject
rm -rf ~/.config/gh

Running echo "url=https://github.com" | git credential reject may not work on all systems. In that case, run the following command:

git credential reject https://github.com

2. Initializing a Git Repository

Git Initialization (`git init`)

git init
ls -la # Lists all files including hidden ones
ls -la .git # View the .git directory

Understanding the `.git` Folder

HEAD: Points to the current branch.
config: Stores repository settings.
refs/: Contains references to commits (branches and tags).
objects/: Stores commit objects.
hooks/: Scripts that trigger on Git events.

To view details inside .git, run:

cat .git/HEAD
cat .git/config
ls -la .git/refs/heads/ # See available branches
ls -la .git/objects/

3. Tracking Changes with Git

Adding Files to Staging

git add <file_name>

Committing Changes

git commit -m "Added new file"

Pushing Changes to GitHub

git push origin main

Undoing Commits

Undo the last commit (keep changes unstaged):

git reset --soft HEAD~1

Undo the last commit (discard changes):

git reset --hard HEAD~1

Resolving Merge Conflicts

git status # Check conflicts
nano <conflicted_file> # Edit the file to resolve conflicts
git add <conflicted_file>
git commit -m "Resolved merge conflict"

4. Git Configuration and Credential Management

Checking Local & Global Git Configuration

git config --list --local # Show local repository settings
git config --global --list # Show global settings

Storing Credentials

macOS:

git config --global credential.helper osxkeychain

Linux:

git config --global credential.helper cache

Changing Default Editor

Use Nano:

git config --global core.editor nano

Use VS Code:

git config --global core.editor "code --wait"

5. Installing Homebrew (macOS)

Homebrew is a package manager for macOS that simplifies software installation.

Installing Homebrew

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Useful Homebrew Commands

brew search <package>
brew info <package>
brew install <package>
brew update
brew upgrade
brew list
brew uninstall <package>
brew cleanup # Remove old versions and free space

6. Installing Chocolatey (Windows)

Chocolatey is a package manager for Windows that simplifies software installation.

Installing Chocolatey

Run PowerShell as Administrator and execute:

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

Verifying Installation

choco -?

7. Installing Essential Development Tools

Installing Git

macOS:

brew install git

Windows:

choco install git -y

Installing VS Code

macOS:

brew install --cask visual-studio-code

Windows:

choco install vscode -y

Installing Amazon Q

macOS:

brew install --cask amazon-q

Windows:

First, check if amazon-q exists in Chocolatey by running:

choco search amazon-q

If it exists, install it with:

choco install amazon-q -y

If it doesn't exist, try installing it manually via the command line.

Installing Warp Terminal

macOS:

brew install --cask warp

Windows:

choco install warp -y

Installing Arc Browser

macOS:

brew search arc
brew install --cask arc

Windows:

choco search arc

If unavailable, download manually from Arc Browser.

8. Working in GitHub Codespaces

Open your repository in GitHub.
Click Code > Codespaces.
Click Continue Working in GitHub Codespace.
Select an instance type based on your project needs:
Basic: Suitable for lightweight projects.
Standard: Recommended for most web and mobile development.
Performance: For complex builds or heavy computation.

9. GitHub SSH Key Setup

Generate a New SSH Key

ssh-keygen -t ed25519 -C "your_email@example.com"

Add SSH Key to GitHub

cat ~/.ssh/id_ed25519.pub # Copy the key content

Then add it to GitHub > Settings > SSH Keys.

Test SSH Connection

ssh -T git@github.com

You're right! Let me break it down clearly and explain how it works step by step.

10. Bonus: Configure Terminal for Quick Search and URL Opening

Wouldn’t it be great if you could open websites or search Google directly from the terminal using a simple command like:

oh "github.com"

(Opens https://github.com in your browser)

oh "how to install python"

(Searches Google for "how to install python")

Let’s set it up!

📌 Step 1: Check Your Default Shell

Before adding the function, confirm whether you are using Zsh or Bash by running:

echo $SHELL # or echo $0

If the output contains zsh (e.g., /bin/zsh), you will edit ~/.zshrc.
If the output contains bash (e.g., /bin/bash), you will edit ~/.bashrc.

🔹 macOS default shell is Zsh (since macOS Catalina).
🔹 Linux may use Bash or Zsh, depending on the distribution.
🔹 Window uses Bash from Git Bash.

📌 Step 2: Open the Configuration File

If using Zsh (macOS default), open the Zsh configuration file:

nano ~/.zshrc

If using Bash (common on Linux), open the Bash configuration file:

nano ~/.bashrc

📌 Step 3: Add the `oh` Function

Paste the following Mac-compatible function in ~/.zshrc or ~/.bashrc (for Bash users).

For macOS (Uses `open`)

oh() {
local input="$*"
# Ensure input is a single word with a dot (like a real domain)
if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ && ! "$input" =~ \ ]]; then
open "https://$input"
else
open "https://www.google.com/search?q=$(echo "$input" | tr ' ' '+')"
fi
}

For Linux (Uses `xdg-open`)

On Linux, replace open with xdg-open:

oh() {
local input="$*"
# Ensure input is a single word with a dot (like a domain), and doesn't contain spaces
if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ && ! "$input" =~ [[:space:]] ]]; then
xdg-open "https://$input"
else
xdg-open "https://www.google.com/search?q=$(echo "$input" | tr ' ' '+')"
fi
}

For Windows (Uses `start`)

On Windows, replace open or xdg-open with start:

oh() {
local input="$*"
# Ensure input is a valid domain (contains a dot and no spaces)
if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ && ! "$input" =~ [[:space:]] ]]; then
powershell -c "Start-Process 'https://$input'"
else
powershell -c "Start-Process 'https://www.google.com/search?q=$(echo "$input" | tr ' ' '+')'"
fi
}

Cross-Platform Version (Auto-Detects OS)

If you want a single function that works on both macOS, Linux, and windows, use:

oh() {
local input="$*"
local open_cmd

# Detect OS and set the correct open command
case "$(uname)" in
Darwin*) open_cmd="open" ;;
Linux*) open_cmd="xdg-open" ;; # Linux (xdg-open should use an existing tab when possible)
CYGWIN*|MINGW*|MSYS*) open_cmd="powershell -c start" ;;
*) echo "Unsupported OS" && return 1 ;;
esac

# Open URL or search Google
if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ ]]; then
$open_cmd "https://$input"
else
$open_cmd "https://www.google.com/search?q=$(echo "$input" | tr ' ' '+')"
fi
}

📌 Step 4: Save and Apply the Changes

Press CTRL + X to exit.
Press Y to confirm saving.
Press ENTER to overwrite the file.

Then, apply the changes by running:

source ~/.zshrc # If using Zsh
source ~/.bashrc # If using Bash

🚀 Step 5: Try It Out!

✅ Open a Website:

oh github.com

(Opens https://github.com in your browser.)

✅ Perform a Google Search:

oh "best terminal commands for Mac"

(Opens Google search: https://www.google.com/search?q=best+terminal+commands+for+Mac)

✅ Open Any Website Without Typing https://

oh openai.com

(Opens https://openai.com.)

🔍 How It Works

Detects if the input is a domain using regex (^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$).
If yes, it adds https:// and opens the website.
If no, it converts spaces to + and performs a Google search.
Uses open on macOS and xdg-open on Linux, ensuring cross-platform compatibility.

🔄 Troubleshooting

🔹 Browser doesn’t open?

Ensure open (Mac) or xdg-open (Linux) is available.
On Linux, install xdg-utils if missing:

sudo apt install xdg-utils # Debian/Ubuntu
sudo dnf install xdg-utils # Fedora

✅ Get all setup guides & commands here 👉 Primary Dev Setup 🚀

Chocolatey Installation and Usage Guide

Bello Osagie — Fri, 28 Mar 2025 17:45:27 +0000

What is Chocolatey?

Chocolatey is a package manager for Windows that simplifies the installation, updating, and management of software applications and command-line tools. Similar to Homebrew on macOS, Chocolatey allows users to automate software installations using a single command.

Checking Your PowerShell Execution Policy

Before installing Chocolatey, ensure that your PowerShell execution policy allows scripts to run. Open PowerShell as an administrator and check the current policy:

Get-ExecutionPolicy

If it returns Restricted, change it to AllSigned or Bypass temporarily:

Set-ExecutionPolicy Bypass -Scope Process -Force

This allows Chocolatey to run its installation scripts without restrictions.

Installing Chocolatey

Step 1: Open PowerShell as Administrator

Press Win + X and select Windows Terminal (Admin) or PowerShell (Admin).

Step 2: Run the Installation Command

Copy and paste the following command into the terminal:

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

Press Enter and wait for Chocolatey to install.
Close and reopen PowerShell to apply changes.

Step 3: Verify Installation

Run the following command to confirm Chocolatey is installed:

choco -v

If Chocolatey is installed correctly, it will return the installed version number.

Installing Git Using Chocolatey

Installing Git via Chocolatey ensures you always have the latest version and simplifies updates.

choco search git  # Search for Git
choco install git -y  # Install Git without confirmation prompt

Verify Installation

git --version  # Check Git version
where.exe git  # Locate Git installation

Installing Software with Chocolatey

Chocolatey provides two package types:

Standard Packages (CLI tools like git, nodejs)
GUI Applications (Apps like Google Chrome, VS Code)

Installing a CLI Package

choco install nodejs -y  # Install Node.js

Installing a GUI Application

choco install googlechrome -y  # Install Google Chrome

The -y flag skips confirmation prompts.

Managing Chocolatey Packages

Listing Installed Packages

choco list --local-only  # View installed packages

Upgrading Installed Packages

choco upgrade all -y  # Upgrade all installed packages

Uninstalling a Package

choco uninstall <package-name> -y  # Remove a specific package

Running Chocolatey in Scripts

To automate installations in scripts, use Chocolatey commands within .ps1 files. Example:

# Install multiple applications
choco install git vscode nodejs googlechrome -y

Run the script in an elevated PowerShell session to execute commands.

Chocolatey GUI: A Visual Interface

For users who prefer a graphical interface, install Chocolatey GUI:

choco install chocolateygui -y

Run Chocolatey GUI from the Start Menu to manage software visually.

Uninstalling Chocolatey

If you need to remove Chocolatey, run:

choco uninstall chocolatey -y

Then manually delete the C:\ProgramData\chocolatey folder to clean up residual files.

Exploring More Chocolatey Commands

choco help  # View available commands
choco info <package-name>  # Get package details
choco outdated  # Check for outdated packages

For a full package list, visit Chocolatey Community Repository.

Chocolatey simplifies Windows package management, making software installations fast and efficient! 🚀

Homebrew Installation and Usage Guide

Bello Osagie — Thu, 27 Mar 2025 16:26:27 +0000

Check out the resources for this article.

What is Homebrew?

Homebrew (often called brew) is a package manager for macOS and Linux that allows users to easily install, update, and manage software applications and command-line tools.

Checking Your Default Shell

Before installing Homebrew, it's essential to verify which shell you are using. Run:

echo $SHELL  # or
echo $0

If you're using Zsh (which is the default on modern macOS versions), you may need to configure certain environment variables differently than in Bash.

(Optional) Switch to Zsh

If your default shell is not Zsh, you can switch using:

cat /etc/shells  # List available shells
chsh -s /bin/zsh  # Change default shell to Zsh

Close the terminal and reopen it for changes to take effect.

Prerequisites

Before you start installing and using Homebrew to manage packages, make sure you have the Command Line Tools (CTL) installed by running the following command:

Check if CTL is installed:

xcode-select -p

If it does not return a valid installation path or shows an error like "command not found", install CTL using:

xcode-select --install

This will prompt a macOS dialog to install the necessary tools. Follow the instructions and wait for the installation to complete.

Installing Homebrew

Step 1: Open the Homebrew Website

Run:

xdg-open https://brew.sh  # Linux
open https://brew.sh  # macOS

Or visit Homebrew manually.

Step 2: Copy and Run the Installation Command

Copy the installation script from the website and run it in your terminal:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

You may need to enter your password to allow sudo access.
Follow interactive instructions to add Homebrew to your PATH.
To uninstall Homebrew, replace /install.sh/ with /uninstall.sh/ in the command.
Before uninstalling Homebrew, first remove all installed packages to avoid orphaned files.

Step 3: Configure Environment Variables

Since zprofile loads once per login session, set the Homebrew path there:

cat ~/.zprofile  # View existing configurations

To modify it, use:

vim ~/.zprofile  # or
nano ~/.zprofile

If Homebrew is uninstalled, ensure you remove its path from .zprofile or .zshrc to prevent errors.

Step 4: Verify Installation

Run:

brew --prefix  # Confirm Homebrew’s location
brew -v  # Check installed version

Installing Git Using Homebrew

Even though Git is preinstalled on macOS and Linux, installing it via Homebrew ensures easier updates.

brew search git  # Search for Git
brew install git  # Install Git
brew install --formula git  # Explicitly install as a formula

During installation, dependencies like gettext, pcre2, and libunistring may also be installed.

Verify Installation

git --version  # Check Git version
which git  # Locate Git installation

Understanding Homebrew Package Types

Homebrew has two main package types:

Formulae (command-line tools, e.g., git)
Casks (GUI applications, e.g., Arc Browser)

To install a cask package:

brew search arc  # Search for Arc Browser
brew install --cask arc  # Install Arc Browser

Good practice: Always use --cask when installing GUI apps.

Listing Installed Packages

brew list  # List installed packages
brew list | grep git  # Filter results using `grep`

Managing Homebrew Packages

Before upgrading or removing Homebrew packages, ensure Terminal has necessary permissions:

Go to Apple icon → Privacy & Security → App Management
Toggle the button for Terminal

Upgrade Packages

brew upgrade --cask arc  # Upgrade a specific package
brew upgrade --greedy  # Upgrade all dependencies

Uninstall Packages

brew uninstall --formula <package-name>  # Remove a formula package
brew uninstall --cask <package-name>  # Remove a cask package
brew uninstall --zap --cask <package-name>  # Extra cleanup for GUI apps

The --zap flag in brew uninstall should only be used for cask packages (GUI applications)

Cleanup Unused Packages

brew cleanup  # Free up space by removing old versions
brew autoremove  # Remove orphaned dependencies

Exploring Homebrew Commands

brew help  # View basic commands
brew info <package-name>  # Get details about a package
man brew  # View all available commands
brew home  # Open Homebrew homepage
brew docs  # Open Homebrew documentation

For searching packages manually, visit Homebrew Formulae.

User-Specific Settings: Opening Websites from Terminal

To avoid typing https:// every time, add this function to your ~/.zshrc (for Zsh) or ~/.bashrc (for Bash):

macOS (Uses `open`)

oh() {
  local input="$*"
  if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ && ! "$input" =~ \  ]]; then
    open "https://$input"
  else
    open "https://www.google.com/search?q=$(echo "$input" | tr ' ' '+')"
  fi
}

Linux (Uses `xdg-open`)

oh() {
  local input="$*"
  if [[ "$input" =~ ^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$ && ! "$input" =~ [[:space:]] ]]; then
    xdg-open "https://$input"
  else
    xdg-open "https://www.google.com/search?q=$(echo "$input" | tr ' ' '+')"
  fi
}

Source the file to apply changes:

source ~/.zshrc  # or source ~/.bashrc

Now, simply typing brew.sh will open the Homebrew website!

This guide ensures a smooth Homebrew installation and management experience. 🚀

Understanding Variables, Conditionals, Loops, and Arrays In C Programming

Bello Osagie — Sun, 16 Jul 2023 14:51:59 +0000

Introduction

In this blog post, we'll go through the provided code in C step by step and explain each part in detail. This will help beginners understand the code and its logic. Let's get started!

Code Snippet

Understanding Variables and Constants

const int firstNumber = 30;
const int secondNumber = 50;
const int day = 2;
const int myNumbers[] = { 4, 6, 9, 20, 5, 10 };
const char* myLanguages[] = { "C", "C++", "Java", "C#", "PHP", "Python", "Ruby", "JavaScript", "Rust", "Go", "Swift", "R", "Kotlin" };
const int numLanguages = sizeof(myLanguages) / sizeof(myLanguages[0]);
int counter = 1;
int counterIndex = 1;
int index = 0;
int i = 0;

In the above code snippet, we declare and initialize several variables and constants. Here's a breakdown:

firstNumber and secondNumber are constants representing integer values.
day represents the current day as an integer.
myNumbers is an array of integers that stores a collection of numbers.
myLanguages is an array of strings (character pointers) that stores a collection of programming language names.
numLanguages is an integer that represents the number of languages in the myLanguages array.
counter, counterIndex, index, and i are integer variables used for looping and counting purposes.

Comparing Numbers using Conditionals

const int firstNumber = 30;
const int secondNumber = 50;

if (firstNumber > secondNumber) {
  printf("%d is greater than secondNumber %d\n", firstNumber, secondNumber);
} else if (firstNumber < secondNumber) {
  printf("%d is less than secondNumber %d\n", firstNumber, secondNumber);
} else {
  printf("%d is equivalent to secondNumber %d\n", firstNumber, secondNumber);
}

(firstNumber > secondNumber) ? printf("%d is greater than secondNumber %d\n", firstNumber, secondNumber) : 
(firstNumber < secondNumber) ? printf("%d is less than secondNumber %d\n", firstNumber, secondNumber) :
printf("%d is equivalent to secondNumber %d\n", firstNumber, secondNumber);

/*
30 is less than secondNumber 50
30 is less than secondNumber 50
*/

These code blocks demonstrate how to compare two numbers (firstNumber and secondNumber) using conditional statements (if-else and the ternary operator ? :). The code checks if firstNumber is greater than secondNumber, less than secondNumber, or equivalent to secondNumber. The appropriate message is then printed based on the comparison.

Using a Switch Statement

const int day = 2;

switch (day){ 
  case 1:
    printf("Monday\n");
    break;
  case 2:
    printf("Tuesday\n");
    break;
  case 3:
    printf("Wednesday\n");
    break;
  default:
    printf("Sunday\n");
}

/*
Tuesday
*/

This switch statement checks the value of the day variable and executes the corresponding code block. If day is equal to 1, "Monday" is printed. If it is 2, "Tuesday" is printed. If it is 3, "Wednesday" is printed. If none of these cases match, the default case is executed, and "Sunday" is printed.

Looping with While and Do-While

while (counter < 3) {
  printf("%d\n", counter);
  counter++;
}

printf("-----\n");

do {
  printf("%d\n", counterIndex);
  counterIndex++;
} while (counterIndex < 3);

/*
1
2
-----
1
2
*/

These code blocks demonstrate the usage of while and do-while loops. In the first block, the while loop executes as long as counter is less than 3. It prints the value of counter and increments it by 1 in each iteration. In the second block, the do-while loop executes at least once and continues until counterIndex is less than 3. It prints the value of counterIndex and increments it by 1 in each iteration.

Looping with For

while (index < 5) {
  if (index == 2) {
    index++;
    continue;
  }

  printf("%d\n", index);
  index++;
}

printf("-----\n");

for (; i < 5; i++) {
  if (i == 2) {
    continue;
  }
  printf("%d\n", i);
}

/*
0
1
3
4
-----
0
1
3
4
*/

These code blocks showcase the usage of for loops. In the first block, the while loop continues until index is less than 5. It skips the iteration when index is equal to 2 using the continue statement. In the second block, the for loop initializes i to 0, executes until i is less than 5, increments i by 1 in each iteration, and skips the iteration when i is equal to 2 using the continue statement. In both loops, the current value of the loop variable is printed.

Array Manipulation

const int myNumbers[] = { 4, 6, 9, 20, 5, 10 };

printf("%d\n", myNumbers[0]);

printf("-----\n");

for (int index = 0; index < numLanguages; index++) {
  printf("Language %d is %s\n", index + 1, myLanguages[index]);
}

printf("-----\n");

int matrix[2][3] = { {1, 9, 2}, {7, 6, 8} };
printf("%d\n", matrix[0][2]);
matrix[0][2] = 5;
printf("%d\n", matrix[0][2]);

printf("-----\n");

for (int i = 0; i < 2; i++) {
  for (int j = 0; j < 3; j++) {
    printf("%d\n", matrix[i][j]);
  }
}

/*
4
-----
Language 1 is C
Language 2 is C++
Language 3 is Java
Language 4 is C#
Language 5 is PHP
Language 6 is Python
Language 7 is Ruby
Language 8 is JavaScript
Language 9 is Rust
Language 10 is Go
Language 11 is Swift
Language 12 is R
Language 13 is Kotlin
-----
2
5
*/

These code blocks demonstrate array manipulation. The first block prints the value of the first element in the myNumbers array. The second block uses a for loop to iterate over the myLanguages array and prints each language's name along with its corresponding index. The third block initializes a 2-dimensional array called matrix and prints the value at a specific index. It then modifies that value and prints it again. The final block uses nested for loops to iterate over the matrix array and print each element.

String Manipulation

int x = 0;
char* name = "Osagie";

for (; x <= strlen(name); x++) {
  printf("%c\n", name[x]);
}

/*
1
9
5
7
6
8
-----
O
s
a
g
i
e
*/

This code block demonstrates string manipulation. It declares an integer variable x and a character pointer name that points to the string "Osagie". A for loop is used to iterate over the characters in the name string. It prints each character using the %c format specifier.

Practice

Assuming you have an account or are already logged in on Replit.

Try the Replit Editor online.
Click the Fork button.
Edit the current code.

Conclusion

In this blog post, we went through a C code snippet step by step, explaining each part and its logic for beginners. We covered variable declarations, comparisons, conditionals, loops, array manipulation, and string manipulation. Understanding these fundamental concepts will help you in your journey to becoming a proficient C programmer.

References

Here are some reference links that can provide additional information and explanations on the topics covered in the blog:

Variables and Constants:
- C Variable Types: GeeksforGeeks
- Understanding Constants in C: Programiz
Conditionals:
- If-Else Statements: GeeksforGeeks
- Ternary Operator: GeeksforGeeks
Switch Statements:
- Switch Statement: GeeksforGeeks
Loops:
- C Loops: GeeksforGeeks
- While Loop: GeeksforGeeks
- C while and do...while Loop: GeeksforGeeks
Array Manipulation:
- Arrays in C: GeeksforGeeks
- 2D Arrays in C: GeeksforGeeks
- 2D Arrays in C: Tutorials point
String Manipulation:
- Strings in C: GeeksforGeeks
- String Functions: Programiz

These references should provide additional explanations and examples to enhance the understanding of the concepts covered in the blog post.

Happy Coding!

String Manipulation and User Input in C Programming

Bello Osagie — Sun, 25 Jun 2023 01:54:52 +0000

Introduction

In C programming, the string.h library provides several functions for manipulating strings. This blog post will explore the usage of string manipulation functions in C, along with a detailed explanation of user input using scanf and fgets. We will analyze a code snippet that showcases these concepts and discuss each aspect of the code step by step.

Code Snippet

Including `string.h`

The first line of the code snippet #include <string.h> is a preprocessor directive that includes the string.h header file. This file contains function declarations for string manipulation, such as strlen, strcpy, strcat, and strcmp. By including this header file, we gain access to these functions, which we will utilize in the code snippet.

Creating a Directory

To begin, let's create a file named intermediate.c using the command line. Follow the instructions below based on your operating system:

Open the command prompt or PowerShell.
Run the following commands:

cd basic-programming/c-programming

Open the file in your favorite text editor.

code intermediate.c

vim intermediate.c # installed by default on macOS

emacs -Q -nw intermediate.c

nano intermediate.c # installed by default on Linux

Note:
Make sure you save changes in the file.

String Manipulation using `string.h` Functions

In this section, we'll analyze the code related to string manipulation functions provided by the string.h library.

// String Manipulation
strcat(firstText, secondText);
strcpy(secondStr, thirdStr);
const int str13Cmp = strcmp(firstStr, thirdStr);
const int str3greetingCmp = strcmp(thirdStr, greeting);

In the code above, we perform various string manipulation operations:

strcat(firstText, secondText);: This line uses thestrcatfunction to concatenate thesecondTextstring at the end of thefirstTextstring. The result is that thefirstText string becomes "Hello World!".
strcpy(secondStr, thirdStr);: Here, we use the strcpy function to copy the contents of the thirdStr string into the secondStr array. This operation creates an independent copy of the string.
const int str13Cmp = strcmp(firstStr, thirdStr);: The strcmp function compares the contents of the firstStr and thirdStr strings. It returns an integer value indicating the result of the comparison. If the two strings are equal, it returns 0. If firstStr is lexicographically less than thirdStr, it returns a negative value. If firstStr is lexicographically greater than thirdStr, it returns a positive value. The result is stored in the str13Cmp variable.
const int str3greetingCmp = strcmp(thirdStr, greeting);: Similarly, this line compares the thirdStr and greeting strings using strcmp and stores the result in the str3greetingCmp variable.

User Input using `scanf`

Now, let's look at the code related to user input using the scanf function.

// User Input using scanf
printf("Please type your age and grade: ");
scanf("%d %c", &myAge, &myChar);
printf("Please enter your first name: ");
scanf("%19s", myFirstName);

In the code above, we use scanf to retrieve user input:

scanf("%d %c", &myAge, &myChar);: This line prompts the user to enter their age and grade. The format string "%d %c" specifies that we expect an integer followed by a character as input. The & operator is used to pass the memory addresses of myAge and myChar variables to store the values entered by the user.
scanf("%19s", myFirstName);: This line prompts the user to enter their first name. The format string "%19s" specifies that we expect a string input with a maximum length of 19 characters (to avoid buffer overflow). The entered string is stored in the myFirstName character array.

User Input using `fgets`

Here's the code that demonstrates user input using the fgets function.

// User Input using fgets
printf("Please enter your full name: ");
getchar();  // Clear the newline character from the previous input
fgets(myFullName, sizeof(myFullName), stdin);
myFullName[strcspn(myFullName, "\n")] = '\0';

In the code above, we utilize fgets to obtain user input:

fgets(myFullName, sizeof(myFullName), stdin);: This line reads a line of input from the user, storing it in the myFullName character array. The sizeof(myFullName) argument specifies the maximum number of characters to read, preventing buffer overflow. The stdin stream indicates that the input is read from the standard input (keyboard).
myFullName[strcspn(myFullName, "\n")] = '\0';: Since fgets captures the newline character (\n) when the user presses Enter, this line removes the newline character from the myFullName string by replacing it with a null character (\0). This step ensures that the string ends at the intended input and doesn't include the newline character.

Memory Address and Pointers

This section focuses on memory addresses and pointers used in the code.

// Memory Address and Pointers
printf("My age is: %d\n", myAge);
printf("My character is: %c\n", myChar);
printf("My first name is: %s\n", myFirstName);
printf("My full name is: %s\n", myFullName);
printf("%p\n", (void*)&myAge);
printf("%p\n", (void*)ptr);
printf("%d\n", *ptr);

In the code above, we work with memory addresses and pointers:

printf("My age is: %d\n", myAge);: This line displays the value of the myAge variable, representing the age entered by the user.
printf("My character is: %c\n", myChar);: Here, we print the value of the myChar variable, which corresponds to the grade entered by the user.
printf("My first name is: %s\n", myFirstName);: This line outputs the contents of the myFirstName character array, which contains the user's first name.
printf("My full name is: %s\n", myFullName);: Similarly, we display the content of the myFullName character array, which holds the user's full name.
printf("%p\n", (void*)&myAge);: This line prints the memory address of the myAge variable using the %p format specifier. The & operator retrieves the address of the variable.
printf("%p\n", (void*)ptr);: Here, we print the memory address stored in the ptr pointer variable. The (void*) cast is used to ensure proper formatting of the memory address.
printf("%d\n", *ptr);: This line dereferences the ptr pointer and prints the value stored at the memory address it points to. Since ptr points to myAge, it effectively displays the value of myAge.

Output
Finally, the code snippet includes several printf statements to display the output.

// Output
printf("%d\n", alphabetLength);
printf("%d\n", alphabetByte);
printf("%s\n", firstText);
printf("%s\n", secondStr);
printf("%d\n", str13Cmp);
printf("%d\n", str3greetingCmp);

The code above produces the following output:

alphabetLength: This line prints the length of the alphabet string, which is determined using the strlen function.
alphabetByte: Similarly, this line displays the size (in bytes) of the alphabet array, obtained using the sizeof operator.
firstText: This line outputs the contents of the firstText character array, which now contains the concatenated string "Hello World!".
secondStr: Here, we print the contents of the secondStr character array, which was assigned the value of the thirdStr string using strcpy.
str13Cmp: This line displays the result of comparing the firstStr and thirdStr strings using strcmp. It indicates whether the two strings are equal or different.
str3greetingCmp: Similarly, this line shows the result of comparing the thirdStr and greeting strings using strcmp.

Practive

Assuming you have an account or are already logged in on Replit.

Try the Replit Editor online.
Click the Fork button.
Edit the current code.

Conclusion

In this blog post, we explored the usage of string manipulation functions provided by the string.h library in C programming. We discussed functions such as strlen, strcpy, strcat, and strcmp, along with their purpose and how they are utilized in the code snippet. Additionally, we examined user input using scanf and fgets, which allow the program to receive input from the user. Finally, we covered memory addresses and pointers, highlighting their significance and demonstrating their usage in the code snippet.

References

String and Character Array
Introduction to C Pointers
Using Pointers in C
What is return type of getchar(), fgetc() and getc()?

Basics of C Programming: Data Types, Constants, Variables, and Arrays

Bello Osagie — Tue, 20 Jun 2023 16:29:20 +0000

Introduction

Understanding the basics of C programming is essential for any aspiring programmer. In this blog post, we will explore the concept of data types and constants in C programming, taking a hands-on approach to deepen our understanding. We will compile and run the code snippets to observe the results firsthand. Let's get started!

Code Snippet

Creating a Directory

To begin, let's create a file named basics.c using the command line. Follow the instructions below based on your operating system:

Open the command prompt or PowerShell.
Run the following commands:

cd basic-programming/c-programming

Open the file in your favorite text editor.

code basics.c

vim basics.c # installed by default on macOS

emacs -Q -nw basics.c

nano basics.c # installed by default on Linux

Note Make sure you save changes in the file.

Entry Point of a Program

In C programming, int main() or int main(void) is the entry point of a C program. It is the function where the execution of the program starts. Here's an explanation of each:

int main(void) {
  // Code goes here    
}

int main():
- This declaration of main specifies that the function takes an unspecified number of arguments.
- In C, if no arguments are specified in the parentheses, it is assumed that the function can accept any number of arguments.
- While this declaration is allowed by the C language, it is generally considered bad practice because it can lead to potential issues related to argument handling and type-checking.
int main(void):
- This declaration of main specifies that the function takes no arguments.
- By explicitly stating (void) in the parentheses, it conveys that the main function does not expect any input parameters.
- This declaration is considered good practice and is recommended for clarity and to avoid potential issues with argument handling.

Using int main(void) is generally considered better practice because it clearly indicates that the main function does not accept any arguments. It helps in avoiding accidental mistakes related to argument passing and makes the code more readable and self-explanatory.

Exit Point of a Program

In C programming, the return 0; statement at the end of the main function is not required, but it is commonly used. Here's an explanation:

int main(void) {
  // Code goes here 

  return 0;   
}

The return statement is used to indicate the exit status of the program to the operating system or the program's caller.
By convention, a return value of 0 typically indicates successful execution or termination of the program.
If the return statement is omitted in the main function, the C language automatically inserts an implicit return 0; at the end of the function.
Including an explicit return 0; at the end of the main function is considered good practice for the following reasons:
- It makes the code more readable and explicit, clearly indicating the intended termination of the program.
- It allows for consistency with other functions that may have non-zero return values to indicate specific error conditions.
- It ensures compatibility with some programming environments that may expect a return value from the main function.

While return 0; is not strictly required, it is widely used and considered a best practice. It helps in writing clear and maintainable code, especially when working on larger projects or collaborating with other developers.

Data Types: Defining the Nature of Data

Data types are used to define the type of data that a variable can hold. C provides several built-in data types, including integers, characters, booleans, and arrays. Let's explore these data types by examining the code snippet provided.

/* Data Types */

const int numb = 89;
const char *str = "Bello Osagie";
const bool isTrue = 5 > 3;

In the above code, we can identify three different data types being used:

int is used to store integer values. Here, numb represents the number 89.
char* (character pointer) is used to store strings. In this case, str points to the string Bello Osagie.
bool represents boolean values (true or false). The variable isTrue is assigned the value true because the expression 5 > 3 evaluates to true.

By utilizing different data types, we can handle various kinds of information in our programs.

Note

These are not all the data types we have in C. We will explore others later.

Array: List of Characters as a String

The code char text[] = "This is a text"; represents a character array, which is commonly used to store strings in C. In this case, the array text is initialized with the string "This is a text".

char text[] = "This is a text";

Although it is common to use character arrays to store strings in C, it's important to note that there is no separate data type specifically for strings. Instead, strings are represented as arrays of characters terminated by a null character ('\0'), indicating the end of the string.

Modification of a Character at a specific index

Let's visually represent the interpretation of the given code below and explain the zero-indexed string, modification of the character at index 8, and the memory addresses before and after the modification:

char text[] = "This is a text";
text[8] = '1';

Declaration and Initialization of the Character Array (String):

char text[] = "This is a text";

This code declares and initializes a character array text with the string "This is a text". The characters of the string are stored in sequential memory locations.

Visual representation:

Memory:
-----------------------------------------------------
| Address |   Value   |          Variable           |
-----------------------------------------------------
|  1000   |    'T'    |    text[0] (char, 'T')      |
|  1001   |    'h'    |    text[1] (char, 'h')      |
|  1002   |    'i'    |    text[2] (char, 'i')      |
|  1003   |    's'    |    text[3] (char, 's')      |
|  1004   |    ' '    |    text[4] (char, ' ')      |
|  1005   |    'i'    |    text[5] (char, 'i')      |
|  1006   |    's'    |    text[6] (char, 's')      |
|  1007   |    ' '    |    text[7] (char, ' ')      |
|  1008   |    'a'    |    text[8] (char, 'a')      |
|  1009   |    ' '    |    text[9] (char, ' ')      |
|  1010   |    't'    |    text[10] (char, 't')     |
|  1011   |    'e'    |    text[11] (char, 'e')     |
|  1012   |    'x'    |    text[12] (char, 'x')     |
|  1013   |    't'    |    text[13] (char, 't')     |
|  1014   |   '\0'    |    text[14] (char, '\0')    |
-----------------------------------------------------

2.) Modification of Character at Index 8:

text[8] = '1';

This code replaces the character at index 8 (zero-indexed) of text with the character '1'.

Visual representation (after modification):

Memory:
-----------------------------------------------------
| Address |   Value   |          Variable           |
-----------------------------------------------------
|  1000   |    'T'    |    text[0] (char, 'T')      |
|  1001   |    'h'    |    text[1] (char, 'h')      |
|  1002   |    'i'    |    text[2] (char, 'i')      |
|  1003   |    's'    |    text[3] (char, 's')      |
|  1004   |    ' '    |    text[4] (char, ' ')      |
|  1005   |    'i'    |    text[5] (char, 'i')      |
|  1006   |   's'     |    text[6] (char, 's')      |
|  1007   |    ' '    |    text[7] (char, ' ')      |
|  1008   |    '1'    |    text[8] (char, '1')      |
|  1009   |    ' '    |    text[9] (char, ' ')      |
|  1010   |    't'    |    text[10] (char, 't')     |
|  1011   |    'e'    |    text[11] (char, 'e')     |
|  1012   |    'x'    |    text[12] (char, 'x')     |
|  1013   |    't'    |    text[13] (char, 't')     |
|  1014   |   '\0'    |    text[14] (char, '\0')    |
-----------------------------------------------------

In a zero-indexed string or array, the first element is accessed using index 0. So, in the given code, text[8] represents the character at the ninth position in the string. By assigning '1' to text[8], the original character 'a' at index 8 is replaced with '1'.

The memory addresses before and after the modification remain the same, only the values stored at those addresses are changed. This is because the array text is mutable, allowing us to modify its elements even if it is declared as a character array (string) or a constant.

Arrays: Storing Multiple Values

Arrays allow for the storage of multiple values of the same data type. They provide a convenient way to group related data together. Let's analyze the usage of arrays in the code snippet.

const int myNumbers[] = { 4, 8, 1, 9, 7 }; // array
const char *myString[] = { "money", "people", "love" }; // array

The code snippet demonstrates the declaration and initialization of two arrays, myNumbers and myString. myNumbers is an array of integers, while myString is an array of character pointers (strings).

Visual Representation of Array

Let's visually represent the given code and explain the concept of zero-based indexing in arrays and strings:

Declaration and Initialization of Integer Array:

const int myNumbers[] = { 4, 8, 1, 9, 7 };

This code declares and initializes an integer array myNumbers with 5 elements. The elements are initialized with the provided values.

Visual representation:

myNumbers:
| int | index
--------------
|  4  | 0
--------------
|  8  | 1
--------------
|  1  | 2
--------------
|  9  | 3
--------------
|  7  | 4
--------------

In C and many programming languages, arrays are zero-based indexed. It means that the index of the first element in the array is 0, the second element is 1, and so on. In the myNumbers array, the values are accessed as follows:

myNumbers[0] = 4
myNumbers[1] = 8
myNumbers[2] = 1
myNumbers[3] = 9
myNumbers[4] = 7

2.) Declaration and Initialization of String Array:

const char *myString[] = { "money", "people", "love" };

This code declares and initializes a string array myString with 3 elements. Each element is a pointer to a string literal.

Visual representation:

myString:
| str      | index
--------------
| "money"  | 0
--------------
| "people" | 1
--------------
|  "love"  | 2
--------------

Similarly, in C, strings are also represented as arrays of characters. Each character in a string has its index starting from 0. In the myString array, the values are accessed as follows:

myString[0] = "money"
myString[1] = "people"
myString[2] = "love"

Remember that the index represents the position of an element in the array or a character in a string, starting from 0.

Zero-based indexing is a convention used in programming languages, and it provides a consistent and efficient way to access elements in arrays and strings. Starting the index at 0 aligns with the underlying memory representation and allows for simple arithmetic operations when working with array elements.

Constants: Immutable Values

In C programming, constants are fixed values that cannot be modified during the execution of a program. They are declared using the const keyword. Let's examine the usage of constants in our code.

/* Constants */

const int numb = 89;
const char *str = "Bello Osagie";
const bool isTrue = 5 > 3;
char text[] = "This is a text";
text[8] = '1';
const char greetings[] = { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '\0' };
const int myNumbers[] = { 4, 8, 1, 9, 7 }; // array
const char *myString[] = { "money", "people", "love" }; // array
const int indexNumb = myNumbers[2];
const char *indexStr = myString[1];
const int myNumbers2D[2][3] = { {3, 5, 8 }, {3, 0, 1} };
const int indexMyNumber2D = myNumbers2D[1][0];
int replaceIndexMyNumber2D = myNumbers2D[1][0];
replaceIndexMyNumber2D = 10;

The constant numb is declared as an integer with the value 89. Since it is defined as a constant, its value cannot be changed later in the program. Similarly, str is declared as a constant character pointer pointing to the string Bello Osagie.

The boolean constant isTrue is assigned the result of the expression 5 > 3, which evaluates to true. Again, as a constant, its value remains unchanged.

The array greetings is initialized with the characters 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', and '\0', representing a null-terminated string constant.

myNumbers and myString are arrays of integers and character pointers, respectively. These arrays are initialized with fixed values and cannot be modified later.

Next, we have the 2D array myNumbers2D, which is initialized with two rows and three columns of integers.

We have variables such as indexNumb and indexStr, which store specific elements from the constant arrays.

Finally, we have the variable replaceIndexMyNumber2D which initially holds the value of myNumbers2D[1][0] and later gets reassigned to the value 10.

Constants in Array

Let's visually represent the interpretation of the given code and the output after the modification. Then, I will explain why the changes in the array elements are possible despite using const.

const int indexMyNumber2D = myNumbers2D[1][0];
int replaceIndexMyNumber2D = indexMyNumber2D;
replaceIndexMyNumber2D = 10;

1.) Declaration and Initialization of 2D Array:

const int myNumbers2D[2][3] = { 
    {3, 5, 8},
    {3, 0, 1}
};

This code declares and initializes a 2D array myNumbers2D with 2 rows and 3 columns. The array elements are initialized with the provided values.

Visual representation:

myNumbers2D:
--------------
| 3 | 5 | 8 |
--------------
| 3 | 0 | 1 |
--------------

2.) Accessing Element of the 2D Array:

const int indexMyNumber2D = myNumbers2D[1][0];

This code assigns the value at the index [1][0] of myNumbers2D to the constant variable indexMyNumber2D.

Visual representation (after this step):

myNumbers2D:
--------------
| 3 | 5 | 8 |
--------------
| 3 | 0 | 1 |
--------------
indexMyNumber2D: 3

3.) Assignment of Element to a Non-constant Variable:

int replaceIndexMyNumber2D = myNumbers2D[1][0];
replaceIndexMyNumber2D = 10;

This code assigns the value at the index [1][0] of myNumbers2D to the variable replaceIndexMyNumber2D. Then, it reassigns the value of replaceIndexMyNumber2D to 10.

Visual representation (after this step):

myNumbers2D:
--------------
| 3 | 5 | 8 |
--------------
| 3 | 0 | 1 |
--------------
indexMyNumber2D: 3
replaceIndexMyNumber2D: 10

Even though the array myNumbers2D is declared as const, the changes in the array elements are possible because the const qualifier applies to the elements themselves, not to the variables that hold them. The const keyword ensures that the elements cannot be modified through the array variable myNumbers2D.

In memory, the array myNumbers2D is stored as a contiguous block. Each element in the array has its address. When you assign an element to a non-constant variable, like replaceIndexMyNumber2D, the value of that element is copied to the variable, including its address. The variable replaceIndexMyNumber2D now holds the value and the address of the element.

When you modify the value of replaceIndexMyNumber2D, you are changing the value stored at the address held by the variable. However, the original array elements in myNumbers2D remains unchanged. The modification only affects the variable replaceIndexMyNumber2D and its associated memory location.

const int indexMyNumber2D = myNumbers2D[1][0];
int replaceIndexMyNumber2D = indexMyNumber2D; // myNumbers2D[1][0];
replaceIndexMyNumber2D = 10;

Visual representation (address illustration):

Memory:
---------------------------------------------------
| Address |  Value  |           Variable          |
---------------------------------------------------
|  1000   |    3    | myNumbers2D[0][0] (const)   |
|  1004   |    5    | myNumbers2D[0][1] (const)   |
|  1008   |    8    | myNumbers2D[0][2] (const)   |
|  1012   |    3    | myNumbers2D[1][0] (const)   |
|  1016   |    0    | myNumbers2D[1][1] (const)   |
|  1020   |    1    | myNumbers2D[1][2] (const)   |
|  1024   |    3    | indexMyNumber2D (const)     |
|  1028   |   10    | replaceIndexMyNumber2D      |
---------------------------------------------------

In this illustration, the addresses and values of the variables are shown in memory. The const variables (myNumbers2D, indexMyNumber2D) hold the original values without any modifications. The non-constant variable replaceIndexMyNumber2D holds the modified value.

const int indexMyNumber2D = myNumbers2D[1][0];
int replaceIndexMyNumber2D = indexMyNumber2D; // myNumbers2D[1][0];
replaceIndexMyNumber2D = 10;

Printing the Values: Printing Formatted Output

To observe the values of the variables and constants in our code, we use the printf function to print them to the console (terminal). Here's how the values are printed:

/* Printing Values */

printf("%d\n", numb); // Print the value of numb
printf("%s\n", text); // Print the value of text
printf("%s\n", str); // Print the value of str
printf("%s\n", text); // Print the value of text
printf("%d\n", isTrue); // Print the value of isTrue
printf("%d\n", indexNumb); // Print the value of indexNumb
printf("%s\n", greetings); // Print the value of greetings
printf("%s\n", indexStr); // Print the value of indexStr
printf("%d\n", indexMyNumber2D); // Print the value of indexMyNumber2D
printf("%d\n", replaceIndexMyNumber2D); // Print the value of replaceIndexMyNumber2D

Each printf statement specifies a format specifier to indicate the data type of the variable or constant being printed. For example, %d is used to print integers, %s is used to print strings, and %d is also used for booleans (where true is printed as 1 and false is printed as 0).

Note

%d is the same as %i.
The format specifier %c is used to print a single character in C. However, the value representing the character must be enclosed in single quotes (' '), not backticks. Below is an example:

printf("%c\n", 'J'); // A char

This will print the character 'J' to the console followed by a newline character ('\n').

Comments: Documenting Your Code

Comments are essential for code documentation. They provide information about the code's functionality, purpose, and any other relevant details. In the given code snippet, we can see the usage of comments to document the code. Let's take a look:

// This is a single-line comment
/* 
   This is a multi-line comment
   It can span multiple lines
*/

// Code snippet starts here

const int numb = 89; // Variable to store a number
const char *str = "Bello Osagie"; // Variable to store a string
const bool isTrue = 5 > 3; // Variable to store a boolean value

char text[] = "This is a text"; // Variable to store a character array

// Code snippet ends here

In the code snippet, we can see the use of single-line comments and multi-line comments. Single-line comments start with // and continue until the end of the line. They are used to provide brief explanations or comments on a specific line of code.

Multi-line comments start with /* and end with */. They can span multiple lines and are useful for providing detailed explanations or commenting out a block of code.

Comments are not executed as part of the program and do not affect the program's functionality. They are solely meant for human readability and understanding.

Variables: Storing Data

Variables are used to store and manipulate data in C programming. They act as containers that hold values of different types. In the given code snippet, we can see the usage of variables like numb, str, isTrue, text, and more. Let's explore their significance and how they are utilized.

/* variables */

const int numb = 89;
const char *str = "Bello Osagie";
const bool isTrue = 5 > 3;
char text[] = "This is a text";
}

In this code, numb is an integer variable assigned a constant value of 89. We use the const keyword to indicate that the value is constant and cannot be modified.

Similarly, str is a character pointer variable storing the address of the string Bello Osagie. The const keyword ensures that the pointer itself is constant and cannot be used to modify the string.

isTrue is a boolean variable assigned the result of the expression 5 > 3. It will hold the value true since the expression is true.

text is a character array initialized with the string "This is a text." It allows for the manipulation of individual characters within the array.

Modifying Variables: Adding and Replacing Values

Variables can be modified by assigning new values to them. In the code snippet, we can see examples of modifying variables:

text[8] = '1';
replaceIndexMyNumber2D = 10;

The statement text[8] = '1' replaces the character at index 8 in the text array with the character '1'. Similarly, replaceIndexMyNumber2D = 10 assigns the value 10 to the variable replaceIndexMyNumber2D.

Compiling and Running the Code

When compiling a C program using the GCC compiler, you can pass various options and flags to modify the behavior of the compilation process. Let's break down the options used in the commands you mentioned:

/*
 * Run:
 * gcc -Wall -pedantic -Werror -Wextra -std=c99 basics.c -o basics
 * gcc basics.c -o basics
 * ./basics
 */

Let's discuss each option:

-Wall: Enables compiler warnings for potential issues in the code. It stands for all warnings. When this option is used, the compiler will display a comprehensive set of warning messages to help identify possible problems in the code.
-pedantic: Enforces strict adherence to the C language standards. It instructs the compiler to be pedantic and only allows code that strictly follows the C standard. It disables certain language extensions and non-standard features.
-Werror: Treats all warnings as errors. When this option is enabled, any warning generated by the compiler will be treated as an error, causing the compilation to fail. This ensures that the code is warning-free and encourages developers to write clean and error-free code.
-Wextra: Enables additional warning messages beyond those enabled by -Wall. It provides extra warnings for potentially suspicious code constructs or common programming mistakes.
-std=c99: Specifies the C language standard to be used. In this case, it specifies the C99 standard. C99 is an ANSI/ISO standard for the C programming language, introduced in 1999. It adds several new features and improvements to the language.

The first command (gcc -Wall -pedantic -Werror -Wextra -std=c99 basics.c -o basics) enables strict warnings, treats warnings as errors, and enforces adherence to the C99 standard. It is advisable to use this command during development or when aiming for strict code quality and adherence to standards. It helps catch potential issues and encourages cleaner code.

The second command (gcc basics.c -o basics) is a simpler command that compiles the basics.c file without any specific warning options or standard enforcement. It can be used for quick compilation without strict warning checks. However, it's generally recommended to use the first command during development or in projects where code quality and adherence to standards are crucial.

By using the first command, you can catch and address potential issues early in the development process, leading to more robust and maintainable code.

Preprocessor Directives

In the code below, #include <stdio.h> and #include <stdbool.h> are preprocessor directives that include the standard C library headers stdio.h and stdbool.h, respectively. Here's an explanation of each:

#include <stdio.h>
#include <stdbool.h>

#include <stdio.h>:
- This directive includes the standard input/output library header. It provides functions for input and output operations, such as reading from or writing to the console or files.
- It allows you to use functions like printf() and scanf() for formatted output and input operations, respectively.
- In the given code, printf() function is used to print values to the console.
#include <stdbool.h>:
- This directive includes the header for the C99 standard's Boolean type support.
- It defines the bool type, which represents boolean values (true and false).
- In the given code, bool is used to declare the variable isTrue and store a boolean value (true or false).

Including these headers is necessary to access the functions and definitions provided by the respective libraries. Without including stdio.h, you wouldn't be able to use functions like printf(), and without including stdbool.h, you wouldn't be able to use the bool data type.

Practice

Assuming you have an account or are already logged in on Replit.

Try the Replit Editor online.
Click the Fork button.
Edit the current code.

Conclusion

In this blog post, we explored the basics of C programming by examining data types and constants. We learned how to declare and initialize variables and constants of various data types, including integers, characters, booleans, and arrays. We also observed the results by printing the values using printf. Understanding these fundamental concepts is crucial for building more complex C programs. Stay tuned for future blog posts where we will delve deeper into C programming.

References

Happy Coding!!!

Getting Started with C Programming: Compiling Programs

Bello Osagie — Sun, 18 Jun 2023 19:06:05 +0000

Introduction

C programming is a versatile language that allows you to build a wide range of applications. Whether you're a beginner or an experienced programmer, you must know how to set up your development environment and start with basic programming tasks. In this guide, we'll walk you through the process of creating directories and checking for the installation of C on different operating systems. We'll also cover the steps to install C if it's not already available. Finally, we'll demonstrate how to write and compile a simple Hello, World! program in C. Let's get started!

Code Snippet

Installing Choco

If this is not your first time using Chocolatey or Chocolatey is already installed on your Windows Operating System skip this section.

To install Chocolatey, follow these steps:

Search for PowerShell and run it as an administrator on Windows.
Go to the Chocolatey installation page.
If this is your first time installing Chocolatey on your operating system, execute the following command in your terminal, based on the instructions provided on the installation page:

Get-ExecutionPolicy

If the output is "Restricted", enter one of the commands below:

Set-ExecutionPolicy AllSigned

Set-ExecutionPolicy Bypass -Scope Process

Regardless of whether "Restricted" was the previous output or not, run the following command (copy and paste it into your terminal):

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

If there are no errors, check if Chocolatey was successfully installed by running the following command:

choco

If the output displays the version of Chocolatey you are using, it means the installation was successful.

Creating a Directory

To begin, let's create a directory named c-programming using the command line. Follow the instructions below based on your operating system:

Open the command prompt or PowerShell.
Run the following commands:

mkdir basic-programming

mkdir basic-programming/c-programming

change directory to c-programming

cd basic-programming/c-programming

Checking if C is Installed

Before you start writing C programs, it's important to check if C is installed on your system. You can verify this by using the gcc or cc command, a popular C compiler. Follow the steps below:

Open the terminal.
Run the following command:

gcc --version

Note:

You may also include the extension to gcc. That is gcc is the same as gcc.exe.

gcc.exe --version
gcc.exe input.c -o output.exe # optionally omit the .exe

If C is installed, the version information will be displayed. Otherwise, you may be prompted to install the necessary tools or package. For example, for Linux, if gcc is not installed, running gcc --version in the terminal typically results in an error message like this:

The program 'gcc' is currently not installed. You can install it by typing:
sudo apt install gcc

For Windows, the error may look like this shown below:

'gcc' is not recognized as an internal or external command, operable program or batch file.

For macOS, the error may look like this shown below:

-bash: gcc: command not found

`gcc` or `cc`

In the article, the gcc command will be primarily used for checking the version of the C compiler and compiling C programs. However, it is worth noting that cc can be used as an alternative to gcc for the same purposes.
While gcc is commonly used as the command-line interface to the GNU Compiler Collection, including the C compiler, cc is often set as a symbolic link or alias to gcc. Therefore, both commands essentially serve the same purpose and can be used interchangeably in most cases.

The choice between using gcc or cc may depend on personal preference or specific system configurations. However, in the context of the article, it is safe to assume that the gcc command will be predominantly used while acknowledging that the cc command could be used as an alternative.

Installing C

If C is not installed on your system, follow the appropriate instructions based on your operating system:

General Installation (VSCode)

If you prefer to use VSCode, you can install it by using a package manager specific to your operating system. For Windows, you can use Chocolatey by running the command choco install vscode. macOS users can use brew with the command brew install --cask visual-studio-code. Ubuntu users can use sudo with the command sudo apt install code.
After installing VSCode, you should install the following extensions: C/C++ Extension Pack and Code Runner.
After the installation is complete, you can launch Visual Studio Code by searching for it in the applications menu or by running the code command in the terminal (code and click Enter or Return).
Once Code Runner is installed, you will see a play icon beside which is a dropdown.
Click on the play dropdown icon. See the image below:

Open the terminal by pressing Ctrl + J.
Click the option that says Run C/C++.

From the debug configuration options, select the option to build and debug an active file.

You will see the result Hello, World! In your terminal. Notice the new executable file created during execution - hello.exe

Note that the Keyboard shortcut is Ctrl + Shift + B.

Now that you have done the configuration, the next time you want to run a C program just click on the play button or use the keyboard shortcut Ctrl + Alt + N.

Issue

If the installation doesn't work for you, go to the VS Code download page and click the download button based on your operating system - macOS, Linux, Windows and install (click on the executable file after download - accept all default settings).
If the problem persists, download and install Codeblocks. You may navigate to the Binary releases page and download based on your operating system.
Alternatively, use the online Replit text editor.

Note: You can also try VSCode in the browser and still follow along the course.

macOS

On macOS, Homebrew can be used to install C-related tools and libraries. However, Homebrew itself is not specifically used to install the C language since macOS already includes the Clang compiler, which supports C. Here's how you can install Homebrew and verify the availability of Clang:

Open the terminal.
Install Homebrew by running the following command:

On macOS, brew might be pre-installed on your system, verify by running the command below:

brew -v

If it is not installed or it shows an error, run the command below:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

After Homebrew is installed, you can install additional C-related tools and libraries if needed by using Homebrew commands. For example, to install the GNU Compiler Collection (GCC), you can run the following command:

brew install gcc

To verify the availability of Clang, which comes preinstalled on macOS, run the following command:

clang --version

Remember, on macOS, the default compiler is Clang, which supports C and other programming languages. If you install GCC using Homebrew, you can use it as an alternative to Clang.

Alternative installation on macOS

Install Xcode from the App Store.
Open Xcode and navigate to Preferences.
In the Downloads tab, install the Command Line Tools.

Ubuntu

Open the terminal.
Run the following commands

sudo apt-get update
sudo apt-get install build-essential

Note: The sudo command is used to run the subsequent commands with administrative privileges, which may require you to enter your password.

Windows

To install C on Windows, we'll use the MinGW-w64 development environment, which provides a Windows port of GCC.
Follow these steps:

On Windows, you can use Chocolatey to install the MinGW-w64 development environment, which provides a Windows port of GCC. Here's how you can do it:

Open the command prompt or PowerShell with administrative privileges.
Install Chocolatey by following the instructions on the official Chocolatey website.
Once Chocolatey is installed, run the following command to install MinGW-w64:

choco install mingw

During the installation, make sure to select the appropriate options as prompted.

For example, if asked to run the script, type a or all. It means you want to run all scripts.

Do you want to run the script?([Y]es/[A]ll - yes to all/[N]o/[P]rint): a

After the installation is complete, you should have the GCC compiler available on your system. You can verify the installation by running the command gcc --version in the command prompt or PowerShell.

Alternative installation on Windows OS

Visit the MinGW-w64 website and download the installer for your system architecture (32-bit or 64-bit).
Run the installer and ensure you select the Add to PATH option during installation.
After installation, open the command prompt or PowerShell.
Run the following command to verify the installation:

gcc --version

Note:

printf is used to output (print) the result in the terminal.

Writing and Compiling a C Program

Now that you have C installed, let's write a simple Hello, World! program and compile it. Follow the steps below:

Create a file named hello.c and paste (right click) the following code into it and save (based on the editor):

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

vim hello.c

Save file:

:wq
Enter or Return

nano hello.c

Save file:

Ctrl + O Ctrl + C Ctrl + X
Y
Enter or Return

emacs -Q -nw hello.c

It is the same as emacs hello.c except that it might open the GNU graphical interface:

emacs hello.c

Save file:

Ctrl + X Ctrl + S
Ctrl + X Ctrl + C
Open the terminal or command prompt and navigate to the directory where the hello.c file is located.
Use the gcc command to compile the program and generate an executable file:

gcc hello.c -o hello

gcc hello.c -o hello.exe

The -o option specifies the output file name (in this case, hello).

Run the program by executing the generated executable file:

./hello

./hello.exe

You should see the output Hello, World! displayed in the terminal or command prompt.

Practice

Assuming you have an account or are already logged in on Replit.

Try the Replit Editor online.
Click the Fork button.
Edit the current code.

Conclusion

Congratulations! You've learned how to create directories, check if C is installed, install C if needed, and write a simple C program. This knowledge forms the foundation for your C programming journey. As you progress, you can explore more complex programs and dive deeper into the language's capabilities. Have fun coding and building amazing software with C! If you have any further questions, feel free to ask.

References

Happy Coding

DEV Community: Bello Osagie

Fast & Clean TypeScript Workflow with Environment Variables, Bun, and ts-node-dev

1. Project Initialization

2. Environment Variables in .env.local

3. TypeScript & @types/node Setup

4. Reading Env & Demo Outputs

5. Scripts & Loading .env.local

6. Safe .gitignore

7. Enable Watch Mode

8. Node’s Inline Type Stripping: Behavior

9. Faster Dev with ts-node-dev

10. Build Output is In-Memory

11. Bun—Fast, but Selective Support

Summary Workflow

TL;DR

Set Up VS Code Extensions the Right Way — Express.js Series (Ep. 1 Highlights)

Installing Extensions in VS Code

Amazon Q Extension in VS Code

GitHub Theme Not Working?

Material Icon Theme Not Applied?

Postman Web: Sign In to Use It

Extensions That Work Automatically (No Config Needed)

Global Tools: Amazon Q in Terminal (Shell Integration)

But here's the key: it doesn’t work until you set it up correctly.

If Amazon Q Isn't Working in Terminal...

Final Thoughts

Git and GitHub Crash Course for Express.js Developers

Introduction

Prerequisites

Step-by-Step Guide

1. Create or Sign In to Your GitHub Account

2. Open VSCode.dev or GitHub.dev

3. Initialize Git in Your Local Project

4. Configure Git Author Info

5. Stage and Commit Your Changes

6. Create a GitHub Repository Using GitHub CLI

7. Create and Switch to a New Branch

8. Push Branch to GitHub

Summary Commands Cheat Sheet

Useful Tools

📽️ Bonus: Watch the Full Video Tutorial

Final Thoughts

Support This Project

Setting Up Your Windows Dev Environment for Node.js & Express (The Right Way)

Why the Setup Matters

What We’re Setting Up

Two Ways to Install Software on Windows

Installing Chocolatey

Installing Tools with Chocolatey

Managing Node the Right Way: Use NVM

Why not use the global Node installer?

NVM for Windows is better.

Steps to Use NVM (After Chocolatey Installs It)

VS Code Extensions to Install

Recap: Tools We Installed

Watch the Video Tutorial

What’s Next?

Feedback?

Setting Up Your macOS Dev Environment for Node.js & Express (The Right Way)

Why the Setup Matters

What We're Setting Up

Two Ways to Install Software

Installing Homebrew

Setting Up with a Brewfile

Fixing Node.js the Smart Way: Use NVM

Why not just use the global Node installation?

Here's what I did:

1. Uninstall Node via Brew:

2. Install NVM (Node Version Manager):

3. Use NVM to manage Node:

Recap: Tools We Installed

Watch the Video Tutorial

What's Next?

Feedback?

Git & GitHub Setup Guide for Beginners

Introduction

1. GitHub CLI (gh) and Authentication

Authenticate GitHub CLI

2. Initializing a Git Repository

Git Initialization (git init)

2. Environment Variables in `.env.local`

3. TypeScript & `@types/node` Setup

5. Scripts & Loading `.env.local`

6. Safe `.gitignore`

9. Faster Dev with `ts-node-dev`

1. GitHub CLI (`gh`) and Authentication

Git Initialization (`git init`)

Understanding the `.git` Folder

📌 Step 3: Add the `oh` Function

For macOS (Uses `open`)

For Linux (Uses `xdg-open`)

For Windows (Uses `start`)