DEV Community: Jotham Ntekim

CineAgent: Bridging the Web and Conversational AI with a Concurrent Go ETL

Jotham Ntekim — Fri, 06 Feb 2026 11:37:39 +0000

Search engines are only as good as the data you feed them. For the Algolia Agent Studio Challenge, I wanted to build more than just a chatbot; I wanted to build a living pipeline.

Introducing CineAgent, a voice-powered cinema concierge grounded by Trawl—a custom-built, high-concurrency ETL engine written in Go.

🚀 The Vision: Beyond Static Data

Most AI agents are limited by their training data or static JSON uploads. CineAgent is different. It uses a "Trawler" approach to bridge the gap between unstructured web content and conversational discovery.

The project solves three specific problems:

Data Freshness: Trawl (the backend) can scrape and index thousands of records concurrently.
Grounding: The AI Agent is strictly grounded in a curated index of 250+ cinematic masterpieces.
The "Empty State" Problem: In standard search, "No Results" is a dead end. In CineAgent, "No Results" is the beginning of a conversation.

🛠 The Tech Stack

The Engine (Trawl): Built with Go, utilizing Goroutines and Channels for high-concurrency web scraping and batch indexing via the Algolia Go API Client v5.
The Brain: Algolia Agent Studio, configured as a "Film Discovery Expert" to handle complex, natural language queries.
The Face: A React frontend styled with Chakra UI v3 for a premium, immersive dark-mode experience.
The Interaction: Web Speech API for hands-free discovery and the Algolia InstantSearch Chat Widget (Beta).

💡 Key Features & Originality

1. The Trawl ETL Pipeline (Go)

While most participants might upload a static file, I built an ETL (Extract, Transform, Load) engine. Trawl follows a concurrent worker-pool pattern. It scrapes metadata (Title, Year, Rating, High-res posters), normalizes it into Go structs, and pipes it into Algolia in optimized batches.

2. The Hybrid "Voice-to-Agent" UI

I implemented a "NoResultsBoundary" logic. If the local search grid can't find a specific niche movie, the UI doesn't just show an error. It proactively invites the user to "Ask CineAgent AI," handing off the search query to the conversational agent.

3. Voice-First Discovery

Users can click the microphone icon to search. If the voice input is a short keyword (e.g., "Inception"), the movie grid updates. If the input is a complex question (e.g., "What is the best sci-fi movie from the 90s?"), CineAgent opens the conversational chat automatically.

📺 Demo & Visuals

Live URL: trawl-ui.vercel.app

![Image Description: A sleek dark-mode movie library with a floating AI Assistant bubble.]

🧠 Lessons Learned

Integrating a Beta widget like the Algolia Chat component into a modern React 18 / Chakra UI v3 environment was a challenge in state management. I learned that isolating the AI handshake from the main search lifecycle is key to maintaining a responsive, "hang-free" user experience.

🔗 Links

GitHub Repository:

Frontend (UI)
github.com/ntekim/trawl-ui
Backend
github.com/ntekim/trawl

Algolia Agent ID: 4ddf0636-38b2-4578-a98f-8715efde81ca

algoliachallenge #devchallenge #agents #webdev #golang #react

Linux User Creation Bash Script

Jotham Ntekim — Wed, 03 Jul 2024 16:32:47 +0000

Hey guys, been a while since my last article on Network Programming Series. While I'll very much start writing soon and continue the next article on the series, let me quickly walk you through how I did my HNG stage 1 task.

HNG is a set of program designed for intermediate to advanced learners who want to rapidly move forward in their career - and end up in jobs in the best international companies. To achieve their mission of enhancing the skills of developers and make them Job ready, they arranged a 2-month transformative internship, widely known as HNG INTERNSHIP.

As part of the custom, we're to complete a task every week to move up the stages and I guess this is me about to walk you through how I did my Stage 1 task.

Task Description

Your company has employed many new developers. As a SysOps engineer, write a bash script called create_users.sh that reads a text file containing the employee’s usernames and group names, where each line is formatted as user;groups.

The script should create users and groups as specified, set up home directories with appropriate permissions and ownership, generate random passwords for the users, and log all actions to /var/log/user_management.log. Additionally, store the generated passwords securely in /var/secure/user_passwords.txt.

Requirements

Each User must have a personal group with the same group name as the username, this group name will not be written in the text file.
A user can have multiple groups, each group delimited by comma ","
Usernames and user groups are separated by semicolon ";"- Ignore whitespace e.g. light; sudo,dev,www-data idimma; sudo mayowa; dev,www-data
For the first line, light is username and groups are sudo, dev, www-data

My Solution

//create_users.sh file
#!/bin/bash //add this to the top of the file to indicate how it should be interpreted

# Check if the user list file is provided as an argument
if [ $# -ne 1 ]; then
  echo "Usage: $0 <user_list_file>"
  exit 1
fi

# Define the user list file from the argument
USER_FILE="$1"

# Check if the user list file exists
if [ ! -f "$USER_FILE" ]; then
  echo "User list file $USER_FILE not found!"
  exit 1
fi

LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.txt"

# Ensure the log and password files exist
sudo touch $LOG_FILE
sudo chmod 666 $LOG_FILE
mkdir -p /var/secure
sudo touch $PASSWORD_FILE
sudo chmod 666 $PASSWORD_FILE

# Function to generate a random password
generate_password() {
  < /dev/urandom tr -dc 'A-Za-z0-9!@#$%^&*()_+=' | head -c 12
}

# Read the user file
while IFS=';' read -r username groups || [ -n "$username" ]; do
    if id "$username" &>/dev/null; then
        echo "User $username already exists." | tee -a $LOG_FILE
    else
    # Create the user with a home directory
    sudo useradd -m -s /bin/bash "$username"
    echo "Created user $username." | tee -a $LOG_FILE

    # Generate and set a random password
    password=$(generate_password)
    echo "$username:$password" | sudo chpasswd
    echo "$username:$password" >> $PASSWORD_FILE
    echo "Password for user $username set." | tee -a $LOG_FILE

    # Set ownership and permissions for the home directory
    sudo chown "$username:$username" /home/$username
    sudo chmod 700 /home/$username
    echo "Home directory permissions set for $username." | tee -a $LOG_FILE

    # Handle groups
    IFS=',' read -ra group_list <<< "$groups"
    for group in "${group_list[@]}"; do
      if getent group "$group" &>/dev/null; then
        echo "Group $group already exists." | sudo tee -a $LOG_FILE
      else
        sudo groupadd "$group"
        echo "Created group $group." | tee -a $LOG_FILE
      fi
      sudo usermod -aG "$group" "$username"
      echo "Added user $username to group $group." | sudo tee -a $LOG_FILE
    done
  fi
done < "$USER_FILE"

Here's what each line does...

#!/bin/bash

This is the shebang line that tells the system to use the Bash interpreter to execute this script.

if [ $# -ne 1 ]; then
  echo "Usage: $0 <user_list_file>"
  exit 1
fi

This section checks if exactly one argument (the user list file) is provided when the script is run. If not, it prints a usage message and exits with an error code.

USER_FILE="$1"

This line assigns the provided argument to the USER_FILE variable, which will be used to refer to the user list file throughout the script.

if [ ! -f "$USER_FILE" ]; then
  echo "User list file $USER_FILE not found!"
  exit 1
fi

This section checks if the specified user list file exists. If not, it prints an error message and exits.

LOG_FILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.txt"
sudo touch $LOG_FILE
sudo chmod 777 $LOG_FILE
mkdir -p /var/secure
sudo touch $PASSWORD_FILE
sudo chmod 777 $PASSWORD_FILE

These lines define the paths for the log file and the password file and then create the log and password files if they do not already exist and set their permissions to be writable by any users.

generate_password() {
  < /dev/urandom tr -dc 'A-Za-z0-9!@#$%^&*()_+=' | head -c 12
}

This function generates a random 12-character password using characters from a specified set. It reads from /dev/urandom, which is a pseudo-random number generator.

while IFS=';' read -r username groups || [ -n "$username" ]; do

This line starts a while loop that reads each line from the user list file. The IFS=';' sets the internal field separator to ;, so the line is split into username and groups. The || [ -n "$username" ] part ensures the last line is processed even if it doesn't end with a newline character.

    if id "$username" &>/dev/null; then
        echo "User $username already exists." | tee -a $LOG_FILE
    else

This block checks if the user already exists using the id command. If the user exists, it logs a message to the log file and continues to the next iteration.


    sudo useradd -m -s /bin/bash "$username"
    echo "Created user $username." | tee -a $LOG_FILE

If the user does not exist, this block creates the user with a home directory and sets the default shell to Bash. It then logs the action.


    password=$(generate_password)
    echo "$username:$password" | sudo chpasswd
    echo "$username:$password" >> $PASSWORD_FILE
    echo "Password for user $username set." | sudo tee -a $LOG_FILE

This section generates a random password using the generate_password function, sets the user's password, and logs the password in the password file and the action in the log file.

    sudo chown "$username:$username" /home/$username
    sudo chmod 700 /home/$username
    echo "Home directory permissions set for $username." | sudo tee -a $LOG_FILE

This block sets the ownership of the user's home directory to the user and sets the permissions to 700 (read, write, and execute only by the owner). It then logs the action.

    IFS=',' read -ra group_list <<< "$groups"
    for group in "${group_list[@]}"; do
      if getent group "$group" &>/dev/null; then
        echo "Group $group already exists." | sudo tee -a $LOG_FILE
      else
        sudo groupadd "$group"
        echo "Created group $group." | sudo tee -a $LOG_FILE
      fi
      sudo usermod -aG "$group" "$username"
      echo "Added user $username to group $group." | sudo tee -a $LOG_FILE
    done
  fi
done < "$USER_FILE"

This section handles group assignments for the user. It splits the groups field into an array using , as a separator and iterates over each group. For each group, it checks if the group exists; if not, it creates the group. Then, it adds the user to the group and logs the actions.

So that's it. I want to point out though that the internship is a great opportunity to both learn and network, and interestingly, even if you couldn't finish, you can remain connected to their community and enjoy the same benefits as the finalists if you upgrade your account to premium. Check out their Premium benefits here

I'll keep you posted on my next article.

Network Programming: The OSI Model

Jotham Ntekim — Wed, 25 Oct 2023 03:31:33 +0000

1. INTRODUCTION
2. Networking Model
3. Layers of the OSI model

3.1. Layer 7: Application Layer

3.2. Layer 6: Presentation Layer

3.3. Layer 5: Session Layer

3.4. Layer 4: Transport Layer

3.5. Layer 3: Network Layer

3.6. Layer 2: Data Link Layer

3.7. Layer 1: Physical Layer

4. Conclusion

5. Reference

INTRODUCTION

In my last article, I talked about how different hosts can communicate with the help of a computer network. I gave background information on computer networks, their types, and their importance in distributed systems.

In this article, I will walk you through the 7 Layers of the OSI model, and in subsequent articles, we will explore the different network protocols.

Before we get right into it, here are a few points to keep in mind as you follow along:

Hosts: any device that sends or receives traffic(data) - desktop, laptop, phones, printers, servers, Smart TV, Smart Watches, Speakers etc. They are often referred to as nodes. So when I mention hosts or computers later in this article, I am referring to no specific device(s).
Network: consists of two or more computers that are linked to share resources (such as printers and CDs), exchange files, or allow electronic communications. The computers on a network may be linked through cables, telephone lines, radio waves, satellites, or infrared light beams.
Protocol is a set of rules defining how software and devices in a network should work including how they should work together. These are logical rules* though, not physical ones.

The devices on the left may be able to communicate with each other and those on the right too, but those on the left won't be able to communicate with those on the right due to differences in standards. However various devices are expected to communicate with each other. To enable such communication, hence Networking Models.

Networking Model

Networking model is a set of guidelines and standards that defines how data is transmitted and received over a network. It is also known as a networking architecture or a networking blueprint. It provides a common framework for network devices and software to communicate with each other.

Networking models categorise and provide a structure for various networking standards and protocols.

The OSI model is one attempt at standardization, created by International Organisation of Standardization(ISO).

Layers of the OSI model

Network Functions are divided into 7 layers.

Layer 7: Application Layer

It is the layer closest to the end users. Software applications - web browsers, for example, interact with this layer.
HTTP and HTTPS protocols fall under this layer.

It does not include the application itself(internet browser in this situation), but rather just the protocols(HTTP and HTTPS).

Functions:

Identifying communication partners - figuring destination host(s) IP address(es) in the network.
Synchronizing communications

Let's say an internet browser wants to send data into the system on the right(image below). The data is processed through the OSI stack, each layer adding something to the original data(Encapsulation - the original data encapsulated inside the additional information added on). By the time it reaches the physical layer, it is electrical signals to be sent to the destination host(s). The destination system then reverses the process by de-encapsulating the data, stripping off all the additional information added at each layer until it reaches the final layer(application layer).

Interaction between layer 7 in the two systems(host) is called same-layer interaction. It is what enables the application layer to identify communication partners and synchronize communication.

Layer 6: Presentation Layer

This layer is responsible for data formatting, such as character encoding and conversions, and data encryption.

Data in the application layer is in application format, one that only the application understands. It thus has to be translated to a format before being sent to the network layer. The presentation layer's job is to translate between application and network format. For example, encryption of data before being sent to the network layer for processing and decryption before being received by the application layer in the destination host.

Layer 5: Session Layer

This layer establishes, maintains, and terminates sessions.

A session is a mutually agreed upon connection that is established between two network applications.

So a session is a connection that is established between two specific end-user applications. This connection can be in two forms:

Client and server model: the application requesting the information is called the client, and the application that has the requested information is called the server.
Request and response model: while a session is being established and during a session, there is a constant back-and-forth of requests for information and responses containing that information or a response like, “Hey, I don’t have what you’re requesting.”

Sessions may be open for a very short amount of time or a long amount of time.

So this layer...

Controls dialogue(session) between communicating hosts.
Establishes, manages, and terminates the connection between local application(e.g. Your internet browser) and remote application(e.g. YouTube).

For each established connection, a session is created. Session Layer helps to manage all sessions.

NB: Network engineers don't usually work with the top three layers, rather application developers do - to connect their applications over the network.

Layer 4: Transport Layer

This layer segments and reassembles data for communication between end hosts.

Breaks large sets of data into smaller segments which can be more easily sent over the network with a low possibility of causing transmission problems even if an error occurs. It is why videos skip for a second and continue just fine if a particular segment is not sent, unlike when not segmented, the whole video cannot be watched.

It provides host-to-host(end-to-end/process-to-process) connections.
It supports connection-oriented(TCP) and connectionless(UDP) communication.

In the layer, the packaged data is called segment - Data + layer 4 header(L4 Header).

Layer 3: Network Layer

It provides connectivity between end hosts on different networks(i.e. hosts outside the LAN).
Provides path selection - routing with the aid of routers. It provides Logical addressing(IP addressing).

Routers are the workhorse of Layer 3 - we couldn’t have Layer 3 without them. They move data packets across multiple networks.

Routers do not only connect to Internet Service Providers (ISPs) to provide access to the Internet, they also keep track of what’s on its network same way switches keep track of all MAC addresses on a network (Switches exist in Layer 2), what other networks it’s connected to, and the different paths for routing data packets across these networks.

The packaged data at this stage is called packet - Data + layer 4 header + layer 3 header.
The IP address is included in this layer.

Layer 2: Data Link Layer

This layer defines how data is formatted for transmission, how much data can flow between nodes, for how long, and what to do when errors are detected in this flow.

It provides node-node connectivity and data transfer(for example, PC to Switch, Switch to Router or Router to Router). It defines how data is formatted for transmission over a physical medium(copper UTP cables for example). It detects and possibly corrects physical layer errors. It uses layer 2 addressing, which is separate from layer 3 addressing. Switches operate at this layer.

The packaged data is called Frame - Layer 2 trailer + Data + L4 header + layer 3 header + layer 2 header.

Layer 1: Physical Layer

Layer 1 contains the infrastructure that makes communication on networks possible.

It defines the physical characteristics of the medium used to transfer data between devices - for example, voltage level, maximum transmission distances, physical connectors, cable specification etc.

There’s a lot of technology in Layer 1 - everything from physical network devices, and cabling, to how the cables hook up to the devices. Plus if we don’t need cables, what the signal type and transmission methods are (for example, wireless broadband)?

Layer 1 defines the electrical, mechanical, procedural, and functional specifications for activating, maintaining, and deactivating physical links between network devices.

The data unit on Layer 1 is the bit.

A bit is the smallest unit of transmittable digital information. Bits are binary, so either a 0 or a 1. Bytes, consisting of 8 bits, are used to represent single characters, like a letter, numeral, or symbol.

At this level, digital bits are converted into electrical(for wired connections) or radio(for wireless connections) signals.

The complete frame is then sent from one host to the other through ethernet cable for example or wireless broadband. The Data Link Layer translates the raw physical layer into a frame ... The layer 2 header and trailer are removed at layer 2, leaving a packet. Layer 3 removes the layer 3 header, leaving the layer 4 segment, and layer 4 removes the layer 4 header leaving the original data prepared by the upper layers(top 3 layers) of the original device(De-encapsulation).

NB: Data + Segment + Packet + Frame are all called Protocol Data Units(PDUs).

Conclusion

We've discussed the need for Networking models, and the part each layer of the OSI model plays in ensuring communication within and/or over a network. Recall, that we agreed in the last article that the hardware part of a computer network is beyond the scope of this article series so our focus would be on the first 3 Layers(Application, Presentation and Session layers) of the OSI model since they are more concerned with the Software part of a computer network. But since I've always been intrigued to know how IP addressing works - subnetting and masking, I'll be making an exception for the transport and network layer.

In the next article, we will talk about an interesting topic - IP addresses, a Layer 3 Protocol. It is one of the reasons behind my focus in Network programming and the need to write these articles.

Reference

https://www.freecodecamp.org/news/osi-model-networking-layers-explained-in-plain-english/#:~:text=There%20are%20two%20distinct%20sublayers,have%20the%20same%20MAC%20address.

https://www.youtube.com/watch?v=t-ai8JzhHuY

https://www.computernetworkingnotes.com/ccna-study-guide/what-is-a-networking-model-explained.html

Network Programming: The computer network.

Jotham Ntekim — Tue, 10 Oct 2023 23:29:38 +0000

1. Introduction
2. What is a Computer Network?
3. Types of Computer Networks
4. Conclusion

Introduction

You have probably worked into several internet cafes in an attempt to photocopy or print a document.

- You walk straight to the person in charge and tell him you need a printed copy of the document you have on your device.

- You send him the document. After a few minutes, he walks to the printer and gets you a copy of the document you sent him.

But how exactly did the document you sent to his computer get to the printer?

Well, the computer connects to the printer's IP address and sends the data in a language the printer knows. This is possible with the help of Computer Network.

What is a Computer Network?

A computer network is a bunch of devices connected to exchange information — emails, documents, audio/video data — or to share a resource — printers, storage and other physical devices. Typically, computers in a network are called hosts, while links are the elements that connect them.

The scenario painted above about the connection between a printer and a computer is one example of a computer network.
Receiving files from a friend's device through Bluetooth or Xender connection is another example of a computer network.
The connection between your favourite browser(chrome for example) and the servers where the data you request are stored is yet another example. The list is endless.

Types of Computer Networks

Computer networks range from very small to very large. Based on size, they're referred to as:

Local Area Network (LAN) - Few hosts(computers) connected over a limited area. Like the ones we find inside houses, schools or offices.
Metropolitan Area Network (MAN) - A larger network that extends across a city and can be conceptually seen as many smaller LANs connected together.
Wide Area Network (WAN) - an even bigger network, which connects multiple MANs or LANs and can span the whole world.

Engineers are also working on a type of interplanetary computer network that connects satellites, planetary rovers and the Earth, which at this time is not of our interest.

Computer networks can be analysed both at a hardware and software level. Physically, a network is made of computers, cables and other machinery that makes it work correctly. Understanding computer networks on the hardware level involves a lot of physics, mathematics and electronics to describe how the signal travels around, along with the technology behind components and computers. The software level on the other hand involves programs, instructions and algorithms(a set of step-by-step instructions for solving a problem) that give life to the physical counterpart - computers, cables, routers, etc.

The hardware part of a computer network is beyond the scope of this article series. Our focus will be on the software level which involves Network Programming: writing programs that communicate with other programs across a computer network.

All networks are based on one or more network protocols - a set of rules that determine how information should be transmitted between different computers in the same network.

For example, the HyperText Transfer Protocol (HTTP) describes how to fetch and share resources, such as text documents, over a network. It also describes all the hardware components required for the resource exchange to work correctly. Thanks to the HTTP you can browse this page on your device, add comments in the box below or share it on social media.

The list of existing network protocols is quite huge and spans across multiple domains. While the list may be a long one, they all follow the Open System Interconnection(OSI) model.

Conclusion

We have established that computer networks are crucial in modern systems and applications. While a few standalone systems like Microsoft Word, Calculator app, Adobe Photoshop etc., can operate without the need to connect to other hosts/applications, most systems require some sort of connection to other hosts to function hence the need for a Computer Network.

In future articles, we will explore some of the different layers of computer protocols - network layer(IP), transport layer(TCP/UDP) and application layer(HTTP/FTP), and how they follow the OSI model.

Golang : The OOP Pattern.

Jotham Ntekim — Tue, 10 Jan 2023 07:14:43 +0000

Programming is a creative task: there is no right or wrong way to solve a problem, in the same way, that there is no right or wrong way to paint a picture.

In this article, I will walk you through how I did my AltSchool Project. We'll learn about some OOP Concepts - Encapsulation, Abstraction, Inheritance, and Polymorphism.

But before I get started, let me brief you on what the project is about...

John has just opened up his car selling shop, to sell different cars. He gets the cars he needs to sell from different people and they all bring it to him. He needs to manage the list of cars he has, attach a price to them, and put them on display to be sold, basically John needs an inventory to manage cars & to manage sales. For instance,

He needs to see the number of cars that are left to be sold
He needs to see the sum of the prices of the cars left
He needs to see the number of cars he has sold
Sum total of the prices of cars he has sold
A list of orders that for the sales he made

Using the knowledge of OOP in Go, Build simple classes for the following “objects”

● Car
● Product
● Store

The Car class can have any car attributes you can think of.

The Product class should have attributes of a product i.e (theproduct, quantityofthe
productinstock,priceoftheproduct).

A car is a product of the store, but there can be other products so the attribute of the car can be promoted to the Product. The Product class should have methods to display a product, and a method to display the status of a product if it is still in stock or not.

The Store class should have attributes like

● Number of products in the store that are still up for sale
● Adding an Item to the store
● Listing all product items in the store
● Sell an item
● Show a list of sold items and the total price

So basically we'll be building a mini-ecommerce platform that will help John make sales and at the same time keep track of his sales.

Let me point out a few things, though Car is the main Product John deals on, he sells other Car accessories such as headlights, tyres etc so our Car class here will cover for all items John sells.

Defining the deliverables or functionalities of this app will be our first task. We’ll do this by creating a Store Interface. Interface basically helps us define a set of attributes or behaviors that a class implements. So instead of creating a function for each type of Product(Camry Car, Tyres, Car Headlights etc), whatever form the Product class takes, they'll be able to extend the interface functions. Attributes like "adding an item to the store" , "selling an item" will be common to any product whether an actual car or car accessories hence the need for interfaces. Interfaces is one way Go implements Polymorphism – one of the concept in Objected Oriented Programming.

Here is the Store definition:

type Store interface {
    AddProduct(prod models.Product) models.Product
    SellProduct(prod models.Product) models.Product
    ProductList() []models.Product
    OnSaleProducts() []models.Product
    SoldProductList() []models.Product
    OnSaleProductPriceTotal() float64
    SoldProductPriceTotal() float64
    DisplayStatus() string
}

Next step is to create Car, and Product class. Go does not support the actual Class keyword as in other languages like JavaScript, so we'll be using struct to define each of this classes. Like Class/Object in JavaScript and Dictionary in python, Go’s structs are typed collections of fields. They’re useful for grouping data together to form records.

So in case of Car and Product collection, the class will be defined as below:

type Car struct {
    Id        string
    Name      string
    Model     string
    Price     float64
    IsCarType bool
    DateAdded string
    Color     string
}

type Product struct {
    Id         string
    Item       Car
    QtyInStock uint64
    TotalPrice float64
    OutOfStock bool
}

While declaring the Car and Product class, I capitalized "C" and "P" as well as the first letter for each of the field in each collection to make it accessible aside that package/file. Instead of "public" and "private" keyword like in other language, use of uppercase and lowercase for the first letter of any keyword is Go's way of encapsulation. Also, if you note, I used the "Car" struct as the type for "Item" in the "Product" struct, that's one way of implementing Inheritance(The Product class inherited the attributes of the Car class).

Now let’s extend the methods we defined in the Store Interfaces, that way our program can know what each method is supposed to do.

var products []models.Product
var availableProducts = products
var soldProducts []models.Product

func (product Product) AddProduct(prod models.Product) models.Product {
    productExists := false
    index := 0
    for i, item := range availableProducts {
        if item.Item.Name == prod.Item.Name && item.Item.Model == prod.Item.Model {
            productExists = true
            index = i

            break
        }
    }
    if productExists {
        availableProducts[index].QtyInStock += 1
        availableProducts[index].TotalPrice += prod.Item.Price
    } else {
        prod.Id = strconv.Itoa(rand.Intn(1000000000))
        prod.TotalPrice = prod.Item.Price * float64(prod.QtyInStock)
        prod.OutOfStock = false
        products = append(products, prod)
        availableProducts = append(availableProducts, prod)
    }

    fmt.Println("Product added successfully!")

    return prod
}

func (product Product) SellProduct(prod models.Product) models.Product {

    //availableProducts := availProductList
    isEqual := false
    greaterThanOne := false
    index := 0
    for i, item := range availableProducts {
        if item.Item.Id == prod.Item.Id {
            isEqual = true
            index = i
            if item.QtyInStock > 1 {
                greaterThanOne = true
            }
            break
        }
    }
    if isEqual {
        if greaterThanOne {
            availableProducts[index].QtyInStock -= 1
            availableProducts[index].TotalPrice -= prod.Item.Price
            availableProducts[index].OutOfStock = false
            for _, item := range products {
                if item.Id == prod.Id {
                    item.QtyInStock -= 1
                    item.TotalPrice -= prod.Item.Price
                    item.OutOfStock = false

                    break
                }
            }
        } else {
            availableProducts = append(availableProducts[:index-1], availableProducts[index+1:]...)
            for _, item := range products {
                if item.Id == prod.Id {
                    item.OutOfStock = true
                    break
                }
            }
            productExists := false
            index := 0
            for i, item := range soldProducts {
                if item.Item.Name == prod.Item.Name && item.Item.Model == prod.Item.Model {
                    productExists = true
                    index = i

                    break
                }
            }
            if productExists {
                soldProducts[index].QtyInStock += 1
                soldProducts[index].TotalPrice += prod.Item.Price
            } else {
                prod.TotalPrice = prod.Item.Price * float64(prod.QtyInStock)
                soldProducts = append(soldProducts, prod)
            }

        }

    }
    fmt.Println("Sale successful!")

    return prod
}
func (product Product) OnSaleProductPriceTotal() float64 {
    var totalPrice float64
    for _, item := range availableProducts {
        totalPrice += item.TotalPrice
    }

    return totalPrice
}

func (product Product) DisplayStatus() string {
    var status string
    for _, item := range products {
        if item.OutOfStock == false {
            status = "Still on sale!"
        } else {
            status = "Out of stock!"
        }
    }
    return status
}

func (product Product) SoldProductPriceTotal() float64 {
    var totalPrice float64
    for _, item := range soldProducts {
        totalPrice += item.TotalPrice
    }

    return totalPrice
}

func (product Product) ProductList() []models.Product {

    return products
}

func (product Product) SoldProductList() []models.Product {

    return soldProducts
}

func (product Product) OnSaleProducts() []models.Product {

    return availableProducts
}

So far we’ve been able to create a set of classes and functions that will help John record and track his sales. We learnt about basic types such as Struct and Interfaces as well as some OOP concepts in Go.
Hopefully, I’ll write another article on other Go types like maps, pointers as well as how Go implements concepts like Constructors, Abstraction etc. Meanwhile do well to drop any questions on the comment section.

Thank You.

DEV Community: Jotham Ntekim

CineAgent: Bridging the Web and Conversational AI with a Concurrent Go ETL

🚀 The Vision: Beyond Static Data

🛠 The Tech Stack

💡 Key Features & Originality

1. The Trawl ETL Pipeline (Go)

2. The Hybrid "Voice-to-Agent" UI

3. Voice-First Discovery

📺 Demo & Visuals

Live URL: trawl-ui.vercel.app

🧠 Lessons Learned

🔗 Links

algoliachallenge #devchallenge #agents #webdev #golang #react

Linux User Creation Bash Script

Task Description

Requirements

My Solution

Network Programming: The OSI Model

Table of Contents

INTRODUCTION

Networking Model

Layers of the OSI model

Layer 7: Application Layer

Layer 6: Presentation Layer

Layer 5: Session Layer

Layer 4: Transport Layer

Layer 3: Network Layer

Layer 2: Data Link Layer

Layer 1: Physical Layer

Conclusion

Reference

Network Programming: The computer network.

Table of Contents

Introduction

What is a Computer Network?

Types of Computer Networks

Conclusion

Golang : The OOP Pattern.