Forem: Ahmed Alasser

Understanding var vs const in Go — A Beginner-Friendly Guide

Ahmed Alasser — Sat, 15 Nov 2025 10:02:21 +0000

👋 Hello there!
If you’re starting your journey with Go programming, one of the first things you’ll encounter is variables and constants.
Understanding the difference between var and const is crucial — and in this article, we’ll make it simple, fun, and practical with easy examples.

🟦 What is a Variable (var) ?

Think of a variable as an open box.
You can put something inside it, take it out, or replace it whenever you want.
In Go, we use var to define variables.
*Example in Go:
*

package main

import "fmt"

func main() {
  var balls int = 5
  fmt.Println("Initial balls:", balls)

  balls = 10 // Changing the value
  fmt.Println("Updated balls:", balls)
}

Here, we have a box with 5 balls. Later, we replace them with 10 balls, and Go is totally fine with it.
*✔️ Use var when:
*
1- The value will change during program execution
2- You’re storing user inputs, counters, scores, etc.

🟩 What is a Constant (const)?

A constant is like a locked box.
Once you put a value inside, it cannot change for the lifetime of your program.

Example in Go:

package main

import "fmt"

func main() {
  const pi float64 = 3.14
  const userName string = "Ahmed"

  fmt.Println("Pi:", pi)
  fmt.Println("Username:", userName)
}

Try to change pi or userName later, and Go will give you an error — the value is locked.
.

🧠 Simple Analogy

Open box **(var) → like a desk drawer
**Locked box (const) → like a safe

*Real-life example:
*
1- var → drawer with papers
2- const → safe with your passport

🧭 When to Use var vs const in Go

*Use var for values that:
*
1- Change over time
2- Depend on user input
3- Work as counters, states, etc.

*Use const for values that:
*
1- Never change
2- Represent math constants
3- Define configuration values
4- Hold static names/labels

*💡 Pro Tip:
* 🚀 Always use const when possible — it keeps your Go code clean, safe, and bug-free.

✨ Final Thoughts

That was a simple and fun 😁 tour of variables (var) and constants (const) in Go.

😎 Once you master the difference, your Go code becomes:
1- Cleaner
2- More maintainable
3- Less buggy

🙌 Thanks for reading!

📢 Follow me on DEV

If you enjoyed this post, drop a ❤️ or leave a comment below — your support means a lot. Let’s connect and share ideas!

🙌 If you’ve got questions or topics for the next article, drop them in the comments — I reply to every one!

Stay curious. Stay coding.

And see you in the next article of the series: “Learn Go from Zero to Hero.”

Understanding Go Project Structure (Without Losing Your Mind)

Ahmed Alasser — Sat, 08 Nov 2025 12:08:43 +0000

**Assalamu Alaikum and welcome! 👋

**Ready to dive deeper into the world of Go programming?

If you've opened a Go project before and felt lost among main.go, utils.go, handlers.go, and a mysterious go.mod, don’t worry. This article will guide you step by step, with a few laughs along the way 😁.

## 🧩 The Big Picture: How Go Keeps It Clean
**
Go 1.22.5 continues to enforce neat project organization. Messy folders? Scattered files? Not on Go's watch.
Every Go project usually follows a clear structure:
1- 🧠 **Modules – the project's brain .
2- 📦 Packages – the organs that do the work .
3- 🗂️ Files – the cells inside those organs .
4- 🔬 (Optional) Workspace – a lab for multiple projects .

Let's break them down one by one.

*## 🧠 Modules – The Boss of the Operation
*
A module is like the CEO of your project.
It doesn’t code, but it tells Go where everything goes and who depends on whom.

Start a new project with:

bash
go mod init github.com/ahmedalasser/golearning

This creates the go.mod file:

go
module github.com/ahmedalasser/golearning
go 1.22.5

⚓ Think of it as your project's ID card. Without it, your project is like a ship with no captain.

Remember:
1- Always include go.sum for dependency integrity.
2- Use go get -u carefully – Go 1.22.5 handles upgrades more predictably now.

**📦 Packages – Where the Real Work Happens

**
Packages organize your code into logical units. Common examples:

1- utils – helpers and reusable functions .
2- handlers – API logic .
3- auth – authentication stuff .
4- db – database magic .

Example project structure:

text
/project
 ├── go.mod
 ├── main.go
 ├── utils/
 │    ├── math.go
 │    └── string.go
 └── handlers/
      ├── user.go
      └── auth.go

Each file declares its package:

go
package utils

Functions you want to export should start with a capital letter:

go
func Add(a, b int) int {
    return a + b
}

Then use it elsewhere:

go
import "github.com/ahmedalasser/golearning/utils"
result := utils.Add(3, 5)

Remember:

1- Keep packages small and focused.
2- Group related functionality; avoid huge "God packages."
😎 Modules → Packages → Functions. Simple. Clean. Go-ish.

**🗂️ Files – Tiny but Mighty

**
Each Go file should handle one clear task. Think of files like movie characters: one shouldn't do everything – script, act, direct, AND make coffee ☕.

1- auth.go handles authentication .
2- user.go handles users .
3- db.go handles database .
main.go is the director – it just calls the right packages.

*Best Practices:
*
1- Name files clearly (auth.go not stuff.go).
2- Keep files short and focused.

🔬 Workspaces – The Return of a Legend

**
Workspaces allow multiple modules to live together during development. Old $GOPATH is gone. Go 1.18 brought workspaces back:

bash
go work init ./authlib ./mainapp

Now authlib and mainapp can interact locally without constant Git pushes.
💥 Optional, but lifesaving when juggling multiple modules.

**🧭 A Peek at a Real Go Project

text
myproject/
 ├── go.mod
 ├── go.sum
 ├── go.work          # optional
 ├── main.go
 ├── internal/
 │    └── database/db.go
 ├── pkg/
 │    ├── utils/math.go
 │    └── handlers/auth.go
 └── README.md

1- internal/ → private packages .
2- pkg/ → reusable packages .
3- go.work → optional workspace for multiple modules .

Tip: Follow this structure to make your project easier to maintain.

**✨ Final Thoughts

**
That was our slightly fun 😁 tour of Go project structure – from Modules, to Packages, to Workspaces.

Once you get this, your projects will stay neat, maintainable, and scalable. Fewer headaches, fewer lost files, more coding joy! 😎

🙌 Thanks for reading!

**📢 Follow me on DEV

**
If you enjoyed this post, drop a ❤️ or leave a comment below — your support means a lot. Let’s connect and share ideas!

If you’ve got questions or topics for the next article, drop them in the comments — I reply to every one! 🙌

Stay curious. Stay coding.

And see you in the next article of the series: “Learn Go from Zero to Hero.”

🚀 A Fun Tour of Go’s Official Website!

Ahmed Alasser — Tue, 04 Nov 2025 20:02:52 +0000

🚀 A Fun Tour of Go's Official Website!

Assalamu Alaikum and welcome! 👋

Ready to take off into the world of Go programming?

Ready to take off into Go programming? In this article, we’ll explore the official Go website (go.dev) — your one-stop guide to learning, practicing, and mastering Go from scratch.

Before diving into goroutines, concurrency, and the fun stuff, let’s start with the right foundation:

📍 Go’s official website — your ultimate guide to mastering the language.

🌐 Go.dev — The Hidden Treasure Most People Ignore

Believe it or not, most beginners visit go.dev once, skim through it, and never come back…

Big mistake. 😅

Because this website isn’t just a boring documentation dump — it’s a structured, hands-on learning hub that guides you through every stage of Go development.

Each section is crafted so intelligently, you’ll find yourself thinking:

“Do I even need a paid course anymore?” 😎

Let’s take a look at the key areas that make Go.dev such a gem.

🧠 1. The Documentation — Clear, Concise, and Actually Useful

Our first stop is the Go Documentation — the ultimate reference for all things Go.

Whether you’re figuring out what package main really means or diving into interfaces and modules, this section’s got you covered.

Start with Get Started, where you’ll find:

🧩 Setup guides for your OS
💻 Command-line basics
⚙️ Practical examples you can actually run

They even walk you through your first “Hello, World!” as if saying:

“Welcome to the Go family, developer!” 👨‍💻💛

🌀 2. Tour of Go — Learn by Playing 🎮

This is my personal favorite part.

Imagine learning Go and coding right inside your browser — no downloads, no installations, no setup headaches.

That’s Tour of Go in a nutshell.

You write your code on the right, run it instantly, and see the results in real time.

Perfect if your computer isn’t a powerhouse or you just want to jump straight into coding.

It starts simple, then takes you deeper into slices, maps, and concurrency.

Every time you complete a section, a little button feels like it’s cheering for you:

“Nice work! Ready for the next level, champ?” 💪

💡 3. Go by Example — Learn the Fast Way, with Real Code

If you’re the kind of learner who loves seeing real code instead of walls of text — this is for you.

Check out Go by Example — a legendary site that splits the page in two:

📄 Explanation on the left
💻 Code on the right

You read, run, and learn — all in one flow. ⚡

When you’re exploring goroutines, for example, instead of reading endless paragraphs, you’ll see a short, working example that makes it click immediately.

That’s the magic of Go:

It teaches you to think in code, not just memorize syntax.

🔍 4. Tutorials — When You’re Ready to Go Deeper

Once you’ve nailed the basics, it’s time to level up with Go Tutorials.

This section focuses on:

🧱 Real-world projects
🌟 Best practices
🚀 Advanced Go concepts

You’ll start learning how to build production-grade systems — not just toy programs.

As they say:

“The difference between writing code and building systems… is understanding.” 😉

🎯 Pro Tip Before You Begin

Think of Go.dev as your treasure map 🗺️.

Follow it step by step, try out the examples yourself, and don’t just read — experiment.

And of course, keep following this series!

In upcoming articles, we’ll write real Go code together and see how everything works under the hood.

By the end, you won’t just learn Go —

you’ll understand it. 💥

✨ Final Thoughts

That was our quick (and slightly fun 😁) tour of the official Go website — from Documentation, to Tour of Go, and Go by Example.

It’s one of the most well-structured, beginner-friendly resources out there.

Whether you’re learning solo or alongside a course, this site is your best companion.

Thanks for reading! 🙌

📢 Follow me on DEV

If you enjoyed this post, drop a ❤️ or leave a comment below — your support means a lot.

Let’s connect and share ideas!

If you’ve got questions or topics you’d like me to cover next, drop them in the comments — I reply to every one! 🙌

Stay curious. Stay coding.

And see you in the next article of the series:

“Learn Go from Zero to Hero.”

☘️ Peace and blessings!

— Ahmed Alasser

Exploring Go’s Core Features in Depth

Ahmed Alasser — Sun, 02 Nov 2025 13:32:11 +0000

In the previous article, I briefly mentioned some of Go’s main features — but in this one, I’ll dive deeper and explain them more clearly.
Let’s explore why Go is such a powerful and developer-friendly language.

**🧩 1. Simplicity
**One of Go’s greatest strengths is its simplicity.
Its syntax is clean, easy to read, and straightforward to write.
While Go enforces some strict rules that can’t be changed, they actually help keep your code consistent and maintainable.

👉 Even beginners can easily read and understand Go code — that’s one of its biggest advantages.

***⚙️ 2. Versatility
*

Go is not purely object-oriented or functional.
Instead, it gives you the flexibility to choose how you want to structure your code.

You can:
Write code in an object-oriented style 🧱
Or use a functional approach 🔁
Or even combine both — depending on what fits your project best

This makes Go extremely versatile and adaptable for all kinds of applications.

*♻️ 3. Garbage Collection
*

If you’re new to programming, garbage collection might sound complicated — but it’s actually simple.

🧠 Go automatically manages memory for you.
When an object is no longer in use, Go removes it from memory.

This means:
✅ No manual memory cleanup
✅ Fewer memory leaks
✅ Better performance overall

You can just focus on writing your logic, while Go handles the memory behind the scenes.

*⚡ 4. Speed
*
As I mentioned in the previous article, Go is a compiled language.
That means it translates your code directly into machine language — making it super fast ⚡

That’s why Go is widely used for high-performance backend systems and large-scale infrastructure.

***🔄 5. Concurrency
*

Concurrency is one of the most powerful and unique features of Go.
With goroutines, you can run multiple tasks at the same time — efficiently and safely.
They’re lightweight threads managed by Go’s runtime, allowing your app to scale easily.

💡 We’ll explore concurrency in more detail later in this course — it’s one of the things that make Go stand out!

*💻 6. Cross-Platform Compatibility
*
Go works perfectly on:

🪟 Windows
🍎 macOS
🐧 Linux

You can write your code once and run it anywhere — no need for major changes or platform-specific tweaks.

We’ll also see how to install Go on each OS in upcoming lessons.

*🏁 Final Thoughts
*
These are some of the core features that make Go such an amazing language.
Of course, there are many others — but these give Go its perfect balance of:
✨ Simplicity
⚡ Performance
🧩 Scalability

📢 Follow me here If you have any questions, feel free to drop them in the comments — I’ll be happy to help 👇

Thanks for reading! 🙌
If you enjoyed this post, drop a 👏 or comment below — your support means a lot.
Let’s connect and share ideas!

Why I Chose Go as My Main Backend Language — and Why You Might Too

Ahmed Alasser — Sat, 01 Nov 2025 10:08:51 +0000

When I first started exploring backend development, I jumped between multiple languages — Python, Node.js, even a bit of Java.
Each had its strengths, but I kept feeling something was missing: clarity.

Then I discovered Go (or Golang) — and it changed the way I thought about backend programming.
Go wasn’t flashy. It didn’t promise “magic” frameworks or a hundred shortcuts.
It just offered speed, simplicity, and structure — and that was exactly what I needed.

*🧠 The Mindset Behind Go
*
Go was created at Google to solve a real problem:
Large, complex systems that were getting slower and harder to maintain.

The goal was simple — create a language that’s easy to read, fast to run, and effortless to deploy.
That philosophy still shows in every line of Go code.

From its clean syntax to its built-in tools, everything feels designed for clarity and productivity.
Here’s what makes it special 👇

*⚡ 1. Simplicity That Doesn’t Sacrifice Power
*
Go has no unnecessary complexity.
No inheritance, no endless dependencies, and very little boilerplate.
It’s a language that forces you to focus on solving the problem, not fighting the syntax.

Example:

package main
import "fmt"

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

That’s a complete Go program — no setup files, no configuration chaos.
You can compile it, run it, and deploy it in seconds.

This simplicity means fewer bugs, faster learning, and a smoother path from idea to execution.

*🚀 2. Performance That Feels Effortless
*
Go is a compiled language, so your code runs directly on the machine — not through an interpreter.
That gives you C-like performance with Python-like ease of writing.

You don’t need to tweak garbage collection or write complex optimizations.
Go handles performance gracefully while letting you focus on business logic.

For developers building APIs or scalable services, that’s a huge win.

*🧵 3. Concurrency Made for Humans
*
Concurrency (running multiple tasks at once) is where Go truly shines.
Most languages make it complicated — Go makes it beautifully simple.

With goroutines, you can run lightweight, concurrent tasks using just one keyword:

go handleRequest()

That’s it. No threads, no heavy setup.
You can serve thousands of simultaneous requests efficiently — perfect for modern web backends and microservices.

*🧩 4. A Batteries-Included Standard Library
*
Go doesn’t need a huge ecosystem to get started.
Its standard library already includes everything you need for real-world backend work:

HTTP servers (net/http)

JSON handling (encoding/json)

File operations

Testing (testing package)

Concurrency primitives

That means less time hunting for third-party packages, and more time building actual software.

*🌍 5. A Growing, Practical Community
*
The Go community is one of the most pragmatic developer spaces out there.
It’s not about hype — it’s about real-world results.

From startups to giants like Google, Uber, and Docker, Go powers production systems at scale.
You’ll find endless tutorials, open-source projects, and helpful developers who care about clean, efficient code.

*🧭 Why I Chose Go
*
I chose Go because it fits how I think:
I like to build things that work, scale, and make sense.

With Go, I spend less time debugging and more time creating.
It’s a language that rewards good habits — and punishes bad ones gently but effectively.

Every line of Go code teaches you something about clarity, structure, and performance.

*💡 My Advice for New Developers
*
If you’re just starting out in backend development, here’s my honest advice 👇

Start simple. Don’t chase every new framework.

Build small projects — APIs, CLI tools, or simple web apps.

Read Go code. Learn from open-source projects.

Focus on fundamentals — data flow, concurrency, and clean code matter more than fancy tools.

You’ll be amazed how much you can build with just Go’s standard library and a bit of curiosity.

*🧱 What’s Next
*
This article is the start of a series I’m writing about learning Go from the ground up — from building your first API to deploying it in production.
If you’re on a similar journey, follow me here on Medium.
Let’s learn, experiment, and grow together — one Go project at a time. 🚀

*🎓 Coming Next: A Beginner-Friendly Go Course
*
After sharing my journey with Go and why I chose it as my main backend language, I’ve decided to take things a step further.
I’m launching a complete Go course for beginners — a hands-on series that will take you from writing your first line of code to building real-world projects.

We’ll cover everything from the basics and API building to file handling and concurrency — all explained clearly and simply.

📢 Follow me here so you don’t miss the first lesson — coming very soon! 🚀

**Thanks for reading**! 🙌
**If you enjoyed this post, drop a 👏 or comment below — your support means a lot.
Let’s connect and share ideas!

My Journey to Becoming a Full Stack Developer

Ahmed Alasser — Fri, 31 Oct 2025 12:45:20 +0000

Hey, I’m Ahmed — My Journey to Becoming a Full Stack Developer
Hi everyone! I’m Ahmed Alasser, a developer in progress from Egypt, currently building my path toward becoming a Full Stack Developer.

I’m passionate about clean, scalable code and enjoy learning how both the backend and frontend work together to create great web experiences.

A few months ago, I decided to take my coding journey more seriously. I’ve always been curious about how the web works — how data moves between the server and the browser, how APIs are structured, and how design turns into real functionality.

These days, I’m focusing on Go for backend development and JavaScript/React for the frontend.

I chose this stack because Go offers speed and simplicity for backend systems, while React brings flexibility and power to the user interface. Together, they make full stack development both fun and efficient.

I’m also learning more about REST APIs, Docker, databases, and Linux, to build complete, deployable applications. I’m not claiming to be an expert — but every project and mistake is helping me improve.

My goal is simple: to write code that works and makes sense, not just quick fixes.

Through these posts, I’ll be sharing lessons, experiments, and ideas from my journey — hopefully helping others who are walking a similar path.

If you’re learning Go, React, or exploring full stack development, let’s connect and share knowledge!