DEV Community: Odewole Abdul-Jemeel

Building My Digital Playground: How I Built a Self-Sufficient Homelab That Never Sleeps

Odewole Abdul-Jemeel — Mon, 03 Nov 2025 06:57:23 +0000

Introduction

It started with a simple motivation — I wanted a reliable and affordable way to experiment, learn, and host personal services without running them on my daily machine. I've always believed that the best way to understand systems is to build them, break them, and rebuild them better.

My goals were straightforward: I needed fairly decent, cheap computing power on my network for learning purposes and hosting fun side projects. More importantly, I wanted to understand how real-world infrastructure works — from virtualization to networking to service orchestration. There's something deeply satisfying about knowing that the services you use daily are running on hardware you control, configured exactly the way you want.

So, I decided to create a homelab, a dedicated environment for learning, self-hosting, and tinkering. My objectives were clear:

Learning: Experiment with virtualization, orchestration, networking, and automation
Self-hosting: Run my own services—from productivity tools to media servers
Reliability: Maintain 24/7 uptime and gain real-world infrastructure experience

Over time, this small project evolved into a fully functional, solar-powered three-node cluster, running everything from media servers to automation pipelines. My setup consists of three Dell OptiPlex 7070 machines, all connected via a Ruijie RG-ES205GC-P 5-Port Gigabit Cloud Managed PoE+ Switch, with upstream connectivity through a FiberOne 50Mbps fiber connection. Not exactly enterprise-grade, but more than enough for what I needed to accomplish.

In fact, my personal website jemeel.dev, a fully ClaudeCode generated portfolio website, is publicly available and running on Dokploy from this very homelab. It's incredibly satisfying to tell people, "Yeah, that's running on hardware in my room."

Here's how it all came together.

Hardware & Power Infrastructure

At the heart of the lab are three Dell OptiPlex 7070 machines — compact, efficient, and affordable. I chose Dell OptiPlex machines because they're reliable, relatively power-efficient, and, most importantly, affordable on the used market.

The Nodes:

🖥️ Dell OptiPlex 7070 SFF – Core i7, 32 GB RAM, 2 TB SSD

🖥️ Dell OptiPlex 7070 SFF – Core i7, 32 GB RAM, 1 TB SSD

💻 Dell OptiPlex 7070 Micro – Core i7, 32 GB RAM, 1 TB SSD

Each node packs a Core i7 processor and 32GB of RAM, not bleeding edge, but plenty of horsepower for running multiple virtual machines and containerized services. The total storage across all nodes is 4TB, which is more than sufficient for my current needs.

These nodes are connected via a Ruijie RG-ES205GC-P 5-Port Gigabit Cloud Managed PoE+ Switch, with upstream internet provided by a FiberOne 50 Mbps fiber connection.

The Cost Breakdown

Let's talk numbers, because one of the biggest questions people ask is: "How much does this actually cost?"

Initial Investment:

3× Dell OptiPlex 7070 units: ₦520,000 each = ₦1,560,000
Ruijie RG-ES205GC-P Switch: ₦45,000
2TB SSD (replacement—more on this later): ₦220,000
Total initial cost: ₦1,825,000 (~$1,200 USD at current rates)

Monthly Operating Costs:

Internet (50Mbps fiber, shared with home): ₦25,000
Electricity (minimal due to solar): ~₦5,000
Total monthly cost: ₦30,000 (~$20 USD)

Now, let me put this in perspective. For comparison, running equivalent infrastructure on cloud platforms would cost significantly more:

Cloud Cost Comparison (Approximate Monthly Costs):

AWS EC2:

3× t3.xlarge instances (4 vCPU, 16GB RAM each): ~$220/month
4TB EBS storage: ~$400/month
Data transfer (moderate): ~$50/month
Total: ~$670/month (₦1,005,000)

DigitalOcean:

3× droplets (8GB RAM, 4 vCPU): ~$240/month
4TB block storage: ~$400/month
Bandwidth overages: ~$30/month
Total: ~$670/month (₦1,005,000)

Google Cloud Platform:

3× n2-standard-4 instances: ~$250/month
4TB persistent SSD: ~$680/month
Network egress: ~$40/month
Total: ~$970/month (₦1,455,000)

Heroku:

Performance-M dynos (comparable): ~$500/month
Heroku Postgres: ~$200/month
Add-ons and scaling: ~$100/month
Total: ~$800/month (₦1,200,000)

Vercel Pro + Infrastructure:

Vercel Pro: $20/month
Backend hosting (Railway/Render): ~$100/month
Database (PlanetScale/Supabase): ~$50/month
Total: ~$170/month (₦255,000) - Limited to web apps only

My Homelab ROI: After just 3 months, my homelab pays for itself compared to AWS/GCP. After 6 months, I'm saving over ₦6 million annually compared to traditional cloud hosting. The only ongoing costs are internet (which I'd have anyway) and minimal electricity due to solar power.

Of course, cloud platforms offer advantages like global distribution, automatic scaling, and managed services. But for learning, experimentation, and self-hosting personal projects, the homelab is unbeatable in terms of cost-effectiveness.

Power & Uptime Design

Living in Nigeria means dealing with inconsistent power supply, so I couldn't just plug everything into the wall and hope for the best. All nodes are connected to a dedicated outlet powered by both the grid and a 3.5KVA solar inverter. The setup automatically switches between power sources, keeping everything online even during extended outages—a must for 24/7 operation.

There's nothing more frustrating than having your services go down because of a power outage, especially when you're hosting productivity tools you rely on daily. This dual-power configuration provides an uninterrupted 24/7 power supply essential for services that need to stay online. The solar setup has been a game-changer, reducing my electricity costs to nearly nothing while ensuring my services remain accessible even during the longest power outages.

Network Topology

Each node communicates over Gigabit LAN, ensuring low latency and quick data replication. All three nodes are connected via the Ruijie switch, which handles local network traffic at gigabit speeds. The switch connects to my FiberOne router, which provides a stable 50Mbps upload and download connection.

I know 50Mbps isn't blazing fast by modern standards, but for a homelab serving primarily personal use and a handful of external services, it's perfectly adequate. The keyword here is "stable"; consistent connectivity matters more than raw speed for most self-hosted services. The fiber line is stable enough for remote access, backups, and moderate traffic applications.

That said, I'm currently in discussions with my ISP about upgrading to a higher dedicated line. With my website now publicly accessible and plans to self-host more projects, the additional bandwidth would provide headroom for growth and better performance for external users.

Virtualization Layer

When it came to choosing a virtualization platform, I went with Proxmox VE. Why Proxmox? It's free, stable, and incredibly flexible. It supports both KVM virtualization for full virtual machines and LXC containers for lightweight workloads. Plus, the web-based management interface makes it easy to manage everything from anywhere on the network. It allowed me to cluster all three nodes, share resources, and manage VMs and containers from a unified interface.

Cluster Setup

Each node was joined into a single Proxmox cluster, enabling live migration and centralized backups. I configured all three nodes into a Proxmox cluster, which allows them to work together as a unified system. This means I can migrate VMs between nodes, manage all three from a single interface, and set up high availability if needed. The cluster setup was straightforward - Proxmox makes it easy to add nodes to an existing cluster through the web UI.

Storage Architecture

For storage, I maintain shared storage through NFS, hosted on one of the larger nodes for reliability. This allows all nodes to access shared storage, making it easy to migrate VMs without worrying about moving disk images around. I also configured regular backups to ensure I don't lose everything if a disk decides to give up on life.

And speaking of disks giving up — let me tell you about an expensive lesson I learned the hard way.

A Costly Mistake: The 1TB SSD Incident

Early in my homelab journey, I ran into a Proxmox cache issue. In my attempt to resolve it, I mistakenly (yeah, the word was invented for blame shifting reasons like this) deleted some critical memory addresses that completely crashed one of my 1TB SSDs. The drive became completely undiscoverable and unrecoverable — no amount of troubleshooting, recovery tools, or desperate Googling could bring it back to life.

This was a painful lesson in several ways:

First, the obvious cost of ₦220,000 for a replacement 2TB SSD (I upgraded the capacity while I was at it). Second, the time lost in rebuilding and reconfiguring services. But most importantly, it taught me the absolute importance of proper backups and understanding what you're doing before you execute commands, especially when dealing with storage and memory management.

Since then, I've implemented much more rigorous backup procedures and I always, always double-check before running any storage-related commands. I also document every significant change I make to the infrastructure. And lastly, it thought me VM managements and deep understanding of proxmox.

Base Templates & Remote Access

One of my favorite optimizations was creating a headless Ubuntu VM template with cloud-init. To speed up provisioning, I use this template which means I can spin up new Ubuntu VMs in seconds with pre-configured networking, SSH keys, and basic packages already installed. No more spending 20 minutes setting up a new VM every time I want to experiment with something.

For remote access and interconnectivity, I configured Tailscale VPN, which allows me to securely connect and manage the cluster from anywhere. Tailscale creates a mesh VPN that lets me connect to my homelab from anywhere without exposing services directly to the internet. It's like having a secure tunnel straight into my network, which is especially useful when I need to access my services while away from home.

Service Grouping Strategy

One of the most important decisions when building a homelab is figuring out how to organize your services. Do you run everything on one machine? Do you create a separate VM for every service? The answer, as usual, is somewhere in between.

To keep things organized, I grouped services by category and performance demand.

Cluster Role Division

🧩 Node 1 & 2: Dedicated to Dokploy (self-hosted PaaS) for deployments, configured in a Docker Swarm setup (primary and worker nodes)—combining 3TB of storage and 64GB RAM. These two nodes are connected via Docker Swarm, providing a powerful platform for deploying containerized applications without much hassle.

⚙️ Node 3: Hosts self-contained services (media, productivity, and infrastructure utilities). This node is reserved for self-hosted services and tools that I want to keep separate from the Dokploy environment.

Philosophy Behind Isolation

Rather than running everything in a single container stack, I prefer isolating services into dedicated VMs or grouped Docker stacks. This separation provides a layer of isolation—if something goes wrong in my deployment environment, my core services remain unaffected. This makes it easier to scale, back up, or tear down without affecting unrelated services.

I organized my services into clear categories: Infrastructure, Media, and Productivity. This makes it easier to manage resources and understand dependencies. Infrastructure services like DNS and reverse proxies get priority allocation since everything else depends on them. Media services can be more resource-hungry, so they get their own allocation. Productivity tools are somewhere in between.

Resource Allocation Philosophy

I follow a simple principle: allocate conservatively, scale when needed. It's tempting to give every VM maximum resources, but that's wasteful. Instead, I start small and monitor performance. If a service consistently maxes out its allocated resources, I increase them. This approach ensures I'm making the most of my limited hardware.

Key Self-Hosted Services

This is where things get interesting. Let me walk you through the major services running in my homelab and why I chose to self-host them.

1. Infrastructure & Networking (VM 1: 4GB RAM, 2 CPUs)

This VM handles the core network and infrastructure management stack that everything else depends on:

Caddy: My primary reverse proxy and web server. Caddy is lightweight and handles SSL automation beautifully. It automatically handles SSL certificates, which means I don't have to manually manage Let's Encrypt renewals. It's simple, fast, and just works.
Portainer: A web-based Docker management interface that provides visual Docker management. While I'm comfortable with Docker CLI, Portainer provides a nice visual overview of all my containers, makes it easy to check logs, and simplifies management when I don't want to SSH into a server.
AdGuard Home: Network-wide ad blocking and DNS management. Every device on my network benefits from ad blocking without needing individual browser extensions. It also gives me detailed insights into DNS queries and lets me block specific domains.
Uptime Kuma: A beautiful uptime monitoring and tracking tool. It pings all my services regularly and alerts me if anything goes down. The dashboard gives me a quick overview of service health.

2. Productivity & Personal Management (VM 2: 4GB RAM, 2 CPUs)

My digital workspace lives here. This VM runs services that help me stay organized and productive:

Traggo: Time tracking made simple. I use it to track how much time I spend on different projects and tasks. Unlike cloud-based alternatives, my time tracking data stays on my servers.
Paperless-NGX: Document management system that OCRs and organizes all my documents. I scan everything—bills, receipts, important documents—and Paperless makes them searchable and accessible from anywhere.
SureFinance: Self-hosted finance tracker for personal finance tracking. I wanted to understand where my money goes without giving a third-party service access to my financial data.
Vikunja: Project and task management. It's like Todoist or Trello, but self-hosted. I use it to organize both personal and work projects.
Mixpost: Social media scheduler and management tool. Helps me schedule and manage social media posts without relying on expensive SaaS solutions.

All of these integrate into my daily workflow seamlessly, replacing SaaS tools with privacy-respecting self-hosted alternatives. The beauty of self-hosting productivity tools is that you control your data and can customize integrations exactly how you want them.

3. Media (VM 3: 12GB RAM, 4 CPUs)

For media and storage, media services tend to be resource-intensive, so I gave this VM more horsepower. This VM runs:

Immich: Self-hosted, AI-powered photo and video library. Think Google Photos, but you own your data. It's got machine learning-powered photo recognition, automatic backups from my phone, and a beautiful interface.
Nextcloud: My personal cloud storage and collaboration platform for file sync. I use it for file syncing, calendar management, and sharing files with others. It's replaced Dropbox and Google Drive for me entirely.

These services make file management, streaming, and backup seamless within my network. The media VM gets more resources because photo recognition and video transcoding can be demanding. I allocated 12GB of RAM and 4 CPU cores to ensure smooth performance, especially when Immich is processing a batch of photos or Nextcloud is syncing large files.

Easier Deployment with Dokploy: My Self-Hosted PaaS

If there's one decision that transformed my homelab from a collection of manually-managed containers into a streamlined deployment platform, it was setting up Dokploy. This self-hosted Platform-as-a-Service has become the backbone of my entire infrastructure.

Why Dokploy?

When researching self-hosted PaaS solutions, I had several options: Coolify, CapRover, Dokku, and Dokploy. I chose Dokploy for three main reasons:

Modern, Intuitive UI: Clean, responsive interface that's actually enjoyable to use
Simplicity Without Sacrificing Power: Easy enough for quick deployments, powerful enough for complex applications
Active Development: Recent, actively maintained, with responsive developer support

I seriously considered Coolify, which is also excellent, but Dokploy's UI and overall user experience won me over.

What Makes Dokploy Special?

Dokploy is essentially a self-hosted alternative to Heroku, Vercel, and Railway. Here's what makes it powerful:

GitHub Integration & One-Click Deployments

Dokploy connects directly to my GitHub repositories. Push code, and it automatically builds, deploys, and configures everything. My website, jemeel.dev, goes from code push to production in less than 5 minutes:

Push code to GitHub
Dokploy receives webhook, pulls code, builds Docker image
Deploys to Docker Swarm
Traefik configures routing
Let's Encrypt provisions SSL
Site is live with HTTPS

This is Vercel-level developer experience on hardware I own.

Docker Compose Support

Native Docker Compose support means I can paste existing compose files directly into Dokploy. For complex multi-container applications (API + frontend + database + cache), one compose file orchestrates everything.

Database Provisioning

Dokploy spins up popular databases with a few clicks: PostgreSQL, MySQL, MongoDB, Redis, MariaDB. Need a database? Click "Add Database," choose PostgreSQL, set a password—done. No manual container management or volume configuration.

Traefik Integration & SSL Management

Dokploy works seamlessly with Traefik for automatic routing and Let's Encrypt for SSL certificates. Deploy a service with a domain name, and SSL just works—automatically provisioned and renewed.

Cloudflare Tunnel Integration

For public-facing services, I use a three-layer architecture:

Cloudflare Tunnel: HTTPS, DDoS protection, WAF, bot filtering
Traefik: HTTP routing, load balancing, service discovery
Dokploy: Application hosting and orchestration

Cloudflare handles external threats and SSL termination, Traefik manages internal routing, and Dokploy hosts the applications.

When This Works Best:

Public websites and web applications
REST APIs with moderate traffic
Personal projects and portfolios
Small to medium business applications
Content management systems

When This Has Limitations:

Latency-sensitive applications (adds 20-50ms)
Very high bandwidth needs (4K streaming to multiple users)
Applications requiring static IPs for allowlisting
Strict compliance requirements needing direct IP control

For most use cases—personal projects, small business apps, moderate-traffic websites—this setup is excellent.

Dokploy vs. Popular PaaS Platforms

Let's compare costs for hosting 10 moderate applications with databases:

Heroku:

10 apps + databases: $160/month (₦240,000) = ₦2,880,000/year

Vercel + Supabase:

Pro plan + databases + bandwidth: $85/month (₦127,500) = ₦1,530,000/year

Railway:

10 apps with databases: ~$115/month (₦172,500) = ₦2,070,000/year

Dokploy on My Homelab:

Hardware (amortized over 3 years): ₦50,694/month
Internet: ₦25,000/month
Electricity: ₦5,000/month
Total: ₦80,694/month = ₦968,328/year

After the first year, when hardware is paid off, costs drop to just ₦30,000/month.

First-year savings: Over ₦1.9 million compared to Heroku. After three years: Over ₦6 million saved. Plus, I own the hardware—it's an asset with resale value.

Feature Comparison:

Dokploy matches or exceeds commercial platforms on most features:

✅ GitHub integration (same as all platforms)
✅ Automatic SSL (same as all platforms)
✅ Database hosting (built-in, unlike Vercel)
✅ Docker Compose support (better than Heroku)
✅ Unlimited deployments (Heroku charges per app)
✅ No sleep mode (Heroku free tier sleeps)
✅ Full backend support (better than Vercel's serverless-only)
❌ Global CDN (Vercel wins here)
❌ Automatic scaling (Railway/Heroku win)

For full-stack applications with traditional databases, Dokploy is far more capable and cost-effective than any commercial PaaS.

My Primary Use Case: Self-Hosting Everything

My philosophy: if it can run in a container, it's going on Dokploy. Every side project, every experiment, every tool I build gets deployed to my homelab.

This approach provides:

Financial Freedom: Never worry about deployment costs
Learning Opportunities: Every deployment teaches DevOps skills
Data Ownership: Complete control over my data
Portfolio Advantage: Demonstrates end-to-end technical capability

Backup & Recovery

My backup strategy ensures quick recovery:

Nightly: Application and database backups via Proxmox
Weekly: Docker volume snapshots
Monthly: Off-site sync to external drives

After the SSD incident, this strategy proved its worth—I restored a complete node in under an hour. Having the Docker Swarm across two nodes provides redundancy: if one node fails, services continue on the other.

The Developer Experience

What I love most is the workflow simplicity:

Write code
Push to GitHub
Watch it automatically deploy
Done

No SSH-ing into servers, no manual Docker commands, no editing configs. Just pure development focus. It's Heroku-level simplicity on infrastructure I own.

Dokploy transformed my homelab from a technical experiment into a practical platform that genuinely competes with commercial PaaS offerings. It's the difference between having servers and having infrastructure.

Networking

Networking is often the most challenging part of a homelab, but it's also the most critical. You need secure, reliable access to your services both from inside and outside your network. My network stack is designed around both security and accessibility.

Cloudflare Tunnel

For external access, I route external traffic through Cloudflare Tunnel. This is a brilliant solution that eliminates the need to expose my home IP address or open ports on my router. The tunnel creates a secure connection from my homelab to Cloudflare's edge network, and Cloudflare handles all the external traffic.

The benefits are significant and include:

DDoS protection: Cloudflare automatically protects against attacks
Web Application Firewall (WAF): Filters malicious traffic before it reaches my network and rate limiting
SSL/TLS encryption: End-to-end encryption without managing certificates manually
Rate limiting: Prevents abuse and resource exhaustion (configurable)
Bot protection: Blocks automated attacks and filtering
Zero Trust Access: Optional additional security layer for sensitive services

This setup is particularly important now that my website is publicly accessible. Without Cloudflare Tunnel, I'd be directly exposing my home network to the internet, which is a security nightmare. Instead, all traffic flows through Cloudflare's infrastructure first, providing multiple layers of protection.

Reverse Proxies

Internally, I run both Traefik and Caddy as reverse proxies, depending on the use case, handling SSL certificates and dynamic service discovery. Traefik excels at dynamic service discovery with Docker — it automatically detects new containers and configures routing. Caddy is simpler and handles static routing beautifully with automatic HTTPS.

This combination gives me a clean, domain-based structure like:

paperless.intellect.lab

portainer.intellect.lab

immich.intellect.lab

jemeel.dev

Between Cloudflare Tunnel, Traefik, and Caddy, I have a robust networking setup that's secure, performant, and relatively easy to manage.

Performance, Challenges & Lessons Learned

Building and maintaining a homelab isn't all smooth sailing. Balancing resources across multiple VMs and containers took some trial and error. Here are some of the challenges I've faced and what I learned from them.

Resource Distribution

With three nodes and limited resources, careful resource distribution is essential. 32GB per node is adequate for most workloads, but RAM can bottleneck quickly when running multiple containers. I constantly monitor CPU, RAM, and disk usage to ensure no single VM or container is starving the others. Proxmox's built-in monitoring makes this easier, but it still requires regular attention.

Network Limitations

The 50Mbps connection (~6.25 MB/s) is the biggest bottleneck in my setup and caps throughput, so I optimized caching and limited high-traffic services. While it's sufficient for most use cases, there are clear limitations:

Performance Envelope:

Throughput: ~6.25 MB/s maximum
Static sites: ~100 concurrent users, ~12 requests per second
API-heavy applications: ~300-500 concurrent users, ~100 requests per second
Video streaming: Best kept local or limited quality

Capacity Examples:

Scenario: Static website serving

Page size: 500 KB
Concurrent users: ~100
Requests per second: ~12

Scenario: API-heavy application

Response size: 50 KB average
Concurrent users: ~300-500
Requests per second: ~100

Despite limitations, performance remains smooth for my use cases. My website loads quickly for visitors, and I haven't experienced any significant slowdowns even with moderate traffic. These aren't huge numbers, but for personal use and small-scale services, they're perfectly adequate. The key is understanding the limitations and designing services accordingly.

However, as I scale up and plan to self-host more projects, the upgrade I'm negotiating with my ISP will provide much more breathing room. With 10x the bandwidth, I could comfortably handle:

1,000+ concurrent users on static sites
Significantly improved video streaming quality
Faster backup and replication
Multiple high-traffic services running simultaneously

Maintenance and Troubleshooting

Regular maintenance is crucial. I've established a routine:

Weekly: Check service health, review logs for errors
Monthly: Update all services and base images, verify backups
Quarterly: Full system review, optimize resource allocation

When things break (and they will), having good documentation and backups is essential. I maintain a simple wiki documenting every service, its configuration, and common troubleshooting steps. This saved my life during the SSD incident—I could rebuild everything relatively quickly because I had documented the entire setup.

Future Improvements

A homelab is never truly finished. There's always something to improve, optimize, or add. There's always room to grow. Here are my plans for the near future:

Monitoring Dashboards: I plan to set up proper monitoring with Prometheus + Grafana. While Uptime Kuma tells me if services are up or down, I want deeper insights into performance metrics, resource usage trends, and potential bottlenecks. Prometheus will collect metrics from all services, and Grafana will visualize them in beautiful dashboards.

Automating Cluster Scaling: Currently, my high availability is somewhat manual. I want to implement more automated failover routines and mechanisms so that if a node goes down, services automatically migrate to healthy nodes without manual intervention. This requires more sophisticated orchestration, but it's worth the effort for critical services. I'm also exploring ways to automate scaling based on load.

🌐 Bandwidth Upgrade: I'm actively working with my ISP to secure a dedicated connection. This increase in bandwidth will enable me to:

Host more public-facing projects without performance concerns
Improve response times for external users
Handle significantly more concurrent traffic
Stream high-quality media without buffering

🖥️ Expanding the Cluster: As my workloads increase, I'm considering adding a few more Proxmox nodes to the cluster. I plan to self-host ALL my side projects moving forward — no more paying for Vercel, Heroku, or similar platforms (at least till there is a justification) when I have perfectly capable infrastructure at home. Each new project is an opportunity to learn something new while saving money on hosting costs.

🎓 AWS Local Mimic for Certifications: One of my more ambitious plans is to create a local AWS-like environment for hands-on learning. I want to build something that mimics AWS services locally—think LocalStack on steroids. This would allow me to:

Practice for AWS certifications without incurring costs
Understand AWS architecture at a deeper level
Experiment with complex multi-service architectures
Build skills that transfer directly to professional cloud environments

The goal isn't to perfectly replicate AWS, but to create enough similarity that I can practice real-world scenarios and prepare for professional certifications. Imagine setting up S3-like object storage, EC2-like compute instances, RDS-like databases, and Lambda-like serverless functions—all running locally on my homelab. It's an ambitious project, but that's exactly why I am investing in the homelab.

Conclusion

Building this homelab has been one of the most rewarding technical projects I've ever undertaken. It started as a simple desire to have cheap, reliable computing power for side projects, but it evolved into a comprehensive learning experience covering virtualization, networking, containerization, and infrastructure management. It taught me more about systems architecture, resource planning, and automation than any course could.

What have I learned? Quite a lot, actually.

First, infrastructure work is humbling. Things will break, often at the worst possible time. Whether it's accidentally destroying an SSD or dealing with unexpected service failures, you learn to troubleshoot under pressure and develop a healthy respect for backup systems.

Second, start simple and don’t despise starting from scratch. Try new things, read about the technologies, map out a plan, and tick off the checklist. Don't let the complexity intimidate you because every expert started as a beginner who kept going.

Third, self-hosting is empowering. There's something deeply satisfying about using services you built and control. No surprise pricing changes, no arbitrary feature removals, no worrying about a service shutting down. You're in control. When someone visits jemeel.dev, they're connecting to hardware sitting in my room, configured and maintained by me. That's incredible.

The economics make sense. For roughly ₦1.8 million upfront and ₦30,000 monthly, I have infrastructure that would cost ₦1+ million per month on AWS or GCP. The homelab paid for itself in three months and will save me millions annually. Plus, I own the hardware; it's an asset that retains value.

The homelab has dramatically improved my daily productivity and experimentation workflow. I can spin up test environments in minutes, deploy new ideas without worrying about cloud costs, and learn by doing rather than just reading documentation. More importantly, this project bridged the gap between theoretical knowledge and practical implementation. Reading about the tech is one thing; actually configuring it, troubleshooting networking issues, recovering from failures, and yes, even breaking SSDs, is something else entirely.

Now, every time I deploy a new app or spin up a container, I'm reminded of the beauty of learning by doing. This homelab isn't just a cluster of PCs — it's my digital playground, my sandbox for ideas, and a daily reminder that curiosity is the best teacher.

If you're considering building your own homelab, my advice is simple: just start. You don't need expensive hardware or a perfect plan. Start with what you have, run a few services, break things (hopefully not your SSDs), fix them, and keep learning. The journey is the reward.

And remember, whether you're using old Dell PCs like me or something fancier, the principles remain the same. Learn, experiment, iterate, and most importantly, have fun building your digital playground. The mistakes you make will teach you more than any tutorial ever could.

Keep GOing, keep building, and enjoy the journey.

Advance Data Types in Go: Arrays, Slices, Maps, Functions

Odewole Abdul-Jemeel — Sun, 26 Nov 2023 15:56:10 +0000

This article builds upon the last entry in the “Golang Primer” series, where we delved into the intricacies of Go syntax and covered fundamental language features, specifically focusing on primary data types in Golang. In this installment, we take a step further into the realm of advanced data types in Golang. Our exploration encompasses the various tools at our disposal for modeling, storing, and accessing data in diverse forms, tailored to different use cases.

Arrays

Arrays in Go serve as ordered collections of items, all of the same type, possessing a fixed size allocated in memory upon creation. Following the convention of many programming languages, array indices commence at zero, indicating that counting starts from 0 rather than 1. In contrast, slices in Go represent a more dynamic alternative to arrays. Slices lack a predetermined length, allowing them to expand or contract based on demand.

Due to the fixed nature of arrays (for instance, if an array of length 3 is created, it can accommodate no more than 3 items), they lack the adaptability required for many applications. To illustrate, adding a fourth item necessitates creating a new array with a larger size, copying the existing items, and then appending the new item. Consequently, slices emerge as the more prevalent choice in Go, and you will seldom encounter direct dealings with arrays.

The syntax for declaring arrays in Go looks as follows:

var fiveNames [5]string

fiveNames = [5]string{"John", "Jean", "Joe", "Jim", "Jane"}

// remember that we can only use the := shorthand inside a function
firstName := fiveNames[0] // to get the first item, John
secondName := fiveNames[1] // to get the second item, Jean

lastName := fiveNames[len(fiveNames)-1) // returns Jane

The len() function, a built-in function in Go, plays a crucial role in array manipulation by returning the length of the array.

Some key aspects distinguish arrays in Go:

Constant Size: The size of an array in Go must be a constant, meaning it must be determinable at compile time.
Type Differentiation by Size: The size of an array is integral to its type. For example, [3]int and [4]int are distinct types.
Syntactic Sugar for Size Inference: Go provides syntactic sugar for inferring the size of an array based on the number of elements. For instance:
```
goCopy code
// This results in the type [5]string
fiveNames := [...]string{"John", "Jean", "Joe", "Jim", "Jane"}
```
Copy Behavior in Function Arguments: When arrays are passed as arguments to a function, the function receives a copy of the array. Consequently, any modifications or alterations within the function do not impact the original array.

These nuances contribute to the robust and statically typed nature of arrays in Go, ensuring both predictability and type safety in array-based operations. It's essential to recognize that due to their inherent inflexibility, arrays in Go are seldom employed in everyday applications. Instead, slices, a more dynamic and versatile data structure, are the predominant choice in Go programming.

Slices provide a flexible alternative to arrays, adapting in size based on the requirements of the application. This adaptability makes slices better suited for a wide range of use cases, offering more convenience and ease of use compared to arrays.

Slices

Slices, in simple terms, are like arrays but without a fixed size. They're akin to the concept of a List in other popular programming languages. Behind the scenes, slices are built on arrays; they function as pointers to arrays. Unlike arrays, when slices are passed as arguments to a function, the function gets a reference or alias of the slice. This means that any changes made to the passed slice within the function also impact the original copy. It makes sense because a slice is always a pointer to another data structure, so any modifications to that underlying structure should affect anything else referencing or pointing to it. We'll delve into the details of pointers and referencing later.

Creating a slice is as simple as declaring an array without specifying a fixed size:

// note that the [] is empty, that is indicating that this is a slice
var sliceofNames []string

sliceOfNumbers := []int{0,1,2,3,4,5}

These are some common operations on slices:

// To get an item at an index, remember that the indexing is 0 based

zero := sliceOfNumbers[0]
one := sliceOfNumbers[1]

// this will create a new slice with items 2,3,4 and 5.
// The operation follows the format s[i:j], where i is the start index 
// and j is the end index. Note that the operator will only get up to 
// the j-1 element and not include the end index in the resulting slice, 
// which is why we use 6 in the example to get the 6-1 index, 
// which is the index of number 5
twoTo5 := sliceOfNumbers[2:6]

// we can also achieve the same result as above, 
// if the end index is skipped, as in this case, it defaults to len(s)
// i.e the lenght of the slice, so everything till the end is included
twoTo5 := sliceOfNumbers[2:]

// if the start index is ignored, then the index 0 is used by default
// i.e the new slice begins at the first index
zeroToFour := sliceOfNumbers[:5]

Slices in Golang differ from some other languages, notably in the aspect of comparison using ==. To compare two slices, it's necessary to manually compare each item in the array.

This is where the similarities between Golang slices and lists in other languages largely end. Tasks that may be familiar, such as add, pop, and insert, often require more manual effort in Golang.

Let's start with the task of adding an item to a slice. Golang provides a built-in append function precisely for this purpose. The append function takes a slice and a variadic number of arguments, allowing flexibility in the number of arguments passed—whether it be one, two, or an infinite amount.

newSlice := append(oldSlice, newItem)

// the append function has a variadic parameter, meaning we can pass 
// any amount of arguments after the slice
newSlice := append(oldSlice, newItem1, newItem2, newItem3, ...)

// or even append a slice to another
newSlice = append(slice1, slice2)

Removing an item from the slice is slightly more complicated:

names := []string{"John", "Paul", "George", "Ringo"}

// remove the first element
names = names[1:]

// remove the last element
names = names[:len(names)-1]

// remove the nth element in a slice
// note that we created an anonymous function and assigned it to a variable
removeNth := func(s []string, i int) []string {
        // check if the index is not out of range 
        if i >= len(s) {
            return s
        }
        /// note the ..., i like to call it the spread operator
        return append(s[:i], s[i+1:]...)
}

names = removeNth(names, 10)

To remove the first item from a list (or slice, pun intended), we simply create a new slice starting from the second index to the end of the list and assign it to the original slice. It's worth noting that if the end index is not specified after the colon, it defaults to the length of the list.

For removing the last item, a similar technique is employed. We copy from the start index up to the index of the last item, as illustrated in the example. Removing an item at a specific index, say the nth index, involves creating two slices: one from the start index up to the index to be removed, and another from after the index to be removed. These slices are then stitched together using the append function. The ... syntax serves as a spread operator, allowing all elements of the items in the slice to be spread and passed to the append function. This is possible because the append function also accepts variadic inputs.

To iterate over a slice, Golang provides a built-in range method. This method iterates over the slice, returning the next item on each iteration, starting from the first item.

// the range returns to result, the first is the index, the second is the value
// since we don't need the index in this example, we ignore it with the _ syntax
for _, name := range names {
        fmt.Println(name)
}

// or if you prefer, you can use this common way
for i := 0; i < len(names); i++ {
        fmt.Println(names[i])
}

Maps

In Go, a map is essentially a reference to a hash table. A hash table is a type of data structure used for an unordered collection of key/value pairs. Each value in the collection is associated with a unique key, and this association is made possible by a function known as a "hash" function. Importantly, all keys within the hash table are unique and are created using the hash function.

Hash tables are significant and valuable data structures, and I would strongly recommend delving deeper into understanding them. They play a crucial role in efficiently organizing and retrieving data based on unique keys, making them a cornerstone in various applications and algorithms.

You can think of a map in Go as an unordered slice where we get to decide the key by which we want to identify an item, with the condition that the keys must be comparable with the == syntax. A map has the below syntax, where the K is the type of the key, and V is the type of the value. The keys must have the same type, i.e you cannot use a string as key for one item and then use int it for another, and the values must also be of the same type.

var newMap map[K]V

// using the := syntax
mapOfAlphabetsToLanguages := map[string]string{
    "A": "Ada",
    "B": "BASIC",
    "C": "C++",
    "D": "Dart",
    "E": "Erlang",
}

// or using the built in make function
newMap := make(map[string]int)

You might be wondering why we would use the make function when we already have the convenient := syntax. The reason lies in situations where we know the size of the map in advance. By specifying the size of the map using the make function, like this: make(map, sizeOfMap), we can optimize resource usage and allocate an appropriately sized map from the start. This can be particularly beneficial when working with large datasets or in scenarios where efficiency and resource management are critical considerations.

These are some common actions we can take on a map:

mapOfAlphabetsToLanguages := map[string]string{
    "A": "Ada",
    "B": "BASIC",
    "C": "C++",
    "D": "Dart",
    "E": "Erlang",
}

// we can get the value by passing the key, 
ada := mapOfAlphabetsToLanguages["A"] // note that this is case-sensitive

// if we do this, there is no "a" key in the map, so the zero based value 
// for the type is returned, which is an empty string "" for strings.
ada2 := mapOfAlphabetsToLanguages["a"]

// we can reassign the values of a key,
// the value of the key "A" is now "ActionScript"
mapOfAlphabetsToLanguages["A"] = "ActionScript"

// we can use the builtin delete function to delete a key-value pair from the map
// the key "A" is now deleted from the map
delete(mapOfAlphabetsToLanguages, "A")

// we can use the len function to get the length of the map
// the length of the map is 4
lengthOfMap := len(mapOfAlphabetsToLanguages)

// we can use the range keyword to iterate over the map
// the order of the iteration is not guaranteed
for key, value := range mapOfAlphabetsToLanguages {
        fmt.Println(key, value)
}

As demonstrated in the example code above, attempting to retrieve a key that is not defined in the map does not result in an error; instead, you receive the zero value of that type. However, there are cases where it's crucial to ascertain whether the key truly exists in the map, and Go provides a convenient way to do this:

goCopy code
value, ok := theMap["wrongKey"]

Here, the variable ok is a boolean that is true when the key is present and false when the key is not found in the map. This mechanism proves helpful in handling scenarios where the existence of a key needs to be validated. It's worth noting that the name ok is a convention, and you can choose any variable name, such as notOk; however, using ok is a common practice for readability and consistency.

So in what cases should you use a slice or a map? The choice between using a slice or a map in Go depends on the specific requirements of your data structure. Here are some guidelines to help you decide:

Use a Slice if:

You need an ordered collection.
The order of elements matters, and you want to preserve it.
Indexing is essential, and you care about the position of elements.
You are frequently shuffling or manipulating the collection.

Use a Map if:

The collection does not need to be ordered.
You require key/value pairs, where each element has a unique and comparable key.
Absolute control over indexing is not critical, and you can use the key for retrieval.
You need to check for the existence of a particular key efficiently.

For example, you might store all student details in a slice if the order of entry is important. On the other hand, if you need to associate each student with a unique identifier (like a student ID) and their corresponding grade, a map would be a more suitable choice. This provides a key/value relationship, making it efficient to retrieve grades based on student IDs. The decision ultimately hinges on the specific characteristics and use cases of your data.

Functions

A function in Golang serves as a reusable unit of code designed to accomplish a specific task. It enables us to break down a large task into more manageable components that can be abstracted away from users, facilitating repetitive actions without the need to rewrite the implementation every time. The basic syntax of a function in Golang is as follows:

func functionName(parameters) (results) {
    ...
    // body
    ...
}

A function is named, which can be anything descriptive except for reserved keywords. It is followed by a pair of brackets ( and ) that contain the parameters the function can accept and work with. After that comes the result types, defining the types of outcomes returned to the function invoker. The function body is enclosed in a pair of curly brackets { }.

Let us write a function that gives us the sum of a list of integers:

func sum(numbers []int) int {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    return sum
}

This sum function takes a slice of integers ([]int) as a parameter and returns an integer.

Inside the function, we initialize a variable sum to 0. Note that the variable name (sum) is arbitrary, but it's good practice to choose a name that reflects the variable's purpose.
Utilizing the range method, we iterate over the slice to access individual numbers.
For each number in the slice, we add it to the sum.
After the loop completes, we use the return keyword to send the result back to the invoker of the function. The invoker is essentially the entity that is called the function.

We can then use the function in our code like this:

listOfNumbers := []int{1, 2, 3, 4, 5}

sum1 := sum(listOfNumbers)

listOfNumbers2 := []int{584, 392, 2834, 83, 4839}

sum2 := sum(listOfNumbers2)

Consider another example function:

func sumAndCount(nums ...int) (int, int) {
    sum := 0
    count := 0

    for _, num := range nums {
        sum += num
        count++
    }

    return sum, count
}

This function, named sumAndCount, is similar to the previous one but with an added feature. Instead of only calculating the sum, it also returns the count of elements in the provided slice.

Take note of a couple of key features:

The function employs a variadic parameter denoted by ... before the type (...int), indicating that the function can accept any number of int parameters.
The result syntax is now (int, int), indicating that the function returns two values, both of type int: the sum and the count.

sum1, count1 := sumAndCount(1, 2, 3, 4, 5)

listOfNumbers2 := []int{584, 392, 2834, 83, 4839}

// we use the spread operator to `spread` the content of the slice to the function
sum2 := sumAndCount(listOfNumbers2...)

Here's another example demonstrating an alternative function syntax:

// divideAndRemainder divides two numbers and 
// returns the quotient and remainder.
func divideAndRemainder(dividend, divisor int) (quotient, remainder int) {
    quotient = dividend / divisor
    remainder = dividend % divisor
    return // This return statement implicitly returns the named values (quotient, remainder)
}

This function takes two parameters, dividend, and divisor, both of type int. As they share the same type, Go allows us to omit the types for all but the last one.
The primary focus of this function is on the results. Yes, these are named results. Golang permits us to name the results, which can be advantageous in various scenarios. Named results act like variables; they are initialized with their zero values and are assignable within the function, hence the use of = in assignments like quotient = dividend / divisor, instead of the := syntax.
Notice the absence of an explicit return statement? That's because the results are named, and Go automatically returns them from the function. The return statement at the end of the function implicitly returns the named values (quotient, remainder).

Named Arguments and Default Values in Golang

If you observe, when invoking functions in Go, we don't use named arguments. In some languages, invoking the divideAndRemainder function might look like this:

// Name arguments in some languages
divideAndRemainder(dividend: 17, divisor: 3)

However, in Go, there is no concept of named arguments. All arguments must be passed in the same order as the parameters are declared in the function:

// Go has no concept of named arguments
divideAndRemainder(17, 3)

Additionally, it's crucial to note that Golang lacks the concept of default values. In Go, all parameters declared in a function must be explicitly passed as arguments when invoking the function. This simplicity and explicitness contribute to the clarity and predictability of Go code.

Anonymous Functions in Go

Anonymous functions, as showcased in the example, are functions in Go that don't have a name. In Go, it's not allowed to create a named function within another function. However, there are scenarios, like the one presented here, where a function is only useful in the current context, and in such cases, we can resort to using anonymous functions.

Here's an example:

names := []string{"John", "Paul", "George", "Ringo"}

// Remove the first element
names = names[1:]

// Remove the last element
names = names[:len(names)-1]

// Remove the nth element in a slice
// Note that we created an anonymous function and assigned it to a variable
removeNth := func(s []string, i int) []string {
    // Check if the index is not out of range
    if i >= len(s) {
        return s
    }
    // Use the "spread" operator (...) to remove the element at index i
    return append(s[:i], s[i+1:]...)
}

names = removeNth(names, 10)

Anonymous functions are declared using the func keyword, similar to named functions, but without including a name. They prove useful when you need to group a block of code together, especially in cases where the function is only intended to be executed once or when defining a function within another function is necessary, as seen in callbacks.

Here are additional examples to deepen our understanding:


import "fmt"

func main() {
    // Example 1: Anonymous function assigned to a variable
    add := func(x, y int) int {
        return x + y
    }

    result1 := add(3, 5)
    fmt.Printf("Result 1: %d\\n", result1)

    // Example 2: Immediately invoked anonymous function
    result2 := func(a, b int) int {
        return a * b
    }(4, 6) // Note that this function is called immediately with ()

    fmt.Printf("Result 2: %d\\n", result2)

    // Example 3: Passing an anonymous function as an argument
    calculate := func(operation func(int, int) int, x, y int) int {
        return operation(x, y)
    }

    result3 := calculate(func(a, b int) int {
        return a - b
    }, 8, 3)

    fmt.Printf("Result 3: %d\\n", result3)
}

Example 1 demonstrates an anonymous function assigned to the variable add. This function adds two integers.
Example 2 shows an immediately invoked anonymous function. The function is defined and called in a single line to calculate the product of two numbers. Notice the function invocation () immediately following the function block {}.
Example 3 showcases passing an anonymous function as an argument to another function (calculate). The calculate function takes an operation and two integers, applying the operation to the integers. This example demonstrates how to parameterize the calculate function, allowing the invoker to supply a function fitting the specified interface.

Congratulations! You have made it to the end of this session As we conclude this session, we've delved into the fundamental aspects of Golang, exploring syntax intricacies, understanding data types, and delving into the world of functions, including the intriguing concept of anonymous functions.

However, our journey into Golang is far from over. In the forthcoming segments of the "Golang Primer," we are poised to explore advanced data types, delving into the nuances of structs, interfaces, pointers, and the critical domain of error handling in Golang.

Please feel free to drop any questions you have and I will be happy to answer them. You can connect with me via my email intellectualjemeel@gmail.com, I am here on LinkedIn and here on Twitter, let’s connect.

Understanding Go Syntax and Language Features

Odewole Abdul-Jemeel — Sun, 05 Nov 2023 07:45:06 +0000

In this article, I will be introducing you to the basic foundation of reading and writing GoLang. Go is one of the simplest programming languages, which is one of the many reasons many developers love the language so much (find out other reasons why Go is so popular here). Go programs are stored in a text file with a .go extension, e.g main.go.

Programming is just a sequence of written instructions for a computer, and large applications are built by the composition of tiny and simple other instructions. Understanding how to create and combine these tiny instructions is the foundation of programming. Let us start from the basics and build our way up.

Variables

A variable serves as a storage location on the computer, identified by a name for easy reference. and since it is a storage, it can hold a quantity of data or object of a particular type. For example, if we need to store the age of a person in memory, we can do so like this,

var age int = 20

In this case, age is the name of the variable, the type (we are coming to this) of data that the variable contains is int (which means integer) and 20 is the value that will be stored in the variable.

Or to store the value of a complex calculation (not really), we can do this, for example

var total int =  1 + 2 + 3 + 4 + 5

Declaring a value in GoLang often follows the following format,

var name type = expression

The var is a keyword in Golang to tell the compiler that we are creating a variable, the name is the reference to which we want our variable to be known and accessed, the type is the type of data the variable can hold, the = is the assignment operator, and the expression is the value to be stored in the variable. If the expression is not provided, the variable is created and initialized with the zero value of the type. A zero value simply means a default value.

For instance, if we declare our variable like so,

var age int

we did not specify any value to be stored in the variable, so Go creates the variable and sets its value to 0, which is the default value for number types.

Zero values for different types

0 for numbers
false for booleans
“” for strings (note, “” is an empty string)
nil for interfaces and reference types (we are coming to this)

When creating multiple variables of the same type, you can efficiently do so on a single line, as demonstrated below:

var mean, median, mode, total, count int

As always, the var is the keyword for declaration, mean, median, mode, total, count are the variables to be created, and they are all of the same type as the type declared at the end of the line, which is int in this case. And remember, since we did not include any expression, they are all created with their zero values, so they all have the value of 0.

If perhaps we know the data ahead, we can create them in one line by providing the values separated by commas in the exact order in which the variables are created, like below,

var mean, median, mode, total, count = 20, 15, 30, 120, 10

// 20 is assigned to mean, 15 to median, and so on, in that order

If you want to create many variables of different types in one line, you can do so like this,

var name, age, sex, isPresent = "John", 12, "Male", true

// "John" is assigned to name, 12 to age, "Male" to sex, and true to isPresent

Multiple variables can also be created in the format below:

var (
        name      string
        age       int
        sex       string = "Male"
        isPresent bool = false
    )

And just like we have established, remember that if we don’t define an expression for the variable, it is created with the zero value. So in this case, name and age are created with zero values while sex and isPresent have the values “Male” and false respectfully.

Please note that expression can also be the output of a function (think of a function as a group of common code executing a particular task). Let’s say we have a function that computes the square of a number, we can store the result of this function when we calculate the square of 5 in a variable,

package main

import "fmt"

func main() {

    var squareOfFive int = Square(5)

    fmt.Println(squareOfFive)
}

// this is a function, we will discuss it in details in the next article
func Square(number int) int {
    return number * number
}

In some cases, especially if you want the variable to automatically be the type of the expression, you don’t need to explicitly specify the type, you can omit it, and Go will automatically infer the type of the variable from the type of value of the expression. So in this case of,

var squareOfFive int = Square(5)

we can simply omit the int and the variable will automatically assume the type of the returned data, like so:

// squareOfFive will automatically assume the type 
// of the data retured by the Square method, which is int in this case
var squareOfFive = Square(5)

This may be useful in some cases, but most times, you always want to declare the type of the variable, so your code can be simple, and readable.

There is an alternate way of creating a variable in GoLang, also known as a short variable declaration. This form of declaration is only permissible within a function and only used to declare local variables within the scope of the function. It takes the form:

// take not of the symbol
variableName := expression 

// the syntax is a semicolon followed by equals, :=

This method of variable declaration is prevalent and the syntax := is often confusing for people who are not familiar with Golang syntax. Let’s see it in an example, suppose we want to write a function that returns the average of 5 numbers, we can decide that we will compute the total of the 5 numbers and put it in a variable, then return the division of that variable by the count:

func AverageofFiveNumbers(a,b,c,d,e int) int {
    total := a + b + c + d + e
    return total / 5
}

// you cannot do this outside of a function, it will throw an error
total:= 20

This function is purely for demonstration and you will probably never be writing simple code like this in production. As you can see, we omitted the var keyword when we declared the total variable, other rules of variables apply to this too, as it is simply a variable too, but just created with another syntax (and remember that you can only use this := syntax in a function).

Variables are mutable and reassignable!

After we create a variable, we can overwrite the data later in the code to hold new information, as long as the new information is of the same type as the old value. For instance, after calculating the squareOfFive in the code below, we can overwrite it later in the code, to hold the wrong data.

package main

import "fmt"

func main() {

    var squareOfFive = Square(5)

    fmt.Println(squareOfFive) // 25 is printed

    squareOfFive = 10

    fmt.Println(squareOfFive) // 10 is printed
}

func Square(number int) int {
    return number * number
}

If you run the code, you will see that the value squareOfFive is overwritten with the wrong data. For this reason, variables are used to hold data that can be manipulated in the program (hence the name, it is not fixed).

Constants

We have already established that variables can be overwritten and changed in the code, whether intentionally or even by mistake, which is a very good thing, because most times, we make things work by manipulating the variables and changing their values at runtime. However, there are times when we need data storage to be fixed and immutable, i.e. it should be constant.

For example, if we are running a mathematical calculation that involves Pi , and some other mathematical constants, we do not want our code to be able to change their values, whether willingly or by mistake. In that case, we use, well, CONSTANTS.

Constants are data storage marked as immutable and are created at the program compile time. They can only be numbers, characters, strings, or booleans. And because they are constants, the expressions that define them must also be constant and can be evaluated by the compiler.

To create a constant, use the keyword const , e,g:

const speedOfLight = 299792458 // m/s

It follows the same format as when creating a variable, just replace the var keyword with const. If we try to mutate the value of the constant speedOfLight later in our code, we will get an error and our code will not compile.

If we need to create multiple constants, we can do this:

const speedOfLight, speedOfSound = 299792458, 343

// or 

const (
    speedOfLight = 299792458
    speedOfSound = 343
)

But remember that constants cannot be mutated, so we cannot have zero values or use any expression that implies that. Every value of the constant must be known at compile time.

There is also an iota keyword that is used to enumerate constants. For example, if we need to declare the days of the week with an index, starting with Sunday at index 0, we can use iota to make things easier like so:

const (
        SUNDAY int = iota
        MONDAY
        TUESDAY
        WEDNESDAY
        THURSDAY
        FRIDAY
        SATURDAY
)

In this code, the iota assigned the value 0 to Sunday, then increments to 1 for Monday, 2 for Tuesday, and so on. This can be very useful if we just need to quickly enumerate and increment some constants by a value.

Data Types

We have established that data type is the type of value that is stored in a variable. It is how we know about the data we have and how we can interact with the data.

In Golang, there are four categories of data types:

Primary types: Primary types are the data types that are pre-defined and built into the language and are the fundamental building blocks of the language. Examples are integers, strings, and booleans.
Aggregate types: Aggregate types, as the name implies, are data types that combine simple primary data types to form complex ones. Examples are arrays and structs.
Reference types: Reference types are data types that are used for dynamic management and accessibility of data locations and addresses in memory. Examples include pointers, slices, maps, and channels.
Interface types: Interface types are used to express generalization or abstraction about the behaviors of other types.

Let us dive into the primary data types in Golang, we will look at the other advanced types later in future articles.

Integers

Numbers are very important in programming and all languages provide ways to work with different types of numbers for different use cases. In Go, there are several sizes of integers, floating point numbers, and complex numbers to work with.

Go provides both signed and unsigned integer arithmetic. Signed integers simply mean the type can represent both positive and negative numbers, while unsigned integers mean that the type can only represent non-negative numbers. Signed integers are represented by int in Go while unsigned integers are represented by uint. int is the most used integer type and so it is often the recommended choice for integers.

Sizes of integers

int8 - 8 bits
int16 - 16 bits
int32 - 32 bits
int64 - 64 bits
uint8 - 8 bits
uint16 - 16 bits
uint32 - 32 bits
uint64 - 64 bits

The bits specify the range of the storage capacity of each type, the higher the size of the bit, the more number the type can hold. There is also a type rune which is often used in place of int32.

Many operations can be performed on integers, some of them are addition +, subtraction -, multiplication * , division / , remainder %, and comparison operations (compares the values of left and right and returns a boolean) e.g equals ==, not equal !=, less than <, greater than > and so on. There are also operations like +=, -=, *= which means performing this operation with the expression, and then assigning the result as the new data. For instance:

var total = 0

total += 10

// which is same as
total = total + 10

total -= 10

// which is same as
total = total - 10

total *= 10

// which is samea s
total = total * 10

Floating-Point Numbers

Floating points numbers are simply decimal numbers, and Go provides two data types to work with them - float32 and float64. The difference between these two types is also the data capacity. While the float32 provides approximately six decimal digits of precision, the float64 provides 15 digits, so it is often used for most floating number applications.

const pi = 3.141592653589793
const discount = .3 // notice that the 0 is omitted, this is permissible in Go.

You can also write floating point numbers with scientific notation,

const r = 3.456e11

Strings

A string is an immutable sequence of bytes, and is often human-readable text.

var name = "John" // John is a string

The length of a string can be determined by the len(string) function. Strings are just a list of individual characters and are indexed from left to right, and the count starts from zero. E.g

var name = "John"

John
0123

// we can get the first character by passing the index in a square bracket

j := name[0]
o := name[1]
h := name[2]
n := name[3]

However, when indexing a string, take note not to let the index go out of the bound of the string length as that can cause an indexing error.

Booleans

Booleans, represented as bool in Go can only be true or false. They are often used to represent possibilities of two logical states, e.g light is on or off (true for on, and false, for off.)

var isLightOn bool = false

isLightOn = true

They are used in conditions for control flows and are the outputs of comparison operations such as ==, <=, >=, !=. The ! syntax is used to negate the values of Booleans, it often reads as not. For instance,

var isLightOn bool = false

isLightOn = !isLightOn // note exclamation

This code means that the value of isLightOn should be the opposite of whatever the current value is, so if it is false, it becomes true, and if it is true, it becomes false.

Control Structures: Loops and Conditional Statements.

Control structures are used to analyze the state of the program and decide the direction of execution based on the given state. They are the basic decision-making process in programming.

Control statements mostly allow you to do two things:

Execute some statements while skipping others
Repeat one or more statements while some conditions are met.

Loops

There is only one way to loop in Go, and that is with the for loop. A loop is an iteration/rerun of a block of code until a certain condition is met. The condition is specified by the programmer and the program will not proceed until the condition of the loop becomes false, and if the condition is never met (i.e never false), the loop will run till infinity and eventually crash the computer (don’t worry, most computers can handle this elegantly). A for loop usually has this format, notice how the components are separated by semicolons, it is very important.

for initialization; condition; post {
    // do this
}

there are three basic parts of the for loop:

The initialization: this is called before the first iteration, so it is often used to do some pre-calculations, run a short code, or for variable declaration before the loop runs. Often used for short variable declarations, and any variable declared there is only available in the scope of the loop i.e in the block of code contained between the { and }.
the condition: this is run before every iteration, so it is where the comparison needed to check if the loop should run is done. If the value of this condition is false, then the loop stops running, and the program proceeds to the code following the for loop,
the post: this part of the loop is executed at the end of every iteration, so it is where the necessary variables are incremented and updated ahead of the next iteration.

Let us write a simple for loop that counts from 0 to 9;

// remember to import the fmt package

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

This code will run 10 times. It declares i to be zero at the initialization (which is run only once and before the for loop begins), then it checks the condition i < 10 , and since i is 0 at this point, the condition is true, so the code runs, and 0 is printed to the console. Immediately after that, the post is run and i++ executed. ++ is a syntax meaning increment the current value by one,

i++

// is the same as 

i = i + 1

and since i is zero, ++ increments i to 1. This completes the cycle for the first iteration. On the second iteration, the initialization is skipped, and the condition is checked again, this time, we know i is 1, so the condition is true again since 1 is < 10. The loop is run and 1 printed to the console, after which the post part is run to increment i to 2 and complete the cycle of the second iteration. This is repeated until i is incremented up to 10 the condition fails and the loop is closed and the program continues to the next line after the loop, which is why you don’t see the 10 printed in the console.

There is no while or do while that you may be familiar with in other languages in Go. You only have the for. To achieve a while loop, you can simply drop the initialization and post part of the for loop, as those are optional, and only declare a condition:

package main

import "fmt"

func main() {
    number := 1000
    noOfTimesDivisibleBy14 := 0

    for number >= 14 { // this works like a while loop
        number -= 14
        noOfTimesDivisibleBy14++
    }

    fmt.Printf("No of times divisible is %v, remainder is %v", noOfTimesDivisibleBy14, number)

}

If you omit the condition, you can create an infinite loop that runs forever;

for {
    // this is an infinite loop. 
}

To break out of a loop, you can use the break keyword to stop the iteration and break away from the loop irrespective of the condition, then the program continues to the next line after the loop body.

count := 0 

for {
    fmt.Println(count)
    if count >= 1000 {
        break // stop the loop and continue
    }
}
// the program continues running here

Note that you can also use a return keyword to close the loop irrespective of the conditions, but instead of continuing to the next line after the loop like in the case of break above, the program returns completely from that scope.

Conditional Statements

if

The if statement is used to check if a block of code should be executed or not. it usually follows the following expression:

if initialization; condtion {
    // do something conditionally
}

The initialization, as we saw in the for loop is where we can make some variable declarations before the condition is checked, and if the condition is true the code in the block {} will run and any variable created in the initialization will be available in the scope of that block. If the condition is false, the block is skipped and the program proceeds to the next line after the if condition.

There is also an else part of the if, though it is optional. The else block will run if the condition of the if statement is false.

if condtion {
    // do this, only if the condition is true
} else if second condition {
    // or do this, if first condition is false and second condition is true
} else {
    // if any of the previous conditions are not true, then do this
}

You can chain as many else if as you want (although it is probably not advisable to do so) or you can use the next conditional statement, the switch. Not that if you use a return inside the if statement, the program returns from the current scope.

Switch

The switch is simply a more compact and easier way to write a chain of if and else statements. It runs a condition against preconditions called cases and executes the first case it encounters that satisfies the condition of the execution.

Switch statements follow the following format:

switch initialization; comparator {
    case condition1: 
            // run this if comparator == condition1
    case condition2:
        // run this if comparator != condition1 and comparator == condition2
    default:
        // run this if the comparator matches none of the cases
}

// note that you can have as many cases as required

As always, the initialization is the part that allows us to create variables or run short codes before the switch is executed, and it is also optional. The comporator is the thing we want to check with cases from top to bottom to find a match. if no match is found with any of the cases, the default block is executed.

For example, let us write a code that switches between the color of a car:

switch carColor {
    case "red":
            fmt.Println("The car is red")
    case "blue":
            fmt.Println("The car is blue")
    case "green":
            fmt.Println("The car is green")
    default:
            fmt.Println("I don't know the color of the car")
}

The comparator is also optional, if it is not provided, it defaults to true and the program goes through the cases from top to bottom until it finds the first case whose condition is true. For example:

switch {
    case true == false:
            fmt.Println("The is false")
    case false == true:
            fmt.Println("The is false")
    case false != true:
            fmt.Println("The is true")
    default:
            fmt.Println("the default")
}

// in this case, since the comparator is not provided, it defaults to true and
// the program goes through the cases until it executes the third case whose 
// condition is true.

Congratulations! You made it here. That is just the basic syntax of Golang. In the next article, we will dive deeply into advanced data types such as arrays, maps, functions, pointers, and structs.

You can connect with me on LinkedIn here, on X, and my email is here.

Keep GOing

References:

Effective Go: https://go.dev/doc/effective_go

The Go Programming Language: Alan A.A Donovan, Brian W. Kernighan

A Comprehensive Introduction to Golang

Odewole Abdul-Jemeel — Sat, 28 Oct 2023 00:02:24 +0000

The genesis of the Go programming language can be traced back to a pivotal moment at Google, where engineers Robert Griesemer, Rob Pike, and Ken Thompson grappled with the intricate nature of C++. Their dissatisfaction with the complexity and the absence of a straightforward, efficiently compiled, and executed language spurred them to embark on a quest to design a novel language. On September 21, 2007, their endeavors culminated in the birth of version 1.0 of the Go language.

The primary mission of the Go creators was to amalgamate the ease of programming found in interpreted, dynamically-typed languages with the efficiency and safety characteristics of statically-typed, compiled languages. Beyond this, the Go language was envisioned to facilitate network and multicore computing, striving to expedite the coding process. To achieve these objectives, Go drew inspiration from various languages, amalgamating their most favorable features into a cohesive, simplified language that resonates with a broad spectrum of developers.

This article takes an in-depth look at the key features of Go, its installation, and an introductory guide to writing programs.

Go

Go is a compiled, concurrent, garbage-collected, statically-typed language. Now, let's break down each of these features to better understand their significance in Go.

Compiled

In the context of programming, a compiled language relies on a compiler system to translate the written code into machine-readable instructions. These compilers facilitate the transformation of human-readable code into the binary language that a computer understands. This process grants compiled languages an inherent speed advantage during runtime, as they operate directly in machine code. However, a drawback arises: whenever alterations are made to the code, the entire program must undergo a recompilation process, demanding additional time and effort.

One of the significant advantages of compiled languages lies in the early detection of errors. Before the program is executed, the compiler thoroughly scrutinizes the code, identifying and flagging any potential issues through compilation errors. This results in swift bug detection and resolution, saving time in the development cycle.

Yet, a notable limitation stems from system dependence. Compiled code is tailored for a specific machine, making it bound to the underlying system's architecture. Consequently, the compiled program might not function properly on systems for which it was not specifically compiled.

Considering GoLang's nature as a compiled language, it inherently inherits these advantages and trade-offs. The speed, early bug detection, and overall efficiency are key strengths of Go due to its compiled structure. However, developers working with Go need to consider the necessity for recompilation after code changes and be mindful of system dependencies while deploying their programs across different environments.

Concurrent

Concurrency involves the execution of multiple tasks or instruction sequences simultaneously, distinct from parallelism, although the distinction can be quite nuanced. Concurrency is about dealing with lots of things at once but parallelism is about doing lots of things at once.

Go, known as a concurrent language, is equipped with tools like Goroutines, simplifying the execution of concurrent programs. Goroutines are basic functions running independently in their threads, allowing for easy handling of concurrency.

However, managing shared memory, facilitating communication across different threads, and avoiding race conditions present challenges in concurrent programming. To address these issues, Golang offers elegant native tools such as channels, wait groups, and mutex. These features empower programmers to resolve common problems associated with concurrent programs efficiently. Delving deeper into these tools will be covered in subsequent sections of this series.

Garbage-collected

Garbage collection in programming serves as an automatic memory management process wherein a garbage collector scans and reclaims memory spaces that were initially allocated but are no longer referenced. This mechanism absolves programmers from the intricacies of low-level memory management and cleanups. However, while this feature does save time and effort for developers, it also utilizes system resources to decide which memory to reclaim and perform the cleanup, which could potentially impact a program's performance.

The primary benefit of garbage collection is its capacity to prevent memory leaks within a program. A memory leak occurs when memory space is lost due to the absence of proper cleanup by the developer, and the program remains unaware of this loss. By implementing garbage collection, Go ensures that memory management becomes a lesser concern for developers, although maintaining vigilance regarding code quality remains essential.

Nevertheless, there are instances in more advanced scenarios where adjusting or fine-tuning the garbage collection process becomes necessary. This could involve optimizing the garbage collection settings to extract maximum efficiency from a program or even temporarily disabling it to apply alternative memory management techniques. These cases necessitate a more nuanced approach to leverage the full potential of the program.

Statically-typed language

A statically typed language conducts type checking during the compile time, requiring that the type associated with each variable be determined before the code is compiled. This design necessitates a deliberate and precise approach when defining variables. However, the advantage is that once the variable type is established, it need not be continuously checked during runtime.

Furthermore, in a statically typed language, once a variable is defined with a certain type, it cannot be altered or assigned data that is inconsistent with that type. This characteristic offers a degree of safety and consistency within the code.

The perception of static typing varies among developers, as it can be regarded as both a positive and a negative aspect in programming. Some appreciate the rigor and safety it offers by catching potential errors during compilation, while others find it restrictive or overly formal for certain types of coding tasks.

These features collectively position Go as a modern and efficient language, offering speed, concurrency support, automatic memory management, and type safety. Developers can leverage these aspects for different project needs while being aware of associated trade-offs.

Why Golang?

1 . Simplicity

Golang's appeal lies in its simplicity and straightforward syntax, evident through its concise structure built upon a mere 25 defined keywords. The language fosters a paradigm of singular ways to execute tasks, significantly enhancing code readability while curbing the complexity that often results from over-engineering.

This dedication to an encouraged singular, effective approach not only streamlines code but also amplifies its reliability. Developers find assurance in the consistent functionality of their code, allowing for a clearer and more predictable development process. What's more, Golang's design philosophy emphasizes simplicity, equipping developers with fundamental tools readily available in its standard library. This emphasis on simplicity reduces the reliance on external or third-party libraries, empowering developers to craft robust applications without unnecessary dependencies.

2 . Golang is fast

Golang, as a compiled language, offers superior performance compared to dynamically typed languages such as Python and JavaScript. While it may not outperform the fastest languages like C++, the amalgamation of Golang's ease of use and inherent speed renders it significantly rapid and sufficiently swift for a wide array of use cases. This balance between speed and development ease positions Golang as an attractive language for most scenarios, catering to a broad spectrum of practical applications.

3 . Easy Concurrency

This is a pivotal strength of Golang. Concurrency is deeply ingrained in the language's core, making it an inherent part of its structure. While other languages may achieve concurrent tasks, Golang streamlines this process, requiring significantly less effort and often surpassing the effectiveness of other languages. Golang's innate design offers effortless and native solutions for handling concurrent operations, providing developers with convenient and efficient tools to manage and execute parallel tasks.

4 . Less Memory Footprint

The benchmark available at https://programming-language-benchmarks.vercel.app/ demonstrates that Golang stands out as one of the most memory-efficient languages presently available. This achievement is attributable to several inherent features of Golang, such as its static typing, robust garbage collection system, and the inherent structuring of data within the language. These traits collectively contribute to Golang's exceptional efficiency in terms of minimal memory consumption compared to other languages.

Companies using Golang

Google, Uber, Paypal, Alibaba, Cloudflare, Docker, Youtube, Linkedin, X (formerlly Twitter), IBM, FireFlies etc

Setting up Go development environment

1 . On Mac

To install Golang on a Mac, visit here to obtain the Go installation package. After downloading the package file, proceed to open it, which will effectively install Go on your system. To verify the successful installation of Go, open a terminal and execute the following command:

$ go version

Upon successful installation, you should receive a response similar to the following, which may vary depending on the installed version of Go:

go version go1.21.3 darwin/arm64

If you get a command not found error even after installing Go, then you need to add Go to your $PATH.

run the following commands to do that:

$ echo "export PATH=$PATH:/usr/local/go/bin" >> ~/.zshrc
$ echo "export PATH=$PATH:$GOPATH/bin" >> ~/.zshrc
$ source ~/.zshrc
$ go version

Following these steps, you should see the version of Golang that is currently installed in the console. If you continue to encounter issues, I recommend visiting StackOverflow at here for potential solutions. It's normal to seek help in such situations, and online communities like StackOverflow often provide valuable assistance for resolving technical issues.

2 . On Linux

To begin using Golang on Linux, head to https://go.dev/doc/install to download the go archive. Then, execute the following command:

$ rm -rf /usr/local/go
$ tar -C /usr/local -xzf go1.21.3.linux-amd64.tar.gz

The initial command removes any existing Golang installation before proceeding with a new installation. The subsequent command untars the recently downloaded archive.

Please note, execute these commands within the directory where the archive was downloaded. To verify your current working directory, enter the command:

$ pwd

After the tar operation has been completed, you need to add the Go directory to your PATH.

$ echo "export PATH=$PATH:/usr/local/go/bin" >> $HOME/.profile

Then you can run

$ go version

to verify that the installation was successful. If you don’t see the current version of Go printed in the console, then play around on Google to fix the issue.

3 . On Windows

Visit here to download the GO MSI file, open the file and follow the prompts.

Then open the Command Prompt and run

$ go version

You should be greeted with the version of the Go installed.

It is this simple to install Golang.

Coding Tools: Recommended IDE

GoLand by JetBrains is an exceptional IDE designed specifically to facilitate an enjoyable and straightforward Golang coding experience. While this IDE isn't free, its subscription is worthwhile if within your budget. For students, there's an advantageous offer providing a free student license for all JetBrains tools, including GoLand, for a year or more.

If GoLand isn't accessible, Visual Studio Code (VSCode) is an excellent alternative. To obtain VSCode, go to https://code.visualstudio.com/download for setting it up on your machine. Additionally, refer to this link for configuring VSCode for Golang development.

Writing and running your first Go program

Our first Golang program is going to be a simple Hello World, to show you the feel of Golang. In addition, we will code a GPA Calculator to give you a more robust introduction to coding in Go.

Let’s start with the HelloWorld program:

1 . Create a folder for our program.

open your terminal, and run the following command:

$ mkdir golang_projects && cd golang_projects
$ mkdir hello_world && cd hello_world

The mkdir is a command to create a directory with the name of the directory following it, because as software engineers, we should be comfortable with using the terminal to get things done (and it is usually faster than GUI). The &&, the logical AND, is a syntax to concatenate two commands in the terminal, meaning we are telling the terminal to create a directory AND cd into the directory. As you may have figured, cd is a command to go into the directory.

2. then run

$ go mod init github.com/hello_world

## response
go: creating new go.mod: module github.com/hello_world

This command tells Go to treat the folder we just created as a module, and to do the initialization of the dependency management for our project, so that when we import packages in other modules, go can know how to manage them for us. We will look into Go’s dependency management in detail later in this series.

3. create a file hello.go in the directory

$ touch hello.go

touch is a command to create a file from the terminal. Open the directory in your favorite IDE and open the hello.go file we just created.

4. Write the following code in the file

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

The line package main serves as a directive to Go, signifying that this file belongs to the main module. A package acts as a means to collect functions and essentially represents files located within the same directory in Go.

The statement import "fmt" functions by importing the "fmt" package into our code. This is how we use other codes written by other people in our program. import enables us to incorporate functionalities written by others into our program. "fmt" is part of the standard library inherent to Go, encompassing various formatting functions, notably the Println function, which outputs content to the console.

For those transitioning from other programming languages, the use of a capital letter to initiate a method might be surprising. In Go, the casing of the initial letter of a type determines the scope at the file level. Types beginning with a capital letter are accessible and exposed beyond their original declaration, while types starting with a lowercase letter remain unexposed and cannot be accessed outside of their specific scope. This mechanism mirrors the idea of public and private (or _) in languages like Java and others.

The func keyword is used to formally declare a function. Each time you intend to create a function, you must use this keyword for declaration. In our code, we declare the main function, which commonly serves as the entry point in a Golang program. By default, it gets executed whenever you run the main package.

fmt.Println("Hello, World!") too is self-explanatory, we are calling the Println method of the fmt package to print the string “Hello, World!” to the console.

5. To run the program, open a terminal in the main module (the directory where the go.mod exists), run the command below and you should see a beautiful “Hello, World!” printed in the console.

$ go run .

## resp
Hello, World!

The command run compiles and runs the go module declared in the current working directory, specified by the dot (.)

And that is your first Golang program. Despite the simplicity of this program, it is a good entry point to the world of Golang.

Check the next episode for the simple but explanatory GPA calculator that will make you fall in love with Go. Keep GOing.

References:

The Go programming language—everything you should know (https://codilime.com/blog/what-is-go-language/)

Go (programming language) https://en.wikipedia.org/wiki/Go_(programming_language)

Concurrency (computer science) https://en.wikipedia.org/wiki/Concurrency_(computer_science)

Concurrency in Operating System https://eng.libretexts.org/Courses/Delta_College/Operating_System%3A_The_Basics/05%3A_Process_Synchronization/5.1%3A_Introduction_to_Concurrency

Dynamic typing vs. static typing https://courses.cs.washington.edu/courses/cse341/04wi/lectures/13-dynamic-vs-static-types.html

Tutorial: Get started with Go https://go.dev/doc/tutorial/getting-started