Forem: Victor Avelar

Navigating the current tech landscape.

Victor Avelar — Sat, 14 Feb 2026 13:23:43 +0000

I wrote a thing 😅

If you are feeling stuck in a stable role but are hesitant to jump into a tougher market, it is time to look at career growth through a different lens. I have put together some thoughts on why industry salaries are recalibrating, the two distinct paths for growth in the current landscape, and why understanding your core motivators is the only way to avoid the trap of a role you do not actually enjoy.

Read the full article: https://victoravelar.dev/articles/2026/navigating-the-current-landscape-growth-beyond-the-ladder/

Hacktoberfest 2023, a recap

Victor Avelar — Fri, 01 Dec 2023 11:10:33 +0000

Intro

VictorAvelar / VictorAvelar

My personal README.md

👋

I'm a Mexican engineer who enjoys coding.

I mostly write code in Go and PHP.

📫 You can reach me on twitter: @VictorAvelar

🔭 I’m currently working as Engineering Manager at @commercetools

View on GitHub

I've been taking part in Hacktoberfest for five years now. It initially began as a fantastic opportunity to enhance my coding skills, and over time, it has evolved into an event that I cherish and eagerly anticipate each year.

I mainly focus on Go projects because it's a language that I find thrilling to work with. Contributing to other repositories helps me learn and understand how various teams and companies address issues used by hundreds, if not thousands, of developers daily. Open source, for me, is an excellent learning experience.

Growth

During Hacktoberfest, I've found that I've been continuously developing skills, and surprisingly, they lean more towards the soft skills side. Interacting with maintainers and PR reviewers has helped me improve my communication, develop a direct yet friendly tone, and has proven to be an excellent source of feedback.

Final thoughts

I'm a bit sad that the t-shirts won't be given out this year, but I completely understand the logistical and environmental reasons behind this decision. Although it wasn't the main reason for me to join this amazing event, I must admit that I'll miss the t-shirts and the wonderful sticker bundles a lot.

Hiring!

Victor Avelar — Mon, 07 Sep 2020 12:01:44 +0000

Hey guys! hope you are all doing fine.

We have a couple of open positions at the team I am in charge of, I thought about dropping them here, probably someone it's looking for a new challenge.

Backend engineer: https://company.trivago.com/jobs/r4575346002/

Fullstack engineer:https://company.trivago.com/jobs/r4805198002/

GCP Engineer: https://company.trivago.com/jobs/r4470015002/

If you wanna discuss feel free to reach me on twitter or linkedin.

Software engineering interviews AMA

Victor Avelar — Mon, 04 Nov 2019 13:42:39 +0000

I've been conducting coding interviews for some time and I will like to help you answer questions you might have about it.

I am not a recruiter, I do the so-called "technical interview" so lets share and hopefully help someone to hit a home run on their next interview.

Some topics I think you might be curious are:
preparation, approach, tools, common pitfalls, etc...

So go on and shoot 😄

Side note

I am thinking about sparing some time to do mock interviews with some newcomers to the software industry, so if you are interested please let me know and we can check a way to sort it out.

ANNOUNCEMENT - DEV from your WTF terminal

Victor Avelar — Mon, 23 Sep 2019 07:51:13 +0000

The module has been released, and I just want to share the docs with you, so that you can take a look.

If you haven't try WTFutil, you should.

DEV on WTF

The devto module

Victor Avelar — Fri, 20 Sep 2019 17:53:43 +0000

⚠️ The module is up and awaiting for review ⚠️

Here is the source code

Implementation of WTF devto module #644

VictorAvelar posted on Sep 20, 2019

View on GitHub

Thoughts on the process

There is a lack of explicit information on how to create modules, so if you are eager to create a module you will need to read tons and tons of code.

Another thing that I found tricky was properly configuring the keyboard integration, but there are amazing modules with this feature that you can copy and modify.

Make sure to read the CONTRIBUTING.md file before starting, it will allow you to plan the development with all the requirements.

Finally, please update the docs, if you take a look at the source code, you will find a lot of good modules that have poor or no documentation at all.

The process

Get familiar with Go Modules as it is the dependency management system used by wtfutil/wtf.
Check the existing modules so that you can get ideas and also so that you understand how everything works.
If you're going to install some modules this is the time, for the current module, I just used the API client we built along this series.
VictorAvelar / devto-api-go

A go client for the dev.to API
devto-api-go

A go client for the dev.to API

Travis CI

Scrutinizer

Go ecosystem

Roadmap
- Base client and configuration
- Articles resource
- CLI utility
- Authentication resource
- Extend the tests suite
- Provide code examples
Disclaimer

This library is not an official dev.to API library, but a friendly contribution to the dev.to community
View on GitHub
Go to the modules directory and create a sub directory to start coding, for this module it is modules/devto

The files

It will be possible to have everything in one file, but I like to split the code so that the filename refers to the content.

After checking how the hackernews module works (which heavily inspired this whole series) I have a good idea of what I need.

In keyboard.go we are going to place all the keyboard bindings for our module, we need to be able to navigate from one history to another, and also we need to be able to open the content in our default browser.

So to make things easier, I will put here a screenshot from the module documentation:

Code wise it is not that amazing, here you have the fragment that accomplishes this functionality

func (widget *Widget) initializeKeyboardControls() {
    widget.InitializeCommonControls(widget.Refresh)

    widget.SetKeyboardKey(tcell.KeyDown, widget.Next, "Select next item")
    widget.SetKeyboardKey(tcell.KeyUp, widget.Prev, "Select previous item")
    widget.SetKeyboardKey(tcell.KeyEnter, widget.openStory, "Open story in browser")
    widget.SetKeyboardKey(tcell.KeyEsc, widget.Unselect, "Clear selection")
}

In settings.go you grab the values from the user's config.yaml file and put it into your Widget.

And here is the yaml to use this module:

devto:
  enabled: true
  numberOfArticles: 10
  position:
    top: 1
    left: 1
    height: 1
    width: 2
  contentTag: "showdev" 
  contentUsername: "victoravelar"
  contentState: "rising"

And finally the widget.go, TBH this is just the hackernews widget file with some customization to make it work with the dev.to API.

Conclusions

It was not as hard as expected, and I hope a lot of people is able to get the articles from this community straight to their terminal.

Do your own and please let the world know.

My solution to Code challenge #77

Victor Avelar — Thu, 19 Sep 2019 08:27:20 +0000

Implemented in golang, quite easy to be fair 😄

func GetNthFib(n int) int {
    if n == 1 {
        return 0
    }
    if n == 2 {
        return 1
    }
    x, y := 0, 1
    for i := 2; i < n; i++ {
        x, y = y, x+y
    }
    return y
}

Explanation

So we check for the first two value as this two are required to be able to build the rest of the sequence.

Once we know it is not 0 (x) or 1 (y), we know that the correct result comes from adding the x+y and moving the values 1 place forward.

The loop starts at 2 because otherwise the results will be offset by 2 iterations (we already check the first two statically).

For example, if the loop starts at 0 and they ask for nth 3, then our result will be 3 which is incorrect as the third position on Fibonacci's sequence is 1.

You can play around with it by using this Golang Playground link

Episode 5 - Adding resources to your Client

Victor Avelar — Wed, 18 Sep 2019 12:34:06 +0000

So after being at the Alps for some days, here we go again.

What is a resource?

According to https://restful-api-design.readthedocs.io a resource is described as follows:

The fundamental concept in any RESTful API is the resource. A resource is an object with a type, associated data, relationships to other resources, and a set of methods that operate on it. It is similar to an object instance in an object-oriented programming language, with the important difference that only a few standard methods are defined for the resource (corresponding to the standard HTTP GET, POST, PUT and DELETE methods), while an object instance typically has many methods.

This means that when adding a resource this will allow us to perform operations with our client on specific and well defined types.

How to add a resource to a client?

We create a resource type to hold the methods to interact with articles, this will contain a pointer to our devto.Client implementation,

// articles.go

type ArticleResource struct{
    API *Client // this will receive a pointer to your client instance
}

And then we attach this using the client constructor

you can see a working example in the repository

VictorAvelar / devto-api-go

A go client for the dev.to API

devto-api-go

A go client for the dev.to API

Travis CI

Scrutinizer

Go ecosystem

Roadmap

Base client and configuration
Articles resource
CLI utility
Authentication resource
Extend the tests suite
Provide code examples

Disclaimer

This library is not an official dev.to API library, but a friendly contribution to the dev.to community

View on GitHub

From now on, we are up for the wtfutil part.

Episode 4 - Types

Victor Avelar — Wed, 11 Sep 2019 08:05:17 +0000

📷 Photo by Amador Loureiro on Unsplash

Hey we are getting closer to being able to use dev.to API.

What is a type

According to this article that is the definition I find easier to understand

The type system is the most important feature of a programming language, letting you organize your application data. Go follows a minimalist approach for its type system. It provides several built-in types such as string, bool, int and float64.

You can think of a type like described there with primitives, this describes the space in memory needed and the type of data that is going to be allocated there.

For example for a type user:

// User contains information about a devto account
type User struct {
    Name            string  `json:"name,omitempty"`
    Username        string  `json:"username,omitempty"`
    TwitterUsername string  `json:"twitter_username,omitempty"`
    GithubUsername  string  `json:"github_username,omitempty"`
    WebsiteURL      *WebURL `json:"website_url,omitempty"`
    ProfileImage    *WebURL `json:"profile_image,omitempty"`
    ProfileImage90  *WebURL `json:"profile_image_90,omitempty"`
}

We are telling the go compiler that every time something has the devto.User type assigned it should allocate enough space in memory to place an object with this structure.

Here you have an amazing repository with a lot of go examples

WTF are those things after the type?

Those are called tags, and for me it's kinda the go way of doing annotations, coming from PHP at least this is how it looks like.

The Go spec in the Struct types definition defines tags as:

A field declaration may be followed by an optional string literal tag, which becomes an attribute for all the fields in the corresponding field declaration. An empty tag string is equivalent to an absent tag. The tags are made visible through a reflection interface and take part in type identity for structs but are otherwise ignored.

This will helps us to do something called JSON unmarshalling, but hold your horses, we are not there yet!

The practical dev types

For getting the types you need to analyze the example responses from the API documentation, we will use the Get article spec because for the create request we have only the parameters we are supposed to submit, in the get article endpoint you get the article information plus all the metadata devto is adding in the background.

Now nesting structs when creating types is not a road I will recommend you to take, because it gets messy quite fast, instead try to start breaking every nested object to its own type.

So you can check the types I've come up with in the project repository, I also added some custom unmarshalling for the URLs.

Here I will just leave the devto.Article type, which is the main dev.to type.

// Article contains all the information related to a single
// information resource from devto.
type Article struct {
    TypeOf                 string       `json:"type_of,omitempty"`
    ID                     uint32       `json:"id,omitempty"`
    Title                  string       `json:"title,omitempty"`
    Description            string       `json:"description,omitempty"`
    CoverImage             *WebURL      `json:"cover_image,omitempty"`
    SocialImage            *WebURL      `json:"social_image,omitempty"`
    PublishedAt            *time.Time   `json:"published_at,omitempty"`
    EditedAt               *time.Time   `json:"edited_at,omitempty"`
    CrossPostedAt          *time.Time   `json:"crossposted_at,omitempty"`
    LastCommentAt          *time.Time   `json:"last_comment_at,omitempty"`
    TagList                Tags         `json:"tag_list,omitempty"`
    Tags                   string       `json:"tags,omitempty"`
    Slug                   string       `json:"slug,omitempty"`
    Path                   *WebURL      `json:"path,omitempty"`
    URL                    *WebURL      `json:"url,omitempty"`
    CanonicalURL           *WebURL      `json:"canonical_url,omitempty"`
    CommentsCount          uint         `json:"comments_count,omitempty"`
    PositiveReactionsCount uint         `json:"positive_reactions_count,omitempty"`
    PublishedTimestamp     *time.Time   `json:"published_timestamp,omitempty"`
    User                   User         `json:"user,omitempty"`
    Organization           Organization `json:"organization,omitempty"`
    BodyHTML               string       `json:"body_html,omitempty"`
    BodyMarkdown           string       `json:"body_markdown,omitempty"`
    Published              bool         `json:"published,omitempty"`
}

Take a look raise your questions and contribute if you feel like something is not right.

VictorAvelar / devto-api-go

A go client for the dev.to API

devto-api-go

A go client for the dev.to API

Travis CI

Scrutinizer

Go ecosystem

Roadmap

Base client and configuration
Articles resource
CLI utility
Authentication resource
Extend the tests suite
Provide code examples

Disclaimer

This library is not an official dev.to API library, but a friendly contribution to the dev.to community

View on GitHub

Episode 3 - The configuration struct

Victor Avelar — Fri, 06 Sep 2019 11:48:53 +0000

Before you read

Thanks for spending some minutes reading this, I just want to let you know that from time to time, my ideas are like spaghetti, so if something is not 100% clear, please ask and I will be super happy to answer, probably we will both end with something new to spread around.
😄

Whenever you create a library in any programming language planning how your configuration objects is going to be implemented is super important, as in my opinion it heavily influences the way the code will look and behave.

So for our lovely API client, we are going to have a Config struct, in which we are going to pass the values that are:

Filled from environment variables or secrets.
Variables that affect overall the code behaviour

The first one is pretty much self-explanatory, you don't want to fetch your secrets from Vault (and not this is not sponsored, it just happens to be the one I am familiar with), or require the os package everywhere just to be able to call Getenv.

For our use case we have then the following configuration struct

type Config struct {
    APIKey       string
    InsecureOnly bool
}

As you can see it is convenient that we have one property for each of the scenarios described before, APIKey will be probably filled from a "secure" source that is not visible from your version control system for example, unless you want everyone being able to play around with your dev.to articles.

InsecureOnly is something that will affect how the API client will behave when performing requests to the API.

The constructor

Constructors in go as we are about to see, allows you to control how your client will be build, it is possible that the user will instantiate the struct directly, but as we want to be helpful as possible, we will also provide a friendly way to build a usable Config object.

func NewConfig(p bool, k string) (c *Config, err error) {
    if p == true && k == "" {
        return nil, ErrMissingRequiredParameter
    }

    return &Config{
        InsecureOnly: !p,
        APIKey:       k,
    }, nil
}

Our Config constructor takes a boolean (p) and a string (k), where p represents whether we will use protected endpoints or not, and k is our API key, now once we provide this values the constructor will check and react according to our input.

This check will save us some time, and also will save the dev.to API some unnecessary requests, if we say we want to access protected endpoints but we provide no key, then is obvious that when we perform the request the API is going to give us a lovely http.StatusUnauthorized.

Now if p is false we don't care about the key as for public endpoints a key is not required.

Now, be careful as p is something I like to call a user-friendly variable, this means you are asking the user for something that they can understand: Are you going to access protected endpoints?, easily than: Do you need the client to be insecure only?.

The second one may lead some people to crazy security assumptions, I will probably bet someone could even make a relation with HTTP/HTTPS, so in order to be as clear as possible, we will ask the user-friendly question and then take the opposite value that satisfies our configuration requirements.

And here is an example of how we will use it

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/VictorAvelar/devto-api-go/devto"
)

var (
    k string
    p bool
)

func main() {
    k = os.Getenv("DEVTO_API_KEY") // if not set you will get an empty string
    p = true
    c, err := devto.NewConfig(p, k)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v", c)
}

See it in action at the Go playground

A DEV.to API client is born

Victor Avelar — Tue, 03 Sep 2019 11:07:53 +0000

Episode 2 - Project foundation

So let's get going, be sure to have golang installed in your computer, if like me you're using macOS and Homebrew then you just need to execute the following command:

brew install go

The API client

The module we are going to create will showcase the top 10 links to avoid a huge display block.

For this, we will need to access the information from devto API and for this, we need code to programmatically access this information and be able to use it.

So let's start

The project directory

Open a terminal window and navigate to the place where you store your go code, thanks to the implementation of go modules it doesn't need to be the src folder inside the $GOPATH so I will navigate to ~/Code on my terminal.

We are going to create the directory in which our module is going to live and then we will go inside the recently created folder, you can accomplish this by executing the following

mkdir devto-api-go && cd devto-api-go

Initializing Go modules support

To initialize a Go module you need to execute the init command of the go mod tool, so let's do it, first I will put the "template" and then the actual execution, I like to do this because that is how my brain stores information, so sorry if it's confusing.

⚠️ This is important ⚠️ as you learn go you will
understand that some of the go tooling for using third party code
relies on git features.

So when initializing a module you should use the path to your
repository in the form of {provider}/{username}/{repository}

I like to think of it as a mock for the folder structure I would have created if using the $GOPATH.

So from now on, I will use path-to-your-repo to alias the composition described in my previous quote.

# Template for initializing a new go module once you're inside the 
# project directory
go mod init {path-to-your-repo}

Which for our project will be

# Template for initializing a new go module once you're inside the 
# project directory
go mod init github.com/VictorAvelar/devto-api-go

Please don't be surprised if nothing comes back, you will also get used to the fact that in go, no news are amazing news 😂

The final touch

Once our module is ready, you can create a folder called devto, there is no reason for this, it is a thing I picked, but I cannot remember how 🤔, but it will be useful in the future, I can promise that.

Finally this is how your go.mod file should look like

module github.com/VictorAvelar/devto-api-go

go 1.12

Building a WTF util from 0 to hero

Victor Avelar — Sat, 31 Aug 2019 10:34:49 +0000

Photo by Caspar Camille Rubin on Unsplash

Episode 1 - Why the fuck (INTRO)

Not so long ago I discovered wtfutil an amazing developer oriented tool to monitor, check and browse a lot of stuff, it operates with modules and there is a module that I always find very useful called news.

This modules allows you to see a list of the latest HackerNews articles and if you decide it is interesting enough, you can click on it and it will open the related article on your default browser, which for me is amazing because anyway I'm checking the website every day.

It is basically this daily routine what got me thinking, which other websites I'm checking often to be up to date with news around the tech world, here is where I had an Eureka moment and though well if this thing is not out yet, lets create it.

The approach

First of all I love to share the few things I know, even if its not the best way of doing it I'll share it, and then when someone says hey this can be also done this way, I learn something new, and this is a golden cycle you should try, so for me this will be like a tutorial series on how to approach this from the initial project directory, till having the tool ready to be used by the wtfutil users.

So stay tuned.

Cheers 🍺

Resources

wtfutil / wtf

The personal information dashboard for your terminal

WTF (aka 'wtfutil') is the personal information dashboard for your terminal, providing at-a-glance access to your very important but infrequently-needed stats and data.

Used by thousands of developers and tech people around the world, WTF is free and open-source. To support the continued use and development of WTF, please consider sponsoring WTF via GitHub Sponsors.

Awesome! See here for how you can change the exit message, the message WTF shows when quitting, to something special just for you.