But there was always a nagging feeling, an imposter syndrome hovering in the background. I knew how to call the functions, but I didn’t truly understand why they worked. I was building a mental skyscraper on a foundation of sand. When things broke, or when I wanted to move beyond canned tutorials, I hit a wall. I realized something crucial was missing: the deep, intuitive understanding of the mathematics underneath the code.

My ultimate ambition is high: I want to work on cutting-edge AI at a place like Google DeepMind. To get there, "good enough" isn't good enough. I needed to stop, rewind, and build the foundation properly.

The Map: Mathematics for Machine Learning

I decided to tackle the definitive textbook: Mathematics for Machine Learning by Deisenroth, Faisal, and Ong. My goal is to internalize the "grammar" of ML before writing more "paragraphs" of code.

Today, I’m celebrating a significant milestone: I have completed Chapter 2: Linear Algebra. (The book starts counting content at Ch. 2).

This wasn't just about memorizing formulas. It was a journey from computation to intuition:

1. The Mechanics: It started with the nuts and bolts, what is a matrix, how does multiplication work, and solving systems of linear equations using Gaussian elimination.

2. The Structure: Then, we moved into the abstract, vector spaces, subspaces, and bases. Understanding where these mathematical objects live.

3. The Breakthrough (Linear Mappings): This was the most critical shift. I stopped seeing matrices as just static grids of numbers and started seeing them as active transformations, machines that stretch, rotate, and squash vectors from one coordinate system to another.

Understanding that matrix multiplication is essentially a transformation of space is a game-changer for visualizing what neural networks are actually doing.

$$\begin{bmatrix} a & b \\ c & d \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = x \begin{bmatrix} a \\ c \end{bmatrix} + y \begin{bmatrix} b \\ d \end{bmatrix} = \begin{bmatrix} ax + by \\ cx + dy \end{bmatrix}$$

The Strategy: How I Stay Consistent

Math is hard. Self-studying math is even harder. Relying solely on willpower doesn't work for long-term goals like this. I needed a system.

My routine relies on a few key pillars to keep the momentum going:

• The Pomodoro Technique: I break my study sessions into focused intervals. It prevents burnout and keeps my brain fresh for dense topics like null spaces and affine subspaces.

• Virtual Accountability (James Scholz): Studying alone can be isolating. I sync my sessions with James Scholz’s "Study With Me" streams on YouTube. There is a powerful, unspoken motivation in working alongside thousands of others, even virtually.

• Daily Inspiration (5amoljen): Following accounts like 5amoljen on Instagram provides that necessary jolt of daily discipline. Seeing others wake up early and grind reminds me that the work needs to be done, regardless of how I feel.

What’s Next

Clearing the Linear Algebra chapter feels great, but I’m not rushing to the next topic yet. Knowledge without application fades quickly.

My next step is to dive into the practice problems in the book. I need to prove to myself that I can apply these concepts, calculating ranks, finding kernels, and performing changes of basis, before moving on.

Once I’m confident, I will begin Chapter 3: Analytic Geometry, where we will add lengths, angles, and distances to the vector spaces I just learned about.

The journey to DeepMind is long, and I'm still near the starting line. But for the first time, I feel like I’m running on solid ground.

For this project-based learning session, I decided to build something practical: a backend API to handle image uploads and store them locally.

Here’s the high-level process:

1. User uploads an image and metadata (like title and description) from the frontend via multipart/form-data.

2. The data is sent to an exposed API endpoint.

3. The server parses the request, validates the file, and stores it.

Project Structure

I wanted the codebase to be simple but easy to scale, so I split it into cmd and internal folders:

image-api/
    cmd/
        server/
            server.go
    internal/
        handlers/
            handlers.go
        utils/
            utils.go

• cmd/server/server.go – Entry point. Sets up the HTTP server, defines API endpoints, and handles CORS.

• internal/handlers/handlers.go – Contains handler functions for each API route.

• internal/utils/utils.go – Utility functions (like file type validation).

Setting Up the Server (server.go)

package main

import (
    "image_api/internal/handlers"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/image-upload", withCORS(handlers.HandleImageUpload))
    http.HandleFunc("/delete", withCORS(handlers.HandleImageDelete))
    http.HandleFunc("/update", withCORS(handlers.HandleImageUpdate))
    http.HandleFunc("/image", withCORS(handlers.HandleImageUpdate))

    log.Println("Listening on port: 8282")
    err := http.ListenAndServe("localhost:8282", nil)
    if err != nil {
        log.Fatal(err)
    }
}

func withCORS(h http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
        h(w, r)
    }
}

The withCORS wrapper ensures requests from different origins don’t fail with CORS errors — essential when connecting your API to a frontend.

Handling Image Uploads (handlers.go)

The heart of the project is the image upload handler:

func HandleImageUpload(w http.ResponseWriter, r *http.Request) {
    // Limit upload size to 10MB
    err := r.ParseMultipartForm(10 << 20)
    if err != nil {
        http.Error(w, "File is too big or invalid format", http.StatusBadRequest)
        return
    }

    // Retrieve the file from form data
    file, handler, err := r.FormFile("file")
    if err != nil {
        http.Error(w, "Could not read file", http.StatusBadRequest)
        return
    }
    defer file.Close()

    // Validate file type
    fileBytes, err := io.ReadAll(file)
    if err != nil {
        http.Error(w, "Invalid file", http.StatusBadRequest)
        return
    }
    if !utils.IsValidFileType(fileBytes) {
        http.Error(w, "Invalid file type", http.StatusUnsupportedMediaType)
        return
    }

    // Get additional form fields
    title := r.FormValue("title")
    description := r.FormValue("description")

    uploadDir := `C:\Users\USER\GolandProjects\image_api\uploads`
    if err := os.MkdirAll(uploadDir, 0755); err != nil {
        http.Error(w, "Could not create upload directory", http.StatusInternalServerError)
        return
    }

    // Save file to disk
    filePath := filepath.Join(uploadDir, handler.Filename)
    dst, err := os.Create(filePath)
    if err != nil {
        http.Error(w, "Could not save file", http.StatusInternalServerError)
        return
    }
    defer dst.Close()
    io.Copy(dst, bytes.NewReader(fileBytes))

    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "Uploaded: %s\nTitle: %s\nDescription: %s", handler.Filename, title, description)
}

Key points:

• Size limit prevents huge uploads from consuming memory.

• File type validation ensures only images are accepted.

• os.MkdirAll guarantees the upload directory exists.

• Metadata capture allows storing more than just the image.

Utility Functions (utils.go)

func IsValidFileType(file []byte) bool {
    fileType := http.DetectContentType(file)
    return strings.HasPrefix(fileType, "image/")
}

This small function makes sure the uploaded file really is an image — no disguised .exe files slipping in.

Running the API

1. Clone or create the project.

2. Run:

    go run ./cmd/server
   

3. Send a request via Postman or a frontend form with:

   • File field: file

   • Metadata fields: title, description

With this small project, I not only learned about Go’s net/http package but also got comfortable with handling multipart/form-data, file validation, and CORS.
It’s a solid first step toward building more complex APIs in Go.

Image of military personnel and data analytics interface

This is exciting news for fans eager to jump back into the action. While details on specific gameplay features are still emerging, the preorder availability signals a significant step toward the game's release. Keep an eye out for more information about different editions and their exclusive bonuses as they become available.

Key takeaways that resonated with me:

💡 Community & Collaboration

One of the standout moments was connecting with incredible minds in tech, including several professionals I've long admired. A powerful reminder came from a keynote speaker: "If you want to go fast, work alone; but if you want to go far, work with a team." This perfectly captures the essence of what I learned about the tech community's collaborative spirit.

🔍 Building Developer Relations

We delved into strategic approaches for fostering developer relationships, focusing on three critical pillars:

• Identifying clear goals

• Understanding your target audience

• Measuring impact and iterating based on successes and failures

🤖 AI Beyond Chatbots

The AI breakout sessions were particularly enlightening. It was refreshing to explore AI applications beyond the typical chatbot use cases, discovering innovative solutions to real-world challenges. This session expanded my perspective on AI's potential impact across various sectors.

🎯 Moving Forward

This experience has ignited a dual mission: developing my technical skills while contributing to our campus tech community's growth. While I feel challenged by the road ahead, I'm incredibly motivated by the possibilities.

As I look toward DevFest 2025, I'm excited to measure my growth and continue this journey in tech. A huge thank you to the organizers and everyone who made this event unforgettable!