Forem: diar

Go Interview basic questions

diar — Tue, 18 Mar 2025 13:08:13 +0000

These are some basic GO questions that I've gathered from the interviews.

I will be posting the questions Post As You Go, where I will gather a post from different interviews that I attend.

What is a string in go?

Beisdes that it is just a built in type
It's immutable.
It supports UTF-8, which means, it supports all the world languages.

The difference between an array and a slice?

Array is fixed size and slices are dynamic which use arrays under the hood, so you can add as many values as you want.

How do you catch a panic?

By using recover.
Although keep in mind that the recover has to be inside of a deferr func.
Since the panic stops the execution, defer is executed if there is a panic.

//... rest of the code
defer func() {
    if r := recover(); r != nil {
        fmt.Println("Recovered in f", r)
    }
}()

//... rest of the code

Normally libraries handle panics in their internal code, but they should always return proper error, so you should never get a panic from modules.

What is the difference between any and interface{}

There is no difference.
any is an alias for interface{}

Thanks for your attention.
Is there anything you would add?

File Upload Wrapper Library

diar — Tue, 14 Mar 2023 14:11:16 +0000

The File Upload Wrapper is a PHP library that simplifies file uploads by providing a set of easy-to-use classes that handle common validation and processing tasks.
With this library, you can:

Validate uploaded files with ease
Process uploaded files with targeted validations for specific fields
Simplify the file upload process with a set of easy-to-use classes

Getting Started

To use the library, follow these steps:

Install the library using Composer:

composer require didslm/file-upload-wrapper

Import the classes you need:

use Didslm\FileUpload\Uploader;
use Didslm\FileUpload\File;
use Didslm\FileUpload\Validation\FileSize;
use Didslm\FileUpload\Validation\FileType;
use Didslm\FileUpload\Validation\Dimension;
use Didslm\FileUpload\FieldValidation;
use Didslm\FileUpload\Attributes\Image;
use Didslm\FileUpload\Attributes\Document;
use Didslm\FileUpload\Exceptions\FileUploadException;

Use the upload() method to handle file uploads for your entity:

class Product {
    #[Image(requestField: "request_field", dir: "/public")]
    private string $image;

    #[Image(requestField: "profile_field", dir: "/public", required: false)]
    private string $profile;

    // ...
}

$product = new Product();

Uploader::upload($product, [
    new FileType([File::JPEG]),
    new FileSize(2, File::MB)
]);

Examples

Handling File Uploads for an Entity

The following code shows an example of how to use the library to handle file uploads for an entity:

class Product {
    //...
    #[Image(requestField: "request_field", dir: "/public")]
    private string $image;

    #[Image(requestField: "profile_field", dir: "/public", required: false)]
    private string $profile;

    public function getImageFilename(): string
    {
        return $this->image;
    }

    public function getProfileFilename(): string
    {
        return $this->profile;
    }
}

In this example, the Product class has two properties image and profile that are decorated with the Image attribute.

Types

In the following example you will see a list of available Attribute types:

#[new Image(requestName: 'file_upload_field', dir: '/upload/dir')]
#[new Document(requestName: 'cv_file', dir: '/upload/dir')]
#[new Video(requestName: 'video_file', dir: '/upload/dir')]

The Image attribute provides metadata to the library to process the files correctly during the upload.

The Document attribute provides metadata to the library to process the files correctly during the upload.

The Video attribute provides metadata to the library to process the files correctly during the upload.

The upload() method is then called on the Uploader class with the Product object and an array of validation rules as its parameters.

$product = new Product();

Uploader::upload($product, [
    new FileType([File::JPEG]),
    new FileSize(2, File::MB)
]);

echo $product->getImageFilename();

Handling Exceptions

The library provides a FileUploadException class that all exceptions thrown by the library extend. This means that you can catch all exceptions using FileUploadException in a try-catch block, as shown below:

try {
    Uploader::upload($product, [
        new FileType([File::PNG]),
        new FileSize(2, File::MB)
    ]);
} catch (FileUploadException $e) {
    // handle exception
}

Validation

The library provides several validation classes that you can use to validate uploaded files. These classes can be passed as parameters to the upload() method to specify the validation rules for the files being uploaded.

Type

The FileType class is used to check the file type. You can specify the types of files allowed by passing an array of file types to the constructor. For example:

new FileType([File::PNG, File::JPEG, File::GIF])

Size

The FileSize class is used to validate the file size. You can specify the maximum file size allowed by passing the size in bytes to the constructor. Alternatively, you can use the Size class to specify the size in a more readable format. For example:

new FileSize(2, File::MB)
new FileSize(200, File::KB)

Dimension

The Dimension class is used to validate the dimensions of images. You can specify the maximum width and height of the image by passing them as parameters to the constructor. For example:

new Dimension(200, 200)

Targeted Validations

You can also target specific fields in your entity with a set of validations.
To do this, you can use the FieldValidations class, which takes the request field name as it's first parameter and an array of validation rules as its second parameter. Here's an example:

$profileValidations = new FieldValidations("profile_field", [
    new Dimension(200, 200),
    new FileSize(2, File::MB)
]);

Uploader::upload($product, [
    new FileType([File::PNG, File::JPEG, File::GIF]),
    $profileValidations,
]);

In the example above, we are specifying a set of validation checks that apply to the profile field in the Product entity. These checks will only be applied to the profile image uploaded by the user.

Handling file uploads can be a complicated and error-prone task, but with this library, you can simplify the process and focus on building the features that matter. If you have any questions or feedback, feel free to reach out to the author on Twitter or LinkedIn.

How to start contributing in open-source.

diar — Thu, 02 Feb 2023 00:00:00 +0000

This article is meant to tell you how easy it is to start contributing on public repositories and get feedback from people with a lot of experience.

Loading environment values into PHP classes

diar — Wed, 01 Feb 2023 00:00:00 +0000

Load environment variables with this library into php classes, easy to use and test, you can easily contribute to this open source project, code logic is very small and there is no learning curve.

Is anyone thinking on starting a podcast about development?

diar — Tue, 31 Jan 2023 14:32:22 +0000

If you are

Then reach out to me or just post your linkedin profile in the comments, I will reach out and we can discuss.

If you are not then you can still reach out on linkedin just in case. :)

Loading environment values into go Structs

diar — Fri, 27 Jan 2023 09:37:36 +0000

The Env library

The goal of this library is to be able to load Environment values into GO structs.

This library is a simple one where it loads four types of values and does not cover arrays or any other logic except what is explained here.

Supported types are **string,int,int32,int64,float32,float64,bool** .

Installation

If you have already set up your project in GO and you want to install the library, then all you need to do is go get github.com/diarselimi/env and that's it.

Basic usage

After installing this library you can simply use it by importing it and passing the struct by reference.

The following example will show you, how you can use this with a simple struct which contains tags as a reference to the environment variable.

package main

import (
    "fmt"
    "github.com/Diarselimi/env"
)

type ClientConfig struct {
    BaseUrl string `env:"API_BASE_URL"`
    ClientId string `env:"API_CLIENT_ID"`
    Secret string `env:"API_SECRET"`
}

func main() {
    config := ClientConfig{}
    env.PopulateWithEnv(&config)

    fmt.Println(config)
}

Advanced usage

In this other example you will see how you can use this library by having one central place for all your environment variables, distributed into their own structs.

The most important part here is the tag type inside structs which is named **obj .**

package main

import (
    "fmt"
    "github.com/Diarselimi/env"
)

type Config struct {
    SomeApiConfig ClientConfig 'obj:""'
    MysqlConfig SqlConfig 'obj:""'
}

type ClientConfig struct {
    BaseUrl string `env:"API_BASE_URL"`
    ClientId string `env:"API_CLIENT_ID"`
    Secret string `env:"API_SECRET"`
}

type SqlConfig struct {
    Host string 'env:"MYSQL_HOST"'
    User string 'env:"MYSQL_USER"'
}

func main() {
    config := Config{}
    env.PopulateWithEnv(&config)

    fmt.Println(config)
}

Now you can see the tag types in the structs which contain **env** and **obj** , the library will look and fill them with necessary data.

Contribution

The library is very new and does not contain much logic, if you are new into GO and want to contribute to this project feel free to create a pull request and I will review your code.

Your chance to start contributing when a project is small are way higher because there is no learning curve there are just three methods that do the job.

You can support by writing test scenarios which also help a lot on making the library more stable on future functionalities.

If you are not ready to contribute then I would appreciate any other support GitHub repository like give it a star ⭐ if you think it's worth it.

Conclusion

The env library will provide you with a simple functionality which can help you load your environment values into go structs.

If you were thinking to contribute in open source then this is your chance to do so.

You can use this library for your project or you can contribute by adding support for other types like arrays etc.

As a Developer what should I do next, after ChatGPT release?

diar — Wed, 07 Dec 2022 11:30:00 +0000

As a developer, you may be wondering what to do next now that ChatGPT has been released. ChatGPT is a powerful tool that can help you quickly and easily answer programming questions, but it's important to remember that it's not a replacement for your skills and expertise as a developer.

So what should you do next? Here are a few suggestions:

First, continue to develop and improve your skills. ChatGPT is a useful tool, but it's not a substitute for the knowledge and experience that you have as a developer. By staying up to date with the latest technologies and best practices, and by working on challenging projects that push you to grow, you can continue to build your skills and expertise.

Second, explore new areas of development. ChatGPT can answer many common programming questions, but it can't answer everything. By branching out into new areas of development, such as machine learning or cloud computing, you can expand your knowledge and capabilities, and position yourself for success in the future.

Third, consider taking on more responsibility. As a developer, you may have the opportunity to lead a team or manage a project. This can be a great way to gain valuable leadership and management experience, and can help you advance your career.

Finally, don't be afraid to try new things. The world of development is constantly changing, and new technologies and approaches are always emerging. By staying open to new ideas and opportunities, you can continue to grow and thrive as a developer.

In summary, ChatGPT is a valuable tool, but it's not the end of the road for your career as a developer. By continuing to develop your skills, exploring new areas, taking on new challenges, and staying open to change, you can continue to succeed and thrive in your career.

Update

It's true that ChatGPT can quickly and easily generate articles about programming topics. However, this doesn't necessarily mean that you should stop writing articles yourself. There are still many good reasons to write your own articles, even if ChatGPT is capable of doing it as well.

First, writing your own articles can help you deepen your knowledge and understanding of the topic. By researching and writing about a topic in your own words, you can gain a more thorough understanding of the material than you would by simply using ChatGPT to generate an article.

Second, writing your own articles can help you develop your own unique perspective and voice. While ChatGPT can generate articles that are technically accurate, they may not always reflect your own thoughts and opinions. By writing your own articles, you can share your own insights and experiences, and contribute to the broader conversation in your field.

Third, writing your own articles can be a valuable way to build your reputation and credibility as a developer. By sharing your own original content, you can establish yourself as an authority in your field, and demonstrate your expertise and knowledge to others.

Overall, while ChatGPT can be a useful tool for generating articles about programming, it shouldn't be a replacement for your own writing. Writing your own articles can be a valuable way to deepen your knowledge, develop your perspective, and build your reputation as a developer.

Let's connect on twitter.

Layered Architecture Style

diar — Fri, 02 Dec 2022 08:10:58 +0000

Layered architecture, is an architecture pattern that helps for having a more organized and structured codebase.

Each layer has its distinct job and all the layers communicate via well-defined interfaces.

This architecture helps us with maintainability and scalability and is often used on enterprise applications.

You should be strict about not letting these layers have direct dependencies between layers, otherwise, you will lose the benefits of this architectural style.

Usually, the communication or interaction between layers is top-down at higher levels of the application such as user interaction using lower parts of the application such as the Database.

The key idea of this architectural style is to have a clear separation of concerns.

Keep in touch on twitter @slmdiar.

Let's Connect on Twitter

diar — Thu, 01 Dec 2022 20:57:28 +0000

I have a new account on twitter and looking for engineers and open minded people to connect with.
Whoever follows I will follow back :).

Twitter is a great platform to meet new people, share ideas, and stay up-to-date with the latest news. I'm always looking for new connections and conversations, so come join me and let's get connected!

You can find me on Twitter @slmdiar, and I look forward to connecting with you soon.

Go Channels, Waitgroups, and Go Routines

diar — Tue, 29 Nov 2022 10:52:33 +0000

Go Channels, Waitgroups, and Go Routines

Go is a powerful and efficient programming language that has become increasingly popular in recent years. It has become a go-to language for many developers and is used in a variety of applications. One of the features that makes Go so powerful and efficient is its ability to use channels, waitgroups, and go routines. This article will explain what channels, waitgroups, and go routines are and how they work together to help speed up development and improve the efficiency of applications.

What are Go Channels?

Go Channels are data structures that allow a program to send and receive messages between goroutines. These messages can be of any type and are sent over a channel, allowing for communication between goroutines without having to use locks, mutexes, or other synchronization techniques. A channel can be buffered, meaning that messages can be sent even if the receiver is not yet ready to receive them.

What are Waitgroups?

Waitgroups are a synchronization primitive that let you wait for a group of goroutines to finish executing. Waitgroups can be used to ensure that all goroutines have finished before continuing execution. This allows for synchronization and coordination between different threads of processing units.

What are goroutines?

Goroutines are lightweight threads of execution. They are used to run functions concurrently and can be used to speed up the execution of certain tasks. Goroutines have access to the same memory address space and can share data, allowing multiple goroutines to efficiently work together.

How do Channels, Waitgroups, and Goroutines Work Together?

Channels, waitgroups, and goroutines can be used together to create efficient applications that are capable of performing multiple tasks simultaneously. By using channels, waitgroups, and goroutines together, developers can create applications that can perform multiple functions at the same time, allowing them to create more efficient applications.

Conclusion

Go Channels, waitgroups, and goroutines are powerful tools that can be used to create efficient applications. They allow for communication between goroutines and can be used to synchronize tasks and speed up development. By using these tools together, developers can create powerful applications that can perform multiple tasks simultaneously.

Using Mutex with GO on a real-world project.

diar — Thu, 17 Nov 2022 21:02:56 +0000

What will I learn?

I will be able to understand what is a Mutex,
and how it works in concurrent processes.
I will apply a mutex on a real-world project to see how we can benefit from it.

What is a Mutex?

Mutex is a library that works on locking methods to not be accessible from other concurrent processes
until the mutex says that it's open.
Think of a mutex as the traffic police, and when the police block a road that's a Lock(), no car will pass until the Police open Unlock() the road.

How does it work?

As I would read in the Go docs a Mutex must not be copied,
if I call the Lock() method then the mutex is locked and any other lock call will be waiting for it to be Unlock()-ed.
If I call the Unlock() method then the mutex will unblock itself and tell the lock method that Mutex is open.
Every time I copy a mutex then the state is unlocked, meaning it will have no effect.

Before I describe how to apply on a project, try to set up this project in your maching, and see how it works.

How do I apply it on a project?

This is a project that I was working on, it's about assigning gifs to employees, and each employee has to have one gift,
first come first serve.
I have employees and gifts in two json files and they look like this:

//gifts json
[{
    "name": "netflix card",
    "categories": ["music", "film", "pets", "scifi"]
    }, {
        "name": "gold plated water bottle",
        "categories": ["power lifting", "triathlons", "football", "crossfit", "handball", "running"]
    }
]
...

//employees json
[{
    "id": 1,
    "name": "severin",
    "interests": ["high end audio", "photography", "sitting comfortably"]
    }, {
        "id": 2,
        "name": "oliver",
        "interests": ["pets", "scifi", "music making"]
    }
]
...

The examples are just one object in the array but if you look at the files there are more data.

Next you will see the project structure in github.
The main.go file has the following content

///...
var mutex = sync.Mutex{} //here we initialise Mutex, keep in mind this is outside of the methods.

func handler(w http.ResponseWriter, r *http.Request) {
    employeeId, err := strconv.Atoi(r.URL.Path[1:])
    if err != nil {
        fmt.Fprintf(w, "Employee with id %s not found", r.URL.Path[1:])
        return
    }
    mediator := application.CommandMediator{Mu: &mutex} //here we pass the mutex by reference
    mediator.Add(command.NewAssignGiftToEmployeeCommand(employeeId))

    mediator.Run()
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

If I go ahead and open CommandMediator I will see that I use the mutex there to Lock() and defer Unlock(),
and defer is like saying execute this when you are done.

type CommandMediator struct {
    Mu       *sync.Mutex // important
    commands []Command
}
///...
func (cm *CommandMediator) Run() {
    cm.Mu.Lock() //locking
    defer cm.Mu.Unlock() //unlocking when job is done

    for _, command := range cm.commands {
        command.Execute() // executing the command
    }
}

As I can see in the method Run() above, I am calling the mutex that is being passed from the main file, and then locking it.
So that means that the mutex that I am getting it's the same mutex that everyone else is getting when sending a request.
So that makes sense since we are passing mutex by reference and other people have the same instance of it,
someone might be faster than me in locking it then I must wait for the Unlock().

How long do I have to wait for my request?

Turns out it all depends on how your project is organized, in my small project I have blocked the mediator where the commands are executed,
meaning no one can execute the Run() until the first process is done.

func (cm *CommandMediator) Run() {
    cm.Mu.Lock()
    defer cm.Mu.Unlock()

    for _, command := range cm.commands {
        command.Execute()
    }
}

To make the change more obvious I have added a time.Sleep(5 * time.Second) which will sleep for 5 seconds,
this is for me to try to simulate two requests at the same time.
So every time I run the command it will be blocked for 5 seconds.

How do I see the effect?

Since I have the project on my machine, I can open a terminal and run the application by executing go run main.go,
next step would be to open the following link twice http://localhost:8080/1,
one will show you the gift one will show it after 5 seconds.

As a challenge I could try to disable the mutex in the mediator and see what happens when I click the link above twice or even more.

what is programming? Summary of 10 other articles.

diar — Sun, 26 Jun 2022 13:20:18 +0000

Programming languages are used in computer programming to implement algorithms.

High-Level Languages are programming languages like Java, Python, C, C , etc which helps programmer to write programs which is independent with the type of computer.

"Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result." Doing SQL is considered as programming even though for sure there is no executable and its just interpreted by database engine.

Programming involves activities such as analysis, developing understanding, generating algorithms, verification of requirements of algorithms including their correctness and resources consumption, and implementation of algorithms in a target programming language.

A computer program is usually written by a computer programmer in a programming language.

Most of today's high-level languages support object oriented programming or are object oriented programming languages.

1c. STRUCTURED PROGRAMMING. The structured programming method is a simplified form of imperative programming.

You can program by writing code in a programming language using a text editor or an integrated development environment.

In computer science, an interpreter is a computer program that directly executes instructions written in a programming or scripting language, without requiring them previously to have been compiled into a machine language program- Wikipedia.