DEV Community: Luigi Escalante

Choosing Your Path: Avenger (Front-End) vs Men in Black (Back-End)

Luigi Escalante — Mon, 05 Jan 2026 01:56:10 +0000

While software engineers often find themselves performing both front-end and back-end tasks, it is common to develop a preference for one area or to possess stronger skills in either front-end or back-end development. This inclination typically shapes your professional identity and influences the type of work you seek out.
One aspect that many newcomers overlook is the impact of the company's environment on these two roles. The work culture, team dynamics, and expectations can differ significantly between front-end and back-end positions, and understanding these distinctions is essential when deciding which path to follow.

To illustrate the difference in a lighthearted way: ask yourself, do you want to be an Avenger or a member of the Men in Black? This analogy captures the contrasting nature of front-end and back-end roles in the world of software engineering.

Front-End Developers: The Avengers of Software Engineering

The “Heroes” from the Customer’s Perspective

As a front-end developer, you often become the “hero” of the project in the eyes of the customer or end user. Your work is always the center of attention from the outside world. While a software project involves many areas—such as infrastructure, back-end development, project managers, designers, and testers—even a small successful change on the front end is highly appreciated by the customer. Most of the congratulations and recognition are based on the user experience you help create.

Imagine this scenario: a new app update improves the user experience and makes it easier and faster to find results. All the comments and praise will focus on the great job you did. In contrast, consider if you migrate the database to a new engine to improve performance, but there’s no visible change to the user experience. In this case, no one will say, “I don’t know what you did, but the app is faster—thank you.” Infrastructure and back-end work often pass without comment or glory.
Judged by the World

Front-end developers, like heroes, are judged by society.

The entire world evaluates your work. Since everyone has an opinion, you will receive criticism and negative comments, and sometimes you’ll be blamed for problems beyond your control, the most famous example is the comment “The last version is better”, “I think is better if this is like …”. Everyone will be an expert.

Noncommon skills for Front-End Developers

Effective Communication with Non-Technical Audiences
Front-end developers spend a significant portion of their time—about 80%—interacting with a diverse range of individuals. This includes direct communication with end users, directors, external users, and even responding to feedback from people they may never meet in person. Each group brings its own unique perspectives and requirements, and front-end developers must be able to understand and address these varying needs effectively.
Basic Understanding of UX and Design Principles
Possessing foundational knowledge in user experience (UX) and design is vital for front-end developers. This expertise enables them to create interfaces that are both visually appealing and functional, ensuring that the final product aligns with user expectations and enhances overall satisfaction.
A Keen Eye for Detail and Perfectionism
Much like artists, front-end developers must pay close attention to detail. Even the slightest deviation—such as a pixel out of place—will often be noticed and reported by users. Striving for perfection in the visual and interactive aspects of a project is essential, as these elements are constantly under public scrutiny.
Prioritizing the Needs of End Users
The primary goal of a front-end developer is to ensure that end users are satisfied with the final product. This means consistently considering what will make users happy, rather than prioritizing personal preferences or suggestions from other departments. The user experience should always come first in the decision-making process.

Back-End Developers: “We are men in black”

“Anonymous is your name, the silence your language, you will remember as maybe I saw you.”

Back-end developers often operate behind the scenes, much like the agents in "Men in Black." Their contributions, though critical, generally remain anonymous to the wider world. Their achievements are challenging to showcase outside of technical circles.

When it comes to presenting themselves professionally, whether on a resume or during a job interview, back-end developers may find it difficult to communicate the value of their work. They can display scripts or APIs, but these are only truly understood by other technical professionals. Non-technical individuals tend to respond with a polite “Ok, cool,” before moving on, not fully grasping the complexity or significance of the work involved.

This lack of visibility extends to personal life as well. When a developer creates an app or a website, family members can proudly say, “My son made this.” However, for back-end engineers, their contributions often go unrecognized and unmentioned, even by those closest to them.

“You’re not belong to the system you are over the system”

Back-end development teams frequently operate without the need to explain their actions to non-technical audiences. This is especially true when they are engaged in designing databases, adding or removing fields, executing migration processes, making critical changes, or requesting additional computational resources. Because these activities are largely invisible to end users and stakeholders outside the technical sphere, the teams can focus on ensuring the system’s stability and efficiency without needing to justify their decisions to those unfamiliar with the technical complexities involved.

Team Structure and Resource Allocation
Back-end development teams are sometimes larger than their front-end counterparts. This is often based on the understanding that the back end serves as the backbone of any software system. As a result, back-end teams tend to receive more financial and human resources. Whether or not this approach is ideal can be debated, but it reflects common practices in many organizations.

Noncommon skills for Back-End Developers

Global Risk Management
Back-end developers must always prioritize safeguarding the entire system over accommodating minor requests. The integrity and security of information are paramount; if critical data is lost, the consequences can be catastrophic. Therefore, if a proposed change introduces risk for the sake of a few users, it is better to avoid it. Protecting the whole system is more important than meeting individual demands.
Maintaining a Cold Mind
Regardless of circumstances, back-end developers need to think precisely and respond quickly to problems. Unlike front-end developers, who may have others to help address visible bugs, back-end developers are often the last line of defense. When issues arise, there is no backup team; they are the backbone of the system and must solve problems directly and efficiently, even under pressure.

Go Redis Crud quickly example

Luigi Escalante — Sat, 17 Aug 2024 19:46:38 +0000

Install dependencies and environment variable

Replace the values from database connection with yours.

#env file
REDIS_ADDRESS=localhost
REDIS_PORT=6379
REDIS_PASSWORD=123456
REDIS_DB=0

#install on go
go get github.com/redis/go-redis/v9

Manager Redis

Create a file to manage.go This will contain a method to get the connection with redis for instance in other modules and services.

package main

import (
    "fmt"
    "github.com/redis/go-redis/v9"
    "os"
    "strconv"
)

const CustomerDb = 0

type RedisManager struct {
    Db     int
    Client *redis.Client
}

func NewRedisClient(customerDb int) (*RedisManager, error) {
    address := os.Getenv("REDIS_ADDRESS")
    if address == "" {
        return nil, fmt.Errorf("REDIS_ADDRESS is not set")
    }
    password := os.Getenv("REDIS_PASSWORD")
    if password == "" {
        return nil, fmt.Errorf("REDIS_PASSWORD is not set")
    }
    port := os.Getenv("REDIS_PORT")
    if port == " " {
        return nil, fmt.Errorf("REDIS_PORT is not set")
    }
    db := os.Getenv("REDIS_DB")
    if db == "" {
        return nil, fmt.Errorf("REDIS_DB is not set")
    }
    redisDb, err := strconv.Atoi(db)
    if err != nil {
        return nil, fmt.Errorf("REDIS_DB is not a number")
    }
    cli := redis.NewClient(&redis.Options{
        Addr:     fmt.Sprintf("%s:%s", address, port),
        Password: password,
        DB:       redisDb,
    })
    return &RedisManager{
        Client: cli,
        Db:     customerDb,
    }, nil
}
func (rd *RedisManager) SetDb(db int) {
    rd.Db = db
}

Create Struct for manage the entity (customer) repository

Create a struct for manage the redis connection and Get all methods to interact with the redis entity (CRUD operations and queries)
With this struct, any time we need to access the entity (customer) data, we can instance and start to use it as a repository pattern.

type CustomerRepo struct {
    Cli *RedisManager
    Db  int
}

func NewCustomerRepo() (*CustomerRepo, error) {
    cli, err := NewRedisClient(CustomerDb)
    if err != nil {
        return nil, err
    }
    return &CustomerRepo{
        Cli: cli,
    }, nil
}

Create Struct entity

On Customers entity add the tags for mapped with bun fields.
The redis:"-" make de relation with the fields to save on redis. If you want one file or the struct doenst save just dont add the tag.

type Customer struct {
    ID    string `redis:"id"`
    Name  string `redis:"name"`
    Email string `redis:"email"`
    Phone string `redis:"phone"`
    Age   int    `redis:"age"`
}

CRUD methods

A method example to store, update or get information from the entity.
These methods are used from the CustomersRepo entity.
They received a customer entity with the information and depending on the operation return the result.

Save a new record

func (c *CustomerRepo) Save(customer *Customer) error {
    return c.Cli.Client.HSet(context.TODO(), customer.ID, customer).Err()
}

Get a record for ID

func (c *CustomerRepo) Get(id string) (*Customer, error) {
    customer := &Customer{}
    resMap := c.Cli.Client.HGetAll(context.TODO(), id)
    if resMap.Err() != nil {
        return nil, resMap.Err()
    }
    if len(resMap.Val()) == 0 {
        return nil, nil
    }
    err := resMap.Scan(customer)
    if err != nil {
        return nil, err
    }
    return customer, nil
}

Update a new record

func (c *CustomerRepo) Update(customer *Customer) error {
    return c.Cli.Client.HSet(context.TODO(), customer.ID, customer).Err()
}

Delete a new record

func (c *CustomerRepo) Delete(id string) error {
    return c.Cli.Client.Del(context.TODO(), id).Err()
}

Review the code example

Redis example for test it

Go Bun ORM with PostgreSQL Quickly Example

Luigi Escalante — Mon, 12 Feb 2024 00:05:54 +0000

Install dependencies and environment variable

Replace the values from database connection with yours.

export DB_USER=admin
export DB_PASSWORD=admin123
export DB_NAME=code_bucket
export DB_HOST=localhost
export DB_PORT=5432

go get github.com/uptrace/bun@latest
go get github.com/uptrace/bun/driver/pgdriver
go get github.com/uptrace/bun/dialect/pgdialect

Create table

Bun have a migration system, but I think it will be required its own post. For this quickly example

create table customers(
    id serial not null,
    first_name varchar(80) not null ,
    last_name varchar(80) not null ,
    email varchar(50) not null unique,
    age int not null default 1,
    created_at timestamp not null DEFAULT now(),
    updated_at timestamp null,
    deleted_at timestamp null
);

Manager DB

Create a file to manage.go This will contain a method to get the connection db for instance in other modules and services.

import (
    "database/sql"
    "fmt"
    "github.com/uptrace/bun"
    "github.com/uptrace/bun/dialect/pgdialect"
    "github.com/uptrace/bun/driver/pgdriver"
    "os"
    "sync"
)

var (
    dbConnOnce sync.Once
    conn       *bun.DB
)

func Db() *bun.DB {
    dbConnOnce.Do(func() {
        dsn := postgresqlDsn()
        hsqldb := sql.OpenDB(pgdriver.NewConnector(pgdriver.WithDSN(dsn)))
        conn = bun.NewDB(hsqldb, pgdialect.New())
    })
    return conn
}

func postgresqlDsn() string {
    dsn := fmt.Sprintf("postgres://%s:%s@%s:%s/%s?sslmode=disable",
        os.Getenv("DB_USER"),
        os.Getenv("DB_PASSWORD"),
        os.Getenv("DB_HOST"),
        os.Getenv("DB_PORT"),
        os.Getenv("DB_NAME"),
    )
    return dsn
}

Create Struct entity

On Customers entity add the tags for mapped with bun fields.

type Customers struct {
    bun.BaseModel `bun:"table:customers,alias:cs"`
    ID            uint      `bun:"id,pk,autoincrement"`
    FirstName     string    `bun:"first_name"`
    LastName      string    `bun:"last_name"`
    Email         string    `bun:"email"`
    Age           uint      `bun:"age"`
    CreatedAt     time.Time `bun:"-"`
    UpdatedAt     time.Time `bun:"-"`
    DeletedAt     time.Time `bun:",soft_delete,nullzero"`
}

the bun:"-" omit the field in queries. You can review all tags option on the official bun documentation. Bun tags

Create Struct for manage the entity (customer) repository

Create a struct for manage the db connection and Get all methods to interact with the database entity (CRUD operations and queries)
With this struct, any time we need to access the entity (customer) data, we can instance and start to use it as a repository pattern.

type CustomersRepo struct {
    Repo *bun.DB
}

func NewCustomerRepo() (*CustomersRepo, error) {
    db := Db()
    return &CustomersRepo{
        Repo: db,
    }, nil
}

CRUD methods

Save a new customer

func (cs CustomersRepo) Save(customer *models.Customers) (*models.Customers, error) {
    err := cs.Repo.NewInsert().Model(customer).Scan(context.TODO(), customer)
    if err != nil {
        return nil, err
    }
    return customer, nil
}

Update a customer data (Required the field ID)

func (cs CustomersRepo) Update(customer *models.Customers) (*models.Customers, error) {
    _, err := cs.Repo.NewUpdate().Model(customer).Where("id = ? ", customer.ID).Exec(context.TODO())
    return customer, err
}

Get a customer from one field

func (cs CustomersRepo) GetByEmail(email string) (*models.Customers, error) {
    var customer models.Customers
    err := cs.Repo.NewSelect().Model(&customer).Where("email = ?", email).Scan(context.TODO(), &customer)
    return &customer, err
}

Get a list of customers

func (cs CustomersRepo) GetCustomers() ([]*models.Customers, error) {
    customers := make([]*models.Customers, 0)
    err := cs.Repo.NewSelect().Model(&models.Customers{}).Scan(context.TODO(), &customers)
    return customers, err
}

Delete a customer (soft deleted)

func (cs CustomersRepo) Delete(customer *models.Customers) error {
    _, err := cs.Repo.NewDelete().Model(customer).Where("id = ?", customer.ID).Exec(context.TODO())
    return err
}

Review the code example

BUN CRUD Example

AWS S3 (SDK v2) in Go Quickly example

Luigi Escalante — Fri, 26 Jan 2024 22:14:34 +0000

Requirements

Get your AWS key and secrets from an Iam user in your AWS console and set as environments vars

AWS_KEY= <aws iam user key>
AWS_SECRET= <aws iam user secret>

Install the go dependencies

 go get github.com/aws/aws-sdk-go-v2
 go get github.com/aws/aws-sdk-go-v2/config

Code

Create a struct for manage the AWS Client It's a good practice to get this struct on an independent file to used if we want to implement mor3 AWS services.

File: manager.go
Parameters:
region: the AWS region (ex. us-east-1)

const AwsKeyEnv = "AWS_KEY"
const AwsSecretEnv = "AWS_SECRET"

type AwsConfigClient struct {
    config aws.Config
    region string
}

func NewAwsConfigClient(region string) (*AwsConfigClient, error) {
    key := os.Getenv(AwsKeyEnv)
    secret := os.Getenv(AwsSecretEnv)
    prov := credentials.NewStaticCredentialsProvider(key, secret, "")
    cfg, err := config.LoadDefaultConfig(context.TODO(),
        config.WithRegion(region),
        config.WithCredentialsProvider(prov),
    )
    if err != nil {
        return nil, err
    }
    return &AwsConfigClient{
        config: cfg,
    }, err
}

Create a struct for manager the common types. File: s3.go Parameters: cfg : An instance from the struct config (step 1) bucket: the name of the AWS Bucket

type AwsS3Client struct {
    config aws.Config
    bucket string
    s3     *s3.Client
}

func NewAwsS3Client(cfg *AwsConfigClient, bucket string) (*AwsS3Client, error) {
    client := s3.NewFromConfig(cfg.config)
    return &AwsS3Client{
        config: cfg.config,
        bucket: bucket,
        s3:     client,
    }, nil
}

Upload a file to an AWS bucket

Parameters:
path : the path and the file we want to upload (example: /files/test.txt)

func (cli *AwsS3Client) UploadObject(path string) (*manager.UploadOutput, error) {
file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    client := s3.NewFromConfig(cli.config)
    uploader := manager.NewUploader(client)
    result, err := uploader.Upload(context.TODO(), &s3.PutObjectInput{
        Bucket: aws.String(cli.bucket),
        Key:    aws.String(filepath.Base(path)),
        Body:   file,
    })
    if err != nil {
        return nil, err
    }
    return result, nil
}

Download a file from AWS bucket

Parameters:
fileName : the name of the file in the AWS bucket

func (cli *AwsS3Client) Download(fileName string) (*manager.UploadOutput, error) {
    client := s3.NewFromConfig(cli.config)
    downloader := manager.NewDownloader(client)
    file, err := os.Create(fileName)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    _, err = downloader.Download(context.TODO(), file, &s3.GetObjectInput{
        Bucket: aws.String(cli.bucket),
        Key:    aws.String(fileName),
    })
    return nil, nil
}

Delete a file from AWS bucket

Parameters:
fileName : the name of the file in the AWS bucket

func (cli *AwsS3Client) DeleteObject(fileName string) error {
    objectIds := []types.ObjectIdentifier{
        {Key: aws.String(fileName)},
    }
    _, err := cli.s3.DeleteObjects(context.TODO(), &s3.DeleteObjectsInput{
        Bucket: aws.String(cli.bucket),
        Delete: &types.Delete{Objects: objectIds},
    })
    return err
}

Get the AWS files list

func (cli *AwsS3Client) GetObjects() ([]types.Object, error) {
    output, err := cli.s3.ListObjectsV2(context.TODO(), &s3.ListObjectsV2Input{
        Bucket: aws.String(cli.bucket),
    })
    if err != nil {
        return nil, err
    }
    data := make([]types.Object, len(output.Contents))
    for i, object := range output.Contents {
        data[i] = object
    }
    return data, nil
}

GitHub code example

AWS s3 files

Agregar un acceso directo a una app en GNU/Linux Gnome

Luigi Escalante — Sun, 11 Jun 2023 01:34:11 +0000

Uno de los principales problemas cuando comenzamos a utilizar GNU/Linux con la interface de Gnome en la versión 42.3 o superiores, es agregar un nuevo icono a los menús principales.

Dependiendo la distribución de GNU/Linux que estemos usando puede haber opciones para poder hacerlo por medio de una interface grafica. En algunas versiones esta opción no está disponible.

Para estos casos vamos a crear de manera nativa el acceso directo de una app al menú de aplicaciones. Usaremos como ejemplo la aplicación de Goland IDE de la familia InteliJ.

Crear un archivo de texto dentro de nuestro sistema.

$ sudo vi /home/{tuUsuario}/.local/share/applications/{nuestraApp}.desktop

Ejemplo:

$ sudo vi /home/kaiba/.local/share/applications/goland.desktop

Editar el contenido del archivo con la información de la app

Agregar el siguiente contenido en el archivo que creamos. Cambiando los datos por los de nuestra aplicación.

[Desktop Entry]
Version=13.0
Type=Application
Terminal=false
Exec=/opt/goland/bin/goland.sh
Name=Goland
Icon=/opt/goland/bin/goland.svg

Y procedemos a buscar nuestro acceso directo en la sección de aplicaciones y ya nos aparece.

Instalar Java JDK en GNU/Linux

Luigi Escalante — Sun, 11 Jun 2023 01:27:42 +0000

Para instalar Java Jdk en linux son una serie de sencillos pasos.

Descargar el paquete de Java Jdk de la pagina de Oracle:

Se pude descargar de aquí. Es importante descargar la versión correcta si es de 32 o 64 bits. Ejemplo: jdk-8u40-linux-x64.tar.gz es la versión para Linux de 64 Bits.

Descomprimir el paquete.

En la terminal de Linux nos colocamos en la carpeta en donde descargamos el paquete para descomprimirlo con el siguiente comando:

tar xzfv jdk-8u40-linux-x64.tar.gz

Meter Java en los path de Linux

Esto es para poder usar java sin necesidad de estar indicando la ruta cada vez que utilizemos Java.

Configurar el path

Como super usuario y con un editor de texto como vim abrimos el archivo /etc/profile e introducimos lo siguiente al final del archivo.

#Java JDK
export PATH=/usr/local/jdk/bin/:$PATH
export PATH=/usr/local/jdk/jre/bin/:$PATH
export JAVA_HOME=/usr/local/jdk/jre

Actualizar nuestras configuraciones

Con el siguiente comando actualizamos nuestras variables sin la necesidad de reiniciar nuestro equipo.

source /etc/profile

Comprobar que todo se instalo de manera correcta.

en la terminal escribimos:

java --version

Y nos debera devolver lo siguiente:

java version “1.8.0_40”

Java(TM) SE Runtime Environment (build 1.8.0_40-b26)

Java HotSpot(TM) 64-Bit Server VM (build 25.40-b25, mixed mode)

Y con esto tenemos nuestro Java Jdk instalado.

Si tenemos 2 versiones de Java en nuestro equipo ejemplo Oracle JDK y Open-Jdk podemos cambiar cual queremos usar con el siguiente comando:
sudo update-alternatives --config java
Con esto nos muestra un listado con los JDK de Java instalados y solo tenemos que seleccionar el que queramos usar.

Selection    Command
-----------------------------------------------
   1           java-17-openjdk.x86_64 (/usr/lib/jvm/java-17-openjdk-17.0.4.1.1-1.fc36.x86_64/bin/java)
*+ 2           /usr/lib/jvm/jdk-19-oracle-x64/bin/java

Enter to keep the current selection[+], or type selection number: 2

Usar repositorios privados de GitHub en GO

Luigi Escalante — Sun, 11 Jun 2023 01:21:25 +0000

En ocasiones tenemos la necesidad de tener librerías provenientes de repositorios privados en GO, como por ejemplo librerías propietarias de la empresa, proyectos que aun estén en Sealthy Mode o funciones que no podemos exponer al publico en general.

Esto en GO puede generar problemas sobre todo al momento de querer descargar nuestra librería ya que se necesita de un proceso de autenticación de nuestra cuenta de Github.

Vamos a proceder a descargar una librería de un repositorio de GitHub privado.

PD: Dejo el repositorio con la librería de ejemplo (Como publica), la cual puedes hacer un fork a tu cuenta de GitHub y volverla privada para hacer al prueba con ella.

Generar token de autenticación en GitHub

En nuestra cuenta de GitHub ingresar a la sección de Settings > Profile > Developer Settings >Personal access token

Generar un personal access token y asignarle permisos full access private repo.

Copiarlo en algún block de notas de manera temporal, se usara mas tarde. Este token no lo vuelve a mostrar GitHub.

En la terminal dentro de la carpeta de nuestro proyecto en GO

Configuramos el token en Git

git config --global url."https://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:x-oauth-basic@github.com/".insteadOf "https://github.com/"
git config --global --add url."git@github.com:".insteadOf "https://github.com/"

Agregamos una variable de ambiente en nuestro sistema para que GO reconozca el repositorio aunque sea privado y vaya a buscarlo. Cambiar el valor GOPRIVATE por tu repositorio personal

export env GOPRIVATE=github.com/luigiescalante

Proceder a descargar en tu proyecto en GO

go get github.com/luigiescalante/package-helloworld

Ya puedes usar la librería privada dentro de tu proyecto en GO, Ejemplo:

DEV Community: Luigi Escalante

Choosing Your Path: Avenger (Front-End) vs Men in Black (Back-End)

Front-End Developers: The Avengers of Software Engineering

The “Heroes” from the Customer’s Perspective

Front-end developers, like heroes, are judged by society.

Noncommon skills for Front-End Developers

Back-End Developers: “We are men in black”

“Anonymous is your name, the silence your language, you will remember as maybe I saw you.”

“You’re not belong to the system you are over the system”

Noncommon skills for Back-End Developers

Go Redis Crud quickly example

Install dependencies and environment variable

Manager Redis

Create Struct for manage the entity (customer) repository

Create Struct entity

CRUD methods

Save a new record

Get a record for ID

Update a new record

Delete a new record

Review the code example

Go Bun ORM with PostgreSQL Quickly Example

Install dependencies and environment variable

Create table

Manager DB

Create Struct entity

Create Struct for manage the entity (customer) repository

CRUD methods

Save a new customer

Update a customer data (Required the field ID)

Get a customer from one field

Get a list of customers

Delete a customer (soft deleted)

Review the code example

AWS S3 (SDK v2) in Go Quickly example

Requirements

Code

Upload a file to an AWS bucket

Download a file from AWS bucket

Delete a file from AWS bucket

Get the AWS files list

GitHub code example

Related links

Agregar un acceso directo a una app en GNU/Linux Gnome

Crear un archivo de texto dentro de nuestro sistema.

Editar el contenido del archivo con la información de la app

Instalar Java JDK en GNU/Linux

Descomprimir el paquete.

Configurar el path

Actualizar nuestras configuraciones

Usar repositorios privados de GitHub en GO

Generar token de autenticación en GitHub

Configuramos el token en Git

Proceder a descargar en tu proyecto en GO