DEV Community: Kazem

Most Developers Use AI. Few Actually Lead It.

Kazem — Thu, 26 Feb 2026 17:29:26 +0000

AI is now embedded in modern development workflows.
Code generation, refactoring, documentation, debugging — it’s all accelerated.

But after integrating AI deeply into real production systems, I’ve noticed something important:

The difference between average results and exceptional results is rarely the model.

It’s how the engineer guides it.

Switching from one model to another rarely transforms mediocre output into great engineering.
Clear thinking does.

Let’s break down what actually makes the difference.

⸻

1. Clarity Beats Verbosity

Many developers assume that giving AI more information improves results.

In practice, unfocused information degrades results.

AI performs best when the task is:
• Clearly defined
• Narrowly scoped
• Explicit in constraints

For example, compare:

“Improve this code.”

vs.

“Refactor this Laravel service to reduce database queries, avoid N+1 issues, and maintain backward compatibility with existing API responses.”

The second instruction narrows the solution space.
The first invites ambiguity.

More context is not better.
Relevant context is better.

Precision scales. Noise compounds.

⸻

2. Context Is a Tool — Not a Dumping Ground

In large codebases, especially microservice or modular architectures, context selection becomes critical.

Attaching entire folders or referencing loosely related modules “just in case” introduces ambiguity.

Instead:
• Provide only the files directly involved.
• Clarify relationships explicitly.
• Define what must not change.

Strong engineers curate context before passing it to AI.

AI systems are pattern predictors.
The cleaner the pattern space, the cleaner the output.

⸻

3. Think → Plan → Prompt

One of the biggest productivity leaks in AI-assisted workflows is skipping the thinking phase.

Prompting should not be reactive.

Before writing the instruction:
1. Define the outcome.
2. Identify constraints.
3. Break the task into steps.
4. Decide the evaluation criteria.

Then prompt.

When teams complain about needing constant follow-ups and corrections, the issue often isn’t the tool — it’s the absence of upfront structure.

Planning reduces iterations.
Structure reduces friction.
Friction slows teams.

⸻

4. Share the Edge Cases Early

Engineers sometimes “test” AI by withholding known complexity:
• Hidden edge cases
• Performance constraints
• Backward compatibility requirements

This is counterproductive.

AI is not a junior developer you’re evaluating.
It’s an execution engine.

If you know there’s a race condition risk — say it.
If the function must remain pure — state it.
If latency must stay under 100ms — include it.

The more explicit the constraints, the stronger the output.

⸻

5. Direct the Tooling Layer

Modern AI coding agents can:
• Execute terminal commands
• Traverse repositories
• Refactor across modules
• Run linters or formatters
• Generate migration scripts

But they don’t automatically choose your preferred path.

If the solution should:
• Use a specific package
• Follow a specific architectural pattern
• Respect existing domain boundaries

State it clearly.

Leadership applies to tools as well.

⸻

The Real Shift

The narrative around AI often focuses on replacement.

In practice, what’s happening is amplification.

AI amplifies:
• Clear thinking
• Structured engineering
• Good architecture
• Strong constraint design

It also amplifies:
• Ambiguity
• Poor planning
• Shallow understanding

The tool is neutral.
Your thinking is not.

⸻

The skill that matters most today isn’t “knowing how to use AI.”

It’s knowing how to steer it.

The engineers who master this won’t just ship faster.

They’ll design better systems — because their thinking improves before their velocity does.

And in the long run, thinking always compounds more than speed.

GoLang 101: Understanding Polymorphism Through Interfaces

Kazem — Thu, 07 Aug 2025 15:31:21 +0000

Hey everyone! 👋 Welcome back to our GoLang 101 series.
In this article, we’re diving into a concept called polymorphism.

If you’ve worked with languages like PHP or Python, you’re likely familiar with polymorphism being closely tied to inheritance. But Go takes a simpler and more elegant path — no inheritance required. Instead, Go uses interfaces to unlock powerful polymorphic behavior.

Let’s see how this works.

What is Polymorphism?

At its core, polymorphism is the ability for an object to take on different forms depending on the context. A simple way to think about this is a function or method with a single name that performs different actions based on the type of object it's acting on.

Take the concept of area, for example. If you want to compute the area of a rectangle, the calculation is base * height. But for a triangle, it's (1/2) * base * height. The function area does two different things depending on whether it's dealing with a rectangle or a triangle.

This is polymorphism in action, the area method is polymorphic because it has different forms depending on the object.

In many object-oriented languages, polymorphism is supported through inheritance. This is where classes have a "superclass" (parent) and "subclass" (child) relationship, and the subclass inherits the methods and data of the superclass. The subclass can then redefine, or "override" a method it inherited from the superclass to provide its own specific implementation.

But Go has no inheritance.

So how does it achieve polymorphism? Let’s see.

Go's Solution: The Power of Interfaces

Go uses interfaces to define behavior in a clean and flexible way.

An interface is a set of method signatures — it defines what a type must do, not how it does it.

Example: A Shape Interface:

type Shape2D interface {
    Area() float64
    Perimeter() float64
}

Any type that implements both Area() and Perimeter() methods automatically satisfies the Shape2D interface — no implements keyword needed.

Let's define Rectangle and Triangle:

type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

type Triangle struct {
    Base, Height, SideA, SideB float64
}

func (t Triangle) Area() float64 {
    return 0.5 * t.Base * t.Height
}

func (t Triangle) Perimeter() float64 {
    return t.Base + t.SideA + t.SideB
}

Both of these types now satisfy the Shape2D interface, no explicit declaration needed.

Now that we have polymorphism through interfaces, we can write flexible functions.

func FitsInYard(s Shape2D) bool {
    return s.Area() < 100 && s.Perimeter() < 100
}

This one function works with any type that satisfies Shape2D, Rectangle, Triangle, or even custom shapes in the future.

You get code reuse, flexibility, and clarity — all without inheritance.

Disambiguation with Type Assertions

While interfaces are great for hiding differences, sometimes you need to "peel it apart" and figure out the exact underlying concrete type. This is especially useful in a program like a graphics application where you might have an DrawShape function that needs to call specific drawing APIs for different shapes (e.g., DrawRectangle, DrawTriangle).

For this, Go provides type assertions. A type assertion provides access to an interface value's underlying concrete value.

func DrawShape(s Shape2D) {
    // Check if the underlying type is a Rectangle
    if rect, ok := s.(Rectangle); ok {
        DrawRect(rect)
    } else if tri, ok := s.(Triangle); ok {
        DrawTriangle(tri)
    }
}

A more convenient way to handle this is with a type switch, which is a special form of the switch statement for type assertions.

func DrawShape(s Shape2D) {
    switch sh := s.(type) {
    case Rectangle:
        DrawRect(sh)
    case Triangle:
        DrawTriangle(sh)
    // ... other cases
    }
}

The variable sh is now of the correct concrete type in each case block.

A Common Use: Error Handling

Another great use of interfaces is in error handling. In Go, many functions return two values: a result and an error.

This error is actually an interface. The error interface is very simple; it has a single method called Error that returns a string.

type error interface {
    Error() string
}

This simple interface allows any type to represent an error, as long as it has an Error() method. When a function returns an error, you should always check if it is nil. If it's not nil, it means something went wrong, and you should handle the error.

f, err := os.Open("file.txt")
if err != nil {
    fmt.Println(err) // Calls err.Error()
    return
}

This is a standard and robust way to handle errors in Go.

Go's approach to polymorphism with interfaces is a powerful and flexible alternative to the traditional inheritance model. By focusing on behavior (methods) rather than data, interfaces allow you to write clean, reusable code that can work with a wide variety of types. In the next article, we'll dive even deeper into how interfaces work behind the scenes and explore some more advanced topics.

Happy coding!

GoLang101: Go’s Minimal Object-Oriented Style

Kazem — Thu, 07 Aug 2025 09:36:55 +0000

Hey everyone! Welcome to the next article of our GoLang 101 series. In this article, we're going to tackle a concept that can seem a bit tricky at first: object-orientation in Go. If you've worked with languages like Python or Java, you're probably used to the idea of classes. Go takes a slightly different approach, but the result is just as powerful and, in my opinion, even more elegant. Let's dive in.

What is a Class, Anyway?

Before we get into Go's unique style, let's quickly review the traditional definition of a class. A class is essentially a blueprint for an object. It’s a collection of data fields and functions (often called methods) that are all related to a single concept. The class itself is a template; it contains the data fields but not the actual data.

An object, on the other hand, is an instance of a class. It's a concrete item that holds actual data, following the template defined by the class. For example, a Point class might define that a point has an x and y coordinate. An object of that class would be a specific point, like (5, 5), with actual values for x and y.

Go's Minimalist Approach to Object-Orientation

Go doesn't have a class keyword. But don't let that fool you! It achieves a similar effect by associating methods with data. The key is the "receiver type."

Remember how we talked about structs in a previous article? In Go, you can define a struct to combine data fields into a single type, like so:

package main

import "fmt"

type Point struct {
    x float64
    y float64
}

func main() {
    p := Point{x: 3, y: 4}
    fmt.Println(p)
}

This struct is the "data fields" part of our class. To add the "methods" part, we use a receiver type when defining a function. A function with a receiver type is called a method and is associated with that specific type.

Here's how we'd add a method to our Point struct to calculate its distance from the origin using the Pythagorean theorem:

package main

import (
    "fmt"
    "math"
)

type Point struct {
    x float64
    y float64
}

// This is a method with a receiver type of Point
func (p Point) DistToOrigin() float64 {
    // It's doing the Pythagorean theorem: sqrt(x^2 + y^2)
    return math.Sqrt(p.x*p.x + p.y*p.y)
}

func main() {
    p1 := Point{x: 3, y: 4}
    distance := p1.DistToOrigin()
    fmt.Println("Distance to origin:", distance)
}

Notice the (p Point) part before the function name DistToOrigin. This is the receiver type. It tells Go that this method belongs to the Point type, and we can call it using dot notation, like p1.DistToOrigin().

Encapsulation and Controlled Access

Encapsulation is another core tenet of object-oriented programming. The idea is to hide internal data from the user of a class, allowing it to be accessed or modified only through defined methods. This prevents the user from accidentally making the data inconsistent.

Go achieves this through a simple yet powerful rule: capitalization

If a variable, type, or function name starts with a lowercase letter, it is private to the package it's defined in. It cannot be accessed by another package.
If it starts with a capital letter, it is public and can be accessed from any other package that imports it.

By giving data fields like x and y lowercase names, we can hide them from outside packages. We can then provide public, capitalized methods like Scale or PrintMe that control how that data is accessed and modified, ensuring consistency and safety.

Encapsulation is the concept of hiding data from a programmer and controlling how that data is accessed. This is typically done by making data accessible only through methods that are part of the class. In Go, this is achieved through a simple capitalization rule.

Let's expand on the previous example by creating a data package with a private variable and a public function to access it.

package data

// Point has lowercase fields to make them private
type Point struct {
    x float64
    y float64
}

// InitMe is a public method to initialize the Point
// It has a capital first letter
func (p *Point) InitMe(newX, newY float64) {
    p.x = newX
    p.y = newY
}

// PrintMe is a public method to display the coordinates
func (p *Point) PrintMe() {
    fmt.Printf("Point coordinates: (%f, %f)\n", p.x, p.y)
}

in main package, we can create a Point object and use the public methods InitMe and PrintMe to interact with the private x and y fields.

package main

import (
    "fmt"
    "./data" // Assuming 'data' package is in the same directory
)

func main() {
    p := data.Point{}
    p.InitMe(3, 4) // We can call the public method to set x and y 
    p.PrintMe()    // We can call the public method to print x and y

    // This would result in a compile-time error because 'x' and 'y' are private
    // p.x = 10
}

This way, we provide controlled access to the internal data. The programmer using our data package must use the public methods we've provided, which ensures the data remains consistent.

To Point, or Not to Point? Receiver Types and Mutability

So far, our methods have been passed a copy of the receiver object (call by value). This is fine if the method just reads data, like DistToOrigin, but it's a problem if the method needs to change the data inside the object. If we try to modify a field within a method that has a value receiver, we're only modifying the copy, not the original object.

There's also a performance consideration: if the object is very large, making a copy every time you call a method can be slow and inefficient.

The solution? Use a pointer receiver.

By using a pointer to the struct as the receiver type, the method receives a pointer to the original object, not a copy. This allows the method to directly modify the data in the original object.

Here's how we'd write an OffsetX method that actually modifies the point:

package main

import "fmt"

type Point struct {
    x float64
    y float64
}

// This method uses a pointer receiver (*Point) to modify the original struct
func (p *Point) OffsetX(v float64) {
    p.x = p.x + v
}

func main() {
    p1 := Point{x: 3, y: 4}
    p1.OffsetX(5)
    fmt.Println(p1) // Output: {8 4} - The x value has changed!
}

Notice the *Point in the receiver. This is a pointer receiver. When you call p1.OffsetX(5), Go implicitly passes a pointer to p1 to the method, allowing the change to persist. It’s a convenient shortcut, as you don't even need to manually reference the object with & when you make the call. You also don't need to dereference the pointer inside the function with (*p).x, you can just use p.x and Go handles it for you.

As a good programming practice, it's generally recommended to stick with either all pointer receivers or all value receivers for a given type to avoid confusion.

And that's it! By understanding structs, receiver types, and pointer receivers, you now have a solid grasp of how Go handles object-orientation. Happy coding!

GoLang101: Mastering Functions

Kazem — Fri, 01 Aug 2025 19:27:35 +0000

Welcome back to our Go series! 👋

In this lesson, we’re going to explore how to define behavior in Go programs using functions. It's time to go a bit deeper and honestly, there's no better place to start than functions. If you're planning to "go" anywhere in Go, you'll be writing a lot of them.

So, let's get into it. Don’t worry, we’ll keep it clean, clear, and practical.

Why Functions Matter (More Than You Think)

You’ve probably already seen a function in Go:

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

That’s the entry point for every Go program — the main() function. But functions in Go aren’t just necessary boilerplate. They're powerful tools for breaking your code into manageable, reusable, testable chunks.

A function is like a named recipe. It describes what ingredients (parameters) it needs and what dish (result) it returns. The best part? You can reuse it as many times as you want.

Writing Your Own Function

Let’s write our first custom function.

func greet(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    greet("Gopher")
}

That’s it. The function greet takes one string parameter and prints a friendly hello. Notice the parentheses after the function name — that’s where parameters live.

Reuse: The Real Power of Functions

Imagine needing to print greetings for 100 users. Would you copy-paste the fmt.Println line 100 times? Hopefully not. You just reuse the function:

greet("Alice")
greet("Bob")
greet("Charlie")

Functions make your code smaller, cleaner, and less error-prone.

Functions with Return Values

Need a function that does something and then returns a result? Go makes this really straightforward:

func add(x int, y int) int {
    return x + y
}

func main() {
    sum := add(3, 4)
    fmt.Println("Sum is:", sum)
}

Multiple Return Values? Yup.

func minMax(x int) (int, int) {
    return x - 1, x + 1
}

Passing Data: By Value vs. Reference

By default, Go copies arguments when calling functions. This is called call by value.

func increment(val int) {
    val++
}

func main() {
    x := 5
    increment(x)
    fmt.Println(x) // Still prints 5
}

Want the function to actually change the value? Pass a pointer:

func increment(val *int) {
    *val++
}

func main() {
    x := 5
    increment(&x)
    fmt.Println(x) // Now it prints 6
}

Pointers can be a little intimidating at first, but once you get used to them, they’re a game changer.

Arrays, Slices, and Function Arguments

Passing arrays copies the whole thing — not great for big data. Instead, Go has slices, which are lightweight and efficient.

func doubleFirstElement(nums []int) {
    nums[0] *= 2
}

func main() {
    numbers := []int{1, 2, 3}
    doubleFirstElement(numbers)
    fmt.Println(numbers) // [2, 2, 3]
}

Slices behave like references but are safe and predictable. In Go, slices > arrays, almost always.

Go-Style Functional Programming (Just a Bit)

Go isn’t a “functional” language, but you can treat functions as values.

func apply(fn func(int) int, val int) int {
    return fn(val)
}

func main() {
    double := func(x int) int { return x * 2 }
    fmt.Println(apply(double, 5)) // 10
}

You can also return functions — hello, closures!

func makeMultiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

This flexibility lets you write dynamic, clean, and composable code — when you need it.

Variadic Functions – The Flexible Argument Trick

Sometimes, you don’t know exactly how many arguments you’ll need. Maybe you want a function that can take 2, 3, or 50 integers — all at once. Go makes this easy with variadic functions.

Let’s build a simple one: getMax, which finds the largest number from a list of integers.

func getMax(vals ...int) int {
    max := vals[0]
    for _, v := range vals {
        if v > max {
            max = v
        }
    }
    return max
}

func main() {
    fmt.Println(getMax(1, 3, 6, 4)) // Outputs 6
}

So What’s Going On Here?

The ...int means the function can accept any number of int values.
Inside the function, vals behaves just like a slice ([]int).

You Can Also Pass a Slice

Already have your values in a slice? Just use the ... syntax to unpack it:

vals := []int{1, 3, 6, 4}
fmt.Println(getMax(vals...)) // Still prints 6

This makes your functions super flexible — you can accept both raw arguments and pre-built slices.

Defer – Clean Up Later, Worry Less Now

In Go, you can schedule a function to run after the current function finishes, using the defer keyword.

Here’s a simple example:

func main() {
    defer fmt.Println("Bye")
    fmt.Println("Hello")
}

// output: 
Hello
Bye

That’s right — defer delays the call until main() is about to return.

Why Use defer?

It’s perfect for cleanup tasks:

Closing files
Unlocking resources
Logging exits

it's better to use it in prior article, right?

file := openFile()
defer file.Close() // Closes when function ends

Quick Gotcha: Argument Evaluation Timing

Even though the function call is deferred, its arguments are evaluated immediately.

Check this out:

func main() {
    i := 1
    defer fmt.Println(i + 1)
    i++
    fmt.Println("Hello")
}

// output: 
Hello
2

Why not 3? Because i + 1 was evaluated when defer was called, not when it ran.

This little quirk can save you some debugging time later.

Function Design Tips (The Human Side)

Let’s get real: code isn't just for machines. It’s for humans too — including future you who returns to this code six months from now.

Here are some friendly tips:

Name your functions well. computeRMS() is better than doMath().
Keep them focused. One function = one job.
Avoid long parameter lists. If you need many values, consider a struct.
Shorter is better. If a function's more than ~15 lines, ask yourself why.

We’ve covered a lot of ground in this article. From understanding what functions really are to writing your own, passing data in and out, and keeping things clean and understandable — you’ve now got a solid grasp on how Go handles functions. We also dipped into some more advanced ideas like using functions as values, creating flexible functions with variadic arguments, and making your code safer and cleaner with defer.

Up next, we’ll dive into how go take advantage objected oriented programming. Stay tuned, and happy coding!

GoLang 101: Communicating with the World — Files, JSON, and Protocols

Kazem — Sat, 19 Jul 2025 13:17:07 +0000

When you write Go code, you’re not working in a vacuum. Real-world applications often need to talk to other systems, save and load data, or communicate over the internet. That’s where file I/O, JSON, and network protocols come in.

In this tutorial, we’ll cover:

How Go handles files
What JSON is and how to use it
How Go communicates over protocols like HTTP and TCP/IP

Let’s jump in.

Communicating Beyond Your Program

Your Go program will often need to:

Read/write from files
Exchange data with APIs
Send or receive messages over a network

To do this, we rely on standardized formats and protocols—rules that both sides understand. These include things like JSON, HTML, HTTP, and more. In Go, many of these are supported with built-in packages, so you don’t have to reinvent the wheel.

RFCs: The Blueprint of Communication

An RFC (Request for Comments) is basically a public standard. Think of it like a contract that says, “Here’s how data should be structured so both sides understand each other.”

For example:

HTML – how web pages are structured
HTTP (RFC 2616) – how web clients and servers talk
URI – how resources are located on the web
JSON (RFC 7159) – a universal format for structured data

Go supports many of these via standard packages, so working with them is usually just a matter of importing the right package.

Using Go Packages for Common Protocols

net/http

Use this when you want your program to make web requests or serve web content.

resp, err := http.Get("http://example.com")

net

Want to create low-level TCP/IP or socket connections? This package is your go-to.

conn, err := net.Dial("tcp", "example.com:80")

These libraries handle a lot of the complex protocol details for you, so you can focus on the logic.

JSON: The Universal Language of Data

JSON (JavaScript Object Notation) is one of the most popular data formats. It’s simple, readable, and maps well to Go’s structs and maps.

Let’s say you have a Person struct:

type Person struct {
    Name    string
    Address string
    Phone   string
}

Now you create a person:

p := Person{Name: "Joe", Address: "123", Phone: "123"}

To convert this to JSONL:

barr, err := json.Marshal(p)

The result barr is a []byte representing this JSON:

{
  "Name": "Joe",
  "Address": "123",
  "Phone": "123"
}

JSON to a Go struct: Now, let’s say you receive some JSON and want to convert it into a Go object:

var pp Person
err := json.Unmarshal(barr, &pp)

This populates pp with the data from the JSON.

-> Just make sure the struct field names match the JSON keys!

Working with Files in Go

Go makes file access straightforward but gives you the power to go deeper if needed.

Want to read part of a file? Use the os package:

f, err := os.Open("data.txt")
b := make([]byte, 10)
n, err := f.Read(b)
f.Close()

Need to write to a file?

f, err := os.Create("output.txt")
f.Write([]byte{1, 2, 3})
f.WriteString("Hi there!")
f.Close()

This lets you control how much you read/write, and when.

This knowledge is the foundation for building real-world applications that save files, talk to web services, or process external data.

In the next article we are going to work with functions

GoLang 101: Organizing Data in Go with Arrays, Slices, Maps, and Structs

Kazem — Fri, 18 Jul 2025 14:56:29 +0000

Hey there, and welcome back to our Go learning journey! 👋

In the last chapter, we explored how to write logic using if, for, and switch. Now it’s time to level up and introduce a powerful idea in Go: composite data types.

These are essential when simple types like int and string just aren’t enough. Let’s dig in together.

What Are Composite Data Types?

Composite data types allow us to group multiple values into a single structure. Think of it like this: instead of tracking individual numbers or strings, you can combine them in one variable.

In Go, the key composite types we’ll cover are:

Arrays
Slices
Map
Struct

Arrays — Fixed-Size Containers

An array is a collection of values, all of the same type, and it has a fixed size defined at compile time.

Declaring an Array

var x [5]int

This creates an array x with 5 integers, all initialized to 0 (Go auto-initializes!).

Accessing Elements

x[0] = 2
fmt.Println(x[1]) // prints 0, since we didn’t set it

Arrays are zero-indexed, so x[0] is the first element.

Want to initialize an array with specific values?

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

You can also let Go infer the size using ...:

x := [...]int{1, 2, 3, 4}

The [...] tells Go: “Figure out how many elements I’m giving you, and make the array that size.”
The type of x is [4]int — a fixed-length array of 4 integers.
Arrays cannot change size once declared.

Looping Through Arrays

Iterating is super common. Go makes it clean with range:

arr := [3]int{1, 2, 3}

for i, v := range arr {
    fmt.Println(i, v)
}

i is the index
v is the value at that index

Slices — Flexible and Powerful

Arrays are cool, but their size is fixed. Slices are like dynamic arrays—much more common and practical in Go.

Creating a Slice from an Array

arr := [7]string{"a", "b", "c", "d", "e", "f", "g"}
s1 := arr[1:3] // includes index 1 and 2 ("b", "c")
s2 := arr[2:5] // includes "c", "d", "e"

Slices are windows into arrays. They can overlap and share data.
Length and Capacity

Every slice has:

len(slice): number of elements
cap(slice): total capacity (how far it can grow without reallocating)

fmt.Println(len(s1), cap(s1)) // Output: 2 6

You can declare a slice directly:

s := []int{10, 20, 30}

This automatically creates the underlying array and slice together.

Creating Slices with make

Use make() to create a slice with a specific size (and optionally, capacity):

s1 := make([]int, 5)            // length and capacity = 5
s2 := make([]int, 3, 10)        // length = 3, capacity = 10

Growing Slices with append

Need to add elements? Use append:

s := []int{}
s = append(s, 1)
s = append(s, 2, 3)

Behind the scenes, Go grows the slice and manages memory for you. If the capacity is exceeded, it allocates a larger array and copies the data—seamlessly.

Shared Underlying Arrays

When you slice an array or another slice, the new slice shares the same memory.

So changing one affects the other:

arr := [5]int{1, 2, 3, 4, 5}
s1 := arr[1:4]           // {2, 3, 4}
s2 := arr[2:5]           // {3, 4, 5}
s1[1] = 99               // modifies arr[2]
s2[0] = 88               // modifies arr[2]
fmt.Println(arr, s1, s2) // Output: [1 2 88 4 5] [2 88 4] [88 4 5]

Understanding this is key to avoiding subtle bugs.

What is a Map in Go?

A map in Go is Go’s version of a hash table, a data structure that stores key-value pairs. It’s like a dictionary where you look things up by a name (the key) instead of by a number.

Think of a map where the key is someone’s name and the value is their phone number:

idMap := map[string]int{
    "Joe": 123,
    "Jane": 456,
}

You can access values by key:

fmt.Println(idMap["Joe"]) // Outputs: 123

Using make:

var idMap map[string]int
idMap = make(map[string]int)

This creates an empty map where:

The key is a string
The value is an int

Using a map literal:

idMap := map[string]int{
    "Joe": 123,
    "Jane": 456,
}

Adding or Updating Values

idMap["Pat"] = 789       // Add a new pair
idMap["Jane"] = 999      // Update an existing value

Deleting a Key

delete(idMap, "Joe") // Removes the key "Joe" and its value

Checking if a Key Exists

id, ok := idMap["Joe"]
if ok {
    fmt.Println("Joe's ID is", id)
} else {
    fmt.Println("Joe not found.")
}

ok is true if the key exists.
This is useful to avoid getting default zero-values for non-existing keys.

Looping Through Maps

Use range to iterate over every key-value pair:

for key, val := range idMap {
    fmt.Println(key, val)
}

Maps don’t have a guaranteed order, so the output order may vary.

What is a Struct?

A struct (short for structure) lets you group multiple related values—of possibly different types—into a single object.

It’s like a lightweight class in other languages, and perfect when you want to model something meaningful—like a Person.

Declaring a Struct:

type Person struct {
    name    string
    address string
    phone   string
}

Creating Struct Instances

You can create and initialize a struct in a few ways.

Using var and dot notation:

var p1 Person
p1.name = "Joe"
p1.address = "123 Main St"
p1.phone = "555-1234"

Using a struct literal:

p2 := Person{
    name:    "Jane",
    address: "456 Oak Ave",
    phone:   "555-6789",
}

Accessing Fields

You can read and write to fields using dot notation:

fmt.Println(p2.name)       // Read
p2.phone = "555-0000"      // Write

Using new for Initialization

p3 := new(Person)
p3.name = "Pat" // All fields are initialized to zero-values by default

This allocates a pointer to a Person struct.

You can even combine them! For example:

people := map[string]Person{
    "joe": {name: "Joe", address: "Street 1", phone: "123"},
}

You’re doing great. Keep going, and don’t hesitate to experiment in your own Go playground. Remember: every great Go programmer started right where you are.

See you in the next one! 🧑‍💻✨

GoLang 101: Making Decisions and Loops with Control Flow

Kazem — Thu, 17 Jul 2025 06:09:16 +0000

Welcome back to the third part of our Go journey! 🚀

So far, you’ve learned how to set up Go, write simple programs, work with variables, and define functions. Now it’s time to make our code dynamic—reacting to user input, making decisions, and repeating tasks.

Let’s explore Go’s control structures in a way that feels natural and easy to use.

The if Statement

At the core of every program is decision-making. In Go, if is your best friend.

score := 85

if score >= 90 {
    fmt.Println("Excellent!")
} else if score >= 70 {
    fmt.Println("Good job.")
} else {
    fmt.Println("Keep practicing.")
}

No parentheses needed around the condition (unlike C or Java), and curly braces {} are required even for single-line blocks. Clean and strict—just the Go way.

Loops with for

Go has one loop keyword: for. That’s right—no while, no do-while. Just for, and it does everything.

Classic Loop

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

While-style Loop

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

Infinite Loop

for {
    fmt.Println("Loop forever")
    break  // Don’t forget to break!
}

Go’s loop syntax is super flexible. It’s easy to write readable code without weird surprises.

The switch Statement

Tired of long if-else chains? Use switch.

day := "Tuesday"

switch day {
case "Monday":
    fmt.Println("Start of the week")
case "Friday":
    fmt.Println("Almost weekend!")
default:
    fmt.Println("Just another day")
}

Go’s switch automatically breaks after each case—no break needed.

You can even switch on conditions:

score := 82

switch {
case score >= 90:
    fmt.Println("A")
case score >= 80:
    fmt.Println("B")
default:
    fmt.Println("C or below")
}

This is super helpful when writing clean conditional logic.

Getting User Input (Basic Way)

Want your Go program to interact with the user? Let’s read some input:

var name string
fmt.Print("Enter your name: ")
fmt.Scanln(&name)
fmt.Println("Hello,", name)

fmt.Scanln() reads user input.
You must pass a pointer (&name) so Go can store the value.

Combining It All: A Tiny Program

Let’s write a simple interactive grading app:

package main

import (
    "fmt"
)

func main() {
    var score int
    fmt.Print("Enter your score: ")
    fmt.Scanln(&score)

    switch {
    case score >= 90:
        fmt.Println("Grade: A")
    case score >= 80:
        fmt.Println("Grade: B")
    case score >= 70:
        fmt.Println("Grade: C")
    default:
        fmt.Println("Grade: F")
    }
}

Try running this in your terminal and inputting different numbers. You’re writing real logic now!

A Note on Error Handling

Go doesn’t use exceptions like many other languages. Instead, functions often return a value and an error.

You’ll see this pattern everywhere:

value, err := someFunction()
if err != nil {
    // handle the error
}

We’ll explore error handling more in an upcoming lesson, but just keep this pattern in mind.

In this article, you learned how to:

Use if, else if, and else to make decisions
Write all kinds of loops using for
Simplify logic with switch (and conditional switches!)
Accept user input from the terminal using fmt.Scanln

In the next articles, we’ll dive into arrays, slices, and maps—Go’s most useful tools for working with collections of data.

You’re doing great. Keep practicing, keep exploring, and Go will soon feel like second nature.

Happy coding! 🧑‍💻

GoLang 101: Mastering Variables, Types, and Memory in Go

Kazem — Thu, 17 Jul 2025 04:34:22 +0000

Welcome back! 🎉 In the last article, we talked about why Go is worth learning and how to get started. Now it’s time to dive into something every programming language needs: variables and data types. We’ll also talk about memory in Go—how variables are stored, scoped, and cleaned up with Go’s built-in garbage collector.

Let’s get into it!

What Is a Variable?

A variable is just a name for a chunk of memory that holds some data—like a number, a string, or something more complex.

In Go, every variable must have:

A name (like x or userAge)
A type (like int, string, or float64)

Here’s a simple example:

var x int

This tells Go: “Please reserve a space in memory called x to store an integer.”

You can also declare multiple variables at once:

var x, y int

Declaring and Initializing Variables

There are a few ways to create and assign values to variables in Go.

Declare and Assign Separately

var x int
x = 10

Declare and Assign Together

var x int = 10

Let Go Infer the Type

var x = 10  // Go will assume x is an int

Use Short Declaration (Inside Functions Only)

x := 10

This one is super common in Go. It’s quick and clean, but it only works inside functions.

Constants

Constants are like variables—but their value never changes. They’re great for fixed values like mathematical constants or configuration settings.

const pi = 3.14159
const appName string = "MyGoApp"

You can’t use := for constants. Also, constant values must be assigned at compile time.

Types in Go

Go is statically typed, meaning the type of each variable is known at compile time. This helps catch bugs early and improves performance.

Basic types:

int, int64, uint – whole numbers
float32, float64 – decimal numbers
string – a sequence of characters
bool – true or false

You can even define your own aliases for clarity:

type Celsius float64
type UserID int

var temp Celsius = 36.5
var id UserID = 123

This doesn’t change the actual type (Celsius is still a float64), but it adds semantic meaning, which helps when reading or maintaining code.

Memory and Pointers

Every variable lives somewhere in memory. Go lets you work with pointers, which store memory addresses instead of actual values.

Two pointer operators you need to know:

&x gives you the address of x
*p gives you the value at address p

Example:

x := 5
p := &x      // p points to x
fmt.Println(*p)  // prints 5

You can also create new pointers like this:

ptr := new(int)  // ptr is a pointer to an int with a zero value
*ptr = 100       // set the value at the pointer

Variable Scope

Scope refers to where in your code a variable can be accessed.

In Go, scope is block-based and hierarchical. That means:

A variable declared outside of functions is accessible everywhere
A variable declared inside a function (or block) is local to that function/block

var x = 10 // global

func printX() {
    fmt.Println(x) // OK, x is visible here
}

func anotherFunc() {
    var y = 20
    fmt.Println(y) // OK here
}

fmt.Println(y) // Error: y is out of scope here

Stack vs. Heap

When you run a Go program, memory is divided into two major areas:

Stack – short-term memory used for function calls and local variables. It’s fast and automatically cleaned up.
Heap – long-term memory for data that might live longer than a function call. It requires garbage collection.

In most low-level languages like C, you’d have to manually manage this. But…

Go Has Garbage Collection

Garbage collection means Go automatically frees up memory that’s no longer in use. This is a huge win for developers—it reduces bugs, prevents memory leaks, and simplifies your code.

Example:

func foo() *int {
    x := 10
    return &x
}

func main() {
    ptr := foo()
    fmt.Println(*ptr)
}

In this article we talked about:

Use var or := to declare variables
Go types include int, float64, string, bool, and more
Pointers let you work with memory addresses
Scopes define where your variables live and how long they stick around
Go’s garbage collector handles cleanup for you, making your life easier

In the next article, we’ll start working with control structures like if, for, and switch, and start writing real logic in Go.

Until then—happy coding!

GoLang 101: Getting Started with Go

Kazem — Wed, 16 Jul 2025 05:53:29 +0000

Go, Why It’s Worth Your Time

Hey folks, If you’re curious about learning a new programming language, Go—also known as Golang—is definitely one to consider. Whether you’re a complete beginner or an experienced developer exploring new tools, Go offers a refreshing combination of speed, simplicity, and power.

In this post, I’ll walk you through why Go is unique, what makes it special, and how you can get started step-by-step.

Why Learn Go?

There are a lot of languages out there—Python, JavaScript, C++, Rust—the list goes on. So why Go?

1. It’s Fast
Go is a compiled language, meaning your code is turned into machine-level instructions before it runs. Unlike interpreted languages (like Python, PHP), compiled languages don’t waste time translating code while the program is running. That makes Go programs blazing fast.

2- Automatic Memory Management
One thing developers hate? Memory leaks. Go comes with built-in garbage collection, just like Python or Java, but with the performance of C-style languages. That means you don’t have to worry about manually allocating or deallocating memory, it’s done for you.

3- Simple but Powerful
Go isn’t trying to be flashy. In fact, it intentionally avoids some “fancy” features like inheritance or generics (although newer versions are introducing more generics support). That simplicity makes it easy to learn and use.

4- Built-in Concurrency
Want to write programs that do multiple things at once? Go’s concurrency model (with goroutines and channels) is one of its best features. It makes writing multi-threaded programs safe and intuitive.

How to Set Up Go on Your Machine

Let’s get you coding. Setting up Go is straightforward.

Visit go.dev:

Click the “Download” button. Choose the installer that matches your operating system (Windows, macOS, or Linux).

Install the Tools:

Run the installer. You’ll be guided through a simple setup wizard—just follow the steps and keep the defaults unless you have specific needs.

Congrats! You're done!

But wait! we still have a long way to go!

Set Up Your Workspace:

Although it's not forced but it's better to follow some structures on your go projects, Go expects your files to be organized in a specific way:

├── bin ## your Go source code
├── pkg ## compiled executable files
└── src ## compiled packages (dependencies)

Go uses an environment variable called GOPATH to locate your workspace. Usually, it’s set automatically during installation, but you can customize it if needed.

Writing Your First Go Program

Once Go is installed, let’s write a simple program.

You can simply open your code editor (I'm using vscode you can use any other editor) and create a file called main.go with the following content:

package main

import "fmt"

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

and run it with go run main.go it's super simple, but let's do it more better:

1 - Create a folder

mkdir go-starter
cd go-starter

2 - Starts a new Go module

go mod init

A Go module is basically your project and its dependency system — like: package.json in Node.js

3 - Prepare your workspace:

mkdir src bin pkg

4 - Now write the print code in src/main.go and run it:

Well done! You’ve just written your first Go program.

Understanding Packages and Code Organization

In Go, code is organized into packages. Every Go file starts with a package declaration. The main package is special, it’s where the program starts executing.

You also use the import keyword to include code from other packages. Go comes with a standard library (like fmt for formatting and printing) and you can also import third-party packages.

When working with bigger projects, organizing your code into packages helps keep things modular and reusable. It also makes it easier to collaborate with others.

Object-Oriented (Sort of)

Go doesn’t use classes or inheritance like traditional object-oriented languages. Instead, it uses structs (data containers) and methods to organize code. This gives you many benefits of OOP—like encapsulation—without the complexity.

You can attach methods to your structs, allowing you to define custom behaviors without bloated syntax.

Built-in Concurrency

Concurrency is where Go really shines.

With keywords like go (for starting goroutines) and chan (for communicating between tasks), Go makes writing concurrent code intuitive and safe. If you’re building web servers, real-time systems, or anything that needs to handle multiple tasks at once, this feature alone is worth learning Go.

Go is fast, efficient, easy to learn, and made for teamwork. Whether you’re building microservices, web apps, or CLIs, Go gives you the tools to build clean, scalable, and high-performing software.

If you’re just getting started, take your time. Follow my tutorials, play with small projects, and most importantly—enjoy the journey.

Happy coding! 🧑‍💻

Laravel101: A Practical Guide for Seeders and Factories

Kazem — Thu, 31 Aug 2023 08:09:57 +0000

During the development process, there are times when we need to evaluate the functionality of a system by using data. In Laravel, we have two useful tools called seeders and factories that help us generate random data. In this article, we’ll explore these tools and learn how to use them effectively.

The factory class in Laravel acts like a factory that generates random data for our database tables. If you navigate to the database/factories directory in your project, you’ll find a class called UserFactory:

class UserFactory extends Factory
{
    public function definition(): array
    {
        return [
            'name' => fake()->name(),
            'email' => fake()->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
            'remember_token' => Str::random(10),
        ];
    }
}

In each factory class, there is an important function called definition that specifies how each attribute should be filled out. To accomplish this, Laravel utilizes a powerful package called fakerPHP, which can generate random data such as names, sentences, paragraphs, and even images. You can find more information about the helper functions and features of this package at the following link.

FakerPHP / Faker

Documentation for FakerPHP / Faker

fakerphp.org

Another point in UserFactory class is that the string that is considered a fixed password is the hashed word “password”.

Laravel includes a variety of global helper PHP functions, and one of them is called Str. This helper function is useful for working with strings, such as generating random strings. You can refer to the documentation for this helper function at here.

Now, let’s get back to our project and generate a factory for our tags. To create a factory, we can use the following artisan command:

php artisan make:factory TagFactory

It’s generally recommended to use a singular name for factory classes. However, if you want to specify the model while generating the factory, you can use the “-m” option in the command, like this:

php artisan make:factory TagFactory -m Tag

In our Tag model, we only have a simple “name” attribute, which can be defined as follows:

use Illuminate\Database\Eloquent\Factories\HasFactory;

class Tag extends Model
{
    use HasFactory;
}

Once we have set up the factory, we can use it to create instances of our model. To do this, simply call the factory method whenever you want to create a model instance.

You can also control the number of random data entries you want to generate. You can achieve this by using either the factory function or the count function. For example, if you want to create 5 random tags, you can use the following code:

Tag::factory(5)->create();

Furthermore, it’s possible to define a specific attribute with a desired value while generating the data. For instance, if you want to create 5 users with the name “test,” but you don’t care about the other attributes, you can use the following code:

User::factory(5)->create(['name' => 'test']);

In our project, we currently have two factories for our user and tag models. Now, we need to create another factory for our task model.

When defining the factory model, it is important to consider the relational model. In our task model, each task is associated with a user. So, what we want to achieve is creating a random task with the id of a given user.

However, during testing your application, there might be situations where no user has been created in the environment. In such cases, generating a random user could be a viable solution. To accomplish this, you can use factory model again just like bellow:

public function definition(): array
{
    return [
        "title" => fake()->sentence(),
        "description" => fake()->paragraph(),
        "expired_at" => fake()->dateTimeThisMonth(),
        "user_id" => User::factory(),
    ];
}

If you run the code in Tinker, you will notice that a new user has been created for the task model.

Also we have the option to specify a user_id when generating a task. However, I suggest refactoring the code to utilize the users that are likely to already exist in database:

public function definition(): array
{
    return [
        "title" => fake()->sentence(),
        "description" => fake()->paragraph(),
        "expired_at" => fake()->dateTimeThisMonth(),
        "user_id" => User::query()->inRandomOrder()->first()?->id ?? 
           User::factory(),
    ];
}

To generate random data more efficiently in Laravel, we have a better solution than using Tinker. It’s called a seeder.

In the database/seeders directory, you will find a class named DatabaseSeeder, which allows us to manage the generation of random data.

Let's update the DatabaseSeeder class as shown below, and then execute an artisan command to run this function.

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        Task::factory()->create();
    }
}

And here is the artisan command for seeding:

php artisan db:seed

That’s it!

With Seeder, we can easily create a random task record in our database using artisan. Additionally, we have the flexibility to create multiple seeders for different scenarios. To create a seeder, you simply need to run php artisan make:seed <seeder-name> command.

Now, let’s create a TaskSeeder that generates 5 random task records, with each task associated with two random tags:

namespace Database\Seeders;

use App\Models\Tag;
use App\Models\Task;
use Illuminate\Database\Seeder;

class TaskSeeder extends Seeder
{
    public function run(): void
    {
        Task::factory(5)->hasTags(2)->create();
    }
}

To run this seeder, you can use the artisan command by specifying your desired seed class.

php artisan db:seed TaskSeeder

Or you can use call method inside DatabaseSeeder to execute your seed classes:

class DatabaseSeeder extends Seeder
{
    public function run(): void
    {
        $this->call(TaskSeeder::class);
    }
}

Initial data model

Well, sometimes there are certain values that are need to be initialized, such as the status of an article (e.g., published or draft) or the status of a transaction (e.g., paid or non-payment).

I want to apply a similar approach to tags in this project. We have a couple of options to achieve this.

One option is to store the initial values in a configuration file. To do this, we can create a PHP file called “defaults” at the specified config path and define the desired values there:

<?php

return [
    'tags' => ['php', 'laravel', 'develop', 'backend']
];

We can then initialize these values using a migration file.

Alternatively, we can initialize these values using a seeder. This means we would define a seeder like TagSeeder that populates the default value in the database.

Both approaches work, but I prefer to use seeder because it’s more clear:

Let’s define TagSeeder and initialize it’s values:

class TagSeeder extends Seeder
{
    public function run(): void
    {
        foreach (config('defaults.tags') as $value) {
            Tag::firstOrCreate(['name' => $value]);
        }
    }
}

As you can see, the helper function config in Laravel is utilized to retrieve static information from config files.

Here I use firstOrCreate method which adds a new tag record only if it hasn’t been previously added.

Great! Now, let’s all come together and work on implementing a scenario like the one described below inside our TaskSeeder:

namespace Database\Seeders;

use App\Models\Tag;
use App\Models\Task;
use App\Models\User;
use Illuminate\Database\Seeder;

class TaskSeeder extends Seeder
{
    public function run(): void
    {
        // create a user with specified credentials
        $user = User::factory()->create(['email' => 'test@test.dev']);

        // init tag with defined value
        $this->call(TagSeeder::class);

        // create 5 random tasks for the user
        $tasks = Task::factory(5)->create(['user_id' => $user->id]);

        // assosiate each generated tasks with 2 predefined tags
        foreach ($tasks as $task) {
            $tags = Tag::query()->inRandomOrder()->take(2)->pluck('id');
            $task->tags()->attach($tags);
        }
    }
}

Now let’s rebuild our database and fill it with this defined seeder. To rebuild the database you can run migrate:fresh artisan command which will drop all tables and re-run all of your migrations:

And if you login with the user you’ll see the tasks generated successfully:

I hope this explanation clarifies the process of using seeders and factories in Laravel. If you have any further questions, feel free to ask!

Laravel101: Exploring Efficient Task Management with Many-to-Many Relationships and Tags

Kazem — Mon, 28 Aug 2023 08:23:36 +0000

Great to have you back! In our previous article, we talk about associating different models and defining relationships within our Laravel application. The best part is that now every user in our project can have personalized tasks.

In this new article, we’re going to take things a step further and explore the many-to-many relationship. We’ll introduce a brand new model called tags, which will enable each task in our application to have multiple tags.

But wait, there’s more! In this article, we're also going to create a fantastic search select blade component, designed to make working with tags inside our forms. So get ready, because we’re about to dive into some seriously exciting stuff!

Create a search select input in blade

Now, let’s talk about a new feature I’ve decided to add: a search select input for adding and selecting tags within the task forms. There might be some packages available that can help with this in the application, but let’s start by implementing it using pure JavaScript.

So, let’s begin!

First, I created a simple input component for searching text, located in the common directory of our blade components. Then, I added this input component to our create tasks view, as shown in the following picture:

Now, if we want to work with pure JavaScript within our common input, we usually need to define all the JavaScript functions within our app.js inside resources/js directory. However, there’s a more convenient way to do this that I prefer, and that is by using a stacked scripts. To achieve this, we have another helpful function within the blade syntax called push. You can use it like this:

@push('scripts')
<script type="module">
    // Your JavaScript code goes here
</script>
@endpush

By using this syntax, you can define your script inside the @push('scripts') and @endpush tags, and it will be treated as a module. This makes it easier to manage and organize your JavaScript code within your application.

However, right now these scripts won’t work. In order to bring them to life, we need to add the stacked scripts inside our main layout:

Now if you open your console inside your browser you’ll see that our script works:

Right now, the first step is to listen to every change and character that the user enters in the input field. To achieve this, you need to assign an event listener to the input element.

To see this in action, you can add the following code snippet to your scripts. When you run it, you’ll notice that every character you enter in the input will be logged to your console:

@push('scripts')
<script type="module">
    let tagSearchInput = document.getElementById("search-tag");

    tagSearchInput.addEventListener("input", async function (e) {
        console.log(tagSearchInput.value);
    });
</script>
@endpush

Now, let’s move on to the next step, which is finding all the tags based on the search input.

But wait we don’t even define our tag model inside our application! It’s actually quite simple! All you need to do is run the following command, and it will take care of creating the model, migration, and controller for you:

php artisan make:model Tag -mc

This model is straightforward because it only has one attribute, which is the name. So, update the migration file by adding a simple name column. Similarly, update the request file as shown below:

Finally, let’s move back to the controller because this is where the new things happen, and we need to work on it.

First, let’s utilize our index function in a slightly different way. Instead of simply listing all the tags in the view, we’ll modify it to return a JSON response. This will allow us to retrieve all the data in our JavaScript code:

public function index()
{
   return response()->json([
        'tags' => []
   ]);
}

Then we need to search inside our tags records to find tags based on searching input. To accomplish this, we can utilize a commonly used syntax in Laravel for searching within model. Laravel provides a useful function called where() that allows us to retrieve specific records from our database tables based on specific attributes or columns.

For instance, if we want to find a tag where its name is “job”, the query would look like this:

$tag = Tag::where('name', 'job')->get();

Don’t forget to use get() at the end to execute the SQL command.

Now, what if we want to find all the tags that have a name containing the specified letter or letters? Here we use LIKE as a 2nd parameter and % at the beginning and end of our search key. For instance:

# all tags start with a 's'
$tags = Tag::where('name', 'LIKE', 's%')->get();

# all tags end with a 's'
$tags = Tag::where('name', 'LIKE', 's%')->get();

# all tags contains a 's'
$tags = Tag::where('name', 'LIKE', '%s%')->get();

So our index function could be look like bellow:

public function index()
{
    $query = Tag::where('name', 'LIKE', "%" . request('name') . "%")->get();
    return response()->json($query);
}

That’s it! By using this syntax, we can easily search and retrieve the desired tags from our database.

Now Lets define the new route:

Route::get('tags', [TagController::class, 'index'])->name('tags.search');

As you see in following pic I just add some sample data and make a request:

Well, let’s see how we can use it in JavaScript. To make the HTTP request, we can use a popular package called Axios. The good news is that Axios is already installed by default in Laravel. However, if you don’t have it, you can easily install it using the following command:

npm install axios

Once you have Axios set up, let’s go back to our JavaScript code and make the request:

let tagSearchInput = document.getElementById("search-tag");

tagSearchInput.addEventListener("input", async function (e) {
    const response = await axios.get(`/tags?name=${tagSearchInput.value}`);
    console.log(response.data);
});

First, Let me explain what “async” and “await” mean in the code. In simple word, think of them as listeners that wait for the result of a request at a specific line.

Now, we need to display the list of results from our query. To achieve this, we can add an HTML element and populate the list with all the found items.

<script type="module">
    let tagSearchInput = document.getElementById("search-tag");
    let tagSearchList = document.getElementById("search-tag-list");

    tagSearchInput.addEventListener("input", async function (e) {
        const response = await axios.get(`/tags?name=${tagSearchInput.value}`);

        if (response.data.length) {
            tagSearchList.classList.remove("hidden");

            // remove all item inside list
            while (tagSearchList.firstChild) {
                tagSearchList.removeChild(tagSearchList.firstChild);
            }

            // add found tags inside the list
            response.data.forEach((tag) => {
                let li = document.createElement("li");
                li.appendChild(document.createTextNode(tag.name));
                li.className = "tag-list-item";
                // todo: uncomment after add tagSelected()
                // li.onclick = () => tagSelected(tag);
                tagSearchList.appendChild(li);
            });
        } else tagSearchList.classList.add("hidden");
    });
</script>

The process involves iterating through the results. If there is any data, our item list is displayed, and we append a list of found tags to our search list.

Now, we need to implement click functionality for each tag item in the list. When a tag item is clicked, its tag id should be appended to a designated input field. This input field has a specific id, such as tags-select and its purpose is to store the selected tags within our form. We will utilize this input field when submitting the selected tags along with the task creation.

To achieve this, I have added three HTML elements as shown in the picture. The first element is an input field with the id tags-select, The second element is an unordered list (ul) which serves as the parent container for our search result tags that are listed. The third element is a div that visually represents the currently selected tags.

Next, when a user clicks on a tag item in the list, we want to perform the following actions:

Create and append an element that represents the selected tag to the tags-select-list Additionally, we add a close button element, which we will later implement its functionality.
Trigger another function that updates our tags-select input field by adding the id of the selected tag.
Hide the dropdown list that displays the search results.
Finally, clear the tag search input element to prepare it for adding another tag.

Here is the function that handles the click event for each listed tag:

const tagSelected = (tag) => {
    let span = document.createElement("span");
    span.id = tag.id;
    span.className = "tag-select-item";

    let closeBtn = document.createElement("i");
    // todo: uncomment after add removeSelectedTag()
    // closeBtn.onclick = () => removeSelectedTag(span);
    closeBtn.appendChild(document.createTextNode('×'));

    span.appendChild(closeBtn);
    span.appendChild(document.createTextNode(tag.name));

    tagSelectWrap.appendChild(span);
    tagSearchList.classList.add("hidden");

    tagSearchInput.value = "";
    tagSelectInput.value = inputTag(parseInt(tag.id));
}

And this is the function that updates our tags-select input field:

function inputTag(tagId) {
    let tags = tagSelectInput.value.length
        ? JSON.parse(tagSelectInput.value)
        : [];
    if (tags.includes(tagId)) {
        const indexToRemove = tags.indexOf(tagId);
        tags.splice(indexToRemove, 1);
        tags = JSON.stringify(tags);
    } else {
        tags.push(tagId);
        tags = JSON.stringify(tags);
    }
    return tags;
}

Here we have to convert array of selected tags id to string since our input accept string value.

Now, let’s discuss the functionality for removing selected tags. When a user clicks on the close button, the corresponding element needs to be removed from both the tags-select-list and our input field. Here is the code for the removal functionality:

const removeSelectedTag = (el) => {
    tagSelectInput.value = inputTag(parseInt(el.id));
    tagSelectWrap.removeChild(el);
}

Amazing let see our fantastic result:

The final step is to implement the functionality for adding a new tag when the user presses Enter and the entered tag is not found in our existing records. In this case, we will send the entered tag to the server and store it as a new tag. As a result, we will repeat the entire process of clicking on a list item for the newly added tag.

To add a new tag, you simply need to include a store function inside the tag controller. Here is how the store function can be implemented:

public function store(StoreTagRequest $request)
{
    $tag = Tag::create($request->validated());
    return response()->json($tag);
}

To ensure that everything is set up correctly, please make sure to add the appropriate route and a simple StoreTagRequest class. We have covered this step earlier, and it is relatively straightforward.

Now let’s return to our search select input and handle the Enter key events. First, we need to check if there are no tags in our records. If there are no existing tags, we will proceed to store a new tag using the following steps:

tagSearchInput.addEventListener("keydown", async function (e) {
    if (e.key === "Enter") {
        e.preventDefault();

        const response = await axios.get(
            `/tags?name=${tagSearchInput.value}`
        );

        if (!response.data.length) {
            const { data } = await axios.post("/tags", {
               name: tagSearchInput.value
            });
            tagSelected(data);
        }
    }
});

Now, we have the exciting capability of adding new tags within our app! Isn’t that amazing?

Well, Let’s return to the task creation process. Here, we simply need to retrieve the entered tags from the input fields when the request is sent.

let’s proceed with updating our askStoreRequest to include selected tags:

public function rules(): array
{
    return [
        'title' => 'required|min:3|max:120',
        'description' => 'nullable|min:3|max:255',
        'expired_at' => 'nullable|date|after:now'
    ];
}


public function validated($key = null, $default = null)
{
    if ($key == 'tags') return json_decode(request('tags'));

    return $this->validator->validated();
}

I have just refactored the validated method to convert a string of ids into an array of IDs (We cannot merge because merging could lead to conflicts, as there is no column named “tags” inside the tasks model).

Now, let's test its functionality by using two given tags.

That’s it!
Store a Task with given tags

Now how to relates this tags to our tasks?

As I mentioned before, we need a way to manage the relationship between tags and tasks. In a previous article, we discussed this topic you can find out here:

Laravel101: Exploring Entity-Model Relationships

Kazem ・ Aug 22 '23

#laravel #php #relational #eloquent

To define the relationship between tags and tasks, we’ll need another table that will record all the connections between these models. This middle table will have two main attributes, and those are the id of each model.

So, let’s get started and define the table using a migration:

php artisan make:migration create_tag_task_table

And this is our migration setup:

Schema::create('tag_task', function (Blueprint $table) {
    $table->foreignId('tag_id')->constrained()->cascadeOnDelete();
    $table->foreignId('task_id')->constrained()->cascadeOnDelete();
});

Right now we need to define relation function for both model that is is incredibly useful and includes many helpful functions that make working with relations in Laravel models straightforward. For both models, we need to declare that each model belongs to the other one.

class Task extends Model
{
    public function tags()
    {
        return $this->belongsToMany(Tag::class);
    }

    // ...
}


class Tag extends Model
{
    public function tasks()
    {
        return $this->belongsToMany(Task::class);
    }

    // ...
}

Let’s back to our controller where we need to define relation between created task and selected tags, Here we will use another function call attach just like bellow:

public function store(StoreTaskRequest $request)
{
    $task = auth()->user()->tasks()->create($request->validated());

    $task->tags()->attach($request->validated('tags'));

    return redirect("/tasks", 201);
}

As you notice after selecting some tags and post store request to server you will notice that a created task is associated with the chosen tags.

Update a task’s tags

Now what’s about updating tags for a given task,

The main requirement is to enable the select input using the provided tags. Fortunately, in the Laravel blades, there is a useful feature called “props” that allows for the insertion of variables within components. In our project, we need to define a tags variable, with a default value of null. This will allow us to utilize the component effectively:

@props([ 'tags' => null ])

Then we need to add selected tags to tags-select input:

<input 
  type="text" 
  name="tags"
  id="tags-select" 
  value="{{ isset($tags) ? $tags->pluck('id') : ''}}"
  hidden
>

And show selected tags inside our tags-select-list :

<div class="flex flex-wrap space-x-1" id="tags-select-list">
    @forelse($tags ?? [] as $tag)
        <span id="{{ $tag->id }}" class="tag-select-item">
          <i>×</i>{{ $tag->name }}
        </span>
    @empty
    @endforelse
</div>

As you can see, the forelse is used in cases where there may be an empty list. You can also use a simple foreach loop along with an if statement, but the forelse provides a simpler alternative.

Now, you can use this component into our edit view. When you do so, you will notice that all the selected tags are displayed correctly. However, there is one small thing that still needs to be addressed: the closing functionality for these tags.

In this situation, all we need to do is search within our list. If any span elements are found, we can assign the close handler function to the close button. This process is straightforward, and you can refer to the following code to implement it:

// Get all the tags inside the parent element add close event
[...tagSelectWrap.getElementsByTagName('span')].forEach(spanTag => {
    spanTag.getElementsByTagName('i')[0].onclick = () => removeSelectedTag(spanTag);
})

That’s it!

Then I add our search components into the task edit view, and refactor our update method as bellow:

Now if we add an additional task and make updates, you will notice that not only will new tags be added, but the last attached tags will also be attached again.

One possible solution is to first detach all previously attached tags and then attach them all together. However, another option is to use a helper function called sync which handles the entire process in one step:

// option 1:
$tags_id = $task->tags()->pluck('id');
$task->tags()->detach($tags_id);
$task->tags()->attach($request->validated('tags'));

// option 2:
$task->tags()->sync($request->validated('tags'));

That’s it Let’s see the result:

We’ve just completed an incredible and extensive article that covers a wide range of topics, including the fascinating realm of many-to-many relationships. In addition, we introduced a brand new model called “tag” and and establish a relationship between user tasks and the associated tags. To enhance the user experience, we even developed blade components specifically designed to manage tags within our forms.

And again this is the repo of our project. Throughout this series of materials, we’ll be taking gradual steps to transform it into a fully functional application.

Happy coding!

Laravel101: Exploring Entity-Model Relationships

Kazem — Tue, 22 Aug 2023 03:11:56 +0000

Up until now, we’ve built an awesome app that lets users save tasks. But now, we want to take it a step further and save each user’s tasks individually. That means each user will have their own set of tasks. And of course, we’ll make sure to relate the tasks with the current user who’s logged into the app. So, they’ll have easy access to the their tasks. Sounds cool, right?

Relational Database Management Systems (RDBMS) are a type of database management system that work based on relationships. Basically, data and relationships are organized using a set of related tables. Many popular DBMSs like SQLite, MySQL, and Microsoft Access follow this structure.

Now, talking about different types of database management structures is beyond the scope of this article. However, if you’re curious and want to explore more about the various types of DBMS, you can check out the following link:

Types of Databases

There are multiple types of databases, such as relational database management systems, object databases, graph databases, network databases, and document db. In this article, we discuss the types of Database Management Systems or DBMS.

c-sharpcorner.com

Alright, let’s dive into the topic of defining relationships in models.

When it comes to table relationships, the main ones we encounter are one-to-many and one-to-one. In a one-to-one relationship, each record in one table is linked to just one record in another table. For instance, think of the connection between a student’s and their account details:

On the other hand, in a one-to-many relationship, each record in one table can be associated with multiple records in another table. Take a peek at the image below:

you’ll notice that each customer can have several orders, but each order belongs to only one customer.

And hey, let’s not forget about another type of relationship called many-to-many. To handle this, we convert it into two one-to-many relationships using an interface table. Check out the image below:

you’ll see a many-to-many relationship between the courses and students tables, which we’ve transformed using an interface table with two one-to-many relationships.

In our example, each user is associated with their own set of tasks.

Here’s how it works: a user can have multiple tasks, but each task belongs to only one user. So, to make this happen, we need to update our tasks model migration file and introduce a new attribute called foreignId. This attribute will be responsible for storing connection between a user to the task.

To establish this connection, we can use any unique data from users table. In our design, we have options like email and ID.

Here’s a helpful tip: in relational databases, we often use the ID since it optimized retrieval of related models.

Let’s update our migration file and add foreignId :

Schema::create('tasks', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('description')->nullable();
    $table->foreignId('user_id')->constrained();
    $table->timestamp('expired_at')->nullable();
    $table->timestamps();
});

As you might have noticed, I’ve used a handy function called constrained here. Its main purpose is to establish a relationship between models in a table. This function adds extra information to attributes, such as the related model’s table name. In this case, the related model is the users table.

You can actually specify the table name explicitly like constrained('users') but this function is smart enough to figure it out automatically based on the foreignId attribute name.

Now we update our migration file let update our tables:

php artisan migrate:fresh --force

Well done! Now, let’s talk about how we can actually use this in our project.

In Laravel, Eloquent provides some handy helper functions to define relationships. In our case, since the task model belongs to a user, we can simply define the belongsTo function in tasks model:

class Task extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

On the other hand, for our user, which can have many tasks, we can use the hasMany function:

class User extends Authenticatable
{
    public function tasks()
    {
        return $this->hasMany(Task::class);
    }
}

Of course we doesn’t have many-to-many in our project yet, but let’s talk about this exciting relationship. The good news is that it’s simpler for both models! We only need to use the belongsToMany function for both of them. These functions are usually all we need to define relationships. But if you’re looking for more detailed explanations, you can find them right here:

Eloquent: Relationships - Laravel 10.x - The PHP Framework For Web Artisans

Laravel is a PHP web application framework with expressive, elegant syntax. We’ve already laid the foundation — freeing you to create without sweating the small things.

laravel.com

These functions have some really handy applications. Let’s say we have a task and we want to know the name of the user who created it. In this case, here’s how we can tackle it:

$task = Task::find(1);
$task->user->name;

Here’s the thing you should know: In our Task model, we’ve got this cool function called “user” defined. Now, you might be wondering why we’re using it as an attribute, without those parentheses.

Well, let me explain. When we treat these functions as attributes, it’s almost like we’re directly referring to the user model itself using a query. That’s why we can easily access attributes like the user’s name. It’s a convenient way to get the information we need right away!

Let’s practice it with tasks function:

As you see in above pic you can find all the relevant models for a specific user or perform any query on the task models that are associated with that particular user.

Now, let’s back to our task controller and update the store function. The goal is to create a new task for the current user and set the user ID attribute. We can achieve this in a very direct way with the following code: (auth()->id() get current logged in user id):

$task = new Task();
$task->title = request('title');
$task->descripton = request('descripton');
$task->expired_at = request('expired_at');
$task->user_id = auth()->id();
$task->save();

However, let me introduce you to an even cooler option using the tasks function. This approach offers some amazing benefits. Check it out:

public function store(StoreTaskRequest $request)
{
    auth()->user()->tasks()->create($request->validated());
    return redirect("/tasks", 201);
}

Here the foreign id of user is handled by tasks

That’s awesome! Now, let’s update our index function to retrieve all the tasks associated with the currently logged-in user. It’s really simple. Just update the index function like this:

public function index()
{
    return view('tasks.index', ['tasks' => auth()->user()->tasks]);
}

Also we can make use of the auth functions in Blade templates to directly access the tasks of the current user. This means we can remove the task variable passing from the index function. Instead, we can fetch all the tasks within the Blade template itself. It’s super convenient!

In this article, we’ve covered the relationships between users and tasks models in Laravel. The information we discussed is not only important but also highly practical. Mastering complex queries is a key skill for anyone working in the backend. I hope you found this tutorial enjoyable and insightful.