← Back to Posts

If I attempt to reply to a friend on Instagram, I’ll find myself checking stories, watching a few reels and liking posts - “So many interesting things are going on!” The simple notification has gone from a quick check to a deep dive into many different worlds. Going back to writing text or coding is not as stimulating. My brain would end up being very disappointed. After years of dealing with this during my education and career the detriments of the technology became clearer.

The problem was two fold - One, I completely forgot what I was doing before and now I’m on my phone for the 12th time. The second problem is that I’ve found myself in a viciously addictive environment again. It’s hard to get out of dopamine hell. While I check all cool reels and stories I quickly lose track of time and find myself bouncing between multiple apps. Each notification pulls me in like a blue light attracting a mosquito *ZAP*. Hours gone in a way that’s opaque to me by the end of the day. I check my screen time at the end of the day and gasp in horror - Some days I’d see up to 4 hours on that one application.

The same justification was always used.

I’ll check a few things, respond quickly and I’ll get back to whatever I was doing

“It’s a new day” I say - “I won’t be addicted today” I tell myself. “Productive activities are all that I will engage in”. “Let me place my phone over there far away and I’ll be good”. A few hours go by and my productivity is pretty good. Focus, flow, and at this point I won the war against my phone. *Ring Ring Ring* I run to my phone and see it’s my mother so I answer it. “Hey mom, how are you doing? I’m doing well. I’ll come over at 6PM and have dinner. Ok … love you too … bye!”. That was a nice wholesome phone call right? Well now this evil device is in my hand again.

I know! I have a great idea! I deserve to be rewarded for my hard work and focus - “Let me check my favorite social media platform - Instagram time!” Thirty minutes go by and I realize I’ve seen enough coffee reels. Let me go make a coffee too and I’ll get right back to what I was doing. These mini episodes of checking your phone are slowly making you go mad. We need to fight back somehow. This cycle may or may not repeat itself multiple times throughout your day.

I’ll check a few things, respond quickly and I’ll get back to whatever I was doing Stop Ahmad STOP
There has to be a better way to deal with this

Through some miracle I stumbled upon Cal Newport’s books Digital Minimalism, and Deep Work. I told myself that I’d apply some of the principles found in these two books. The most important one being “Do Not Disturb”. I needed to dumb my phone down and prevent it from pulling me in. Do Not Disturb helped me avoid almost every single notification on android. Don’t worry, my loved ones could still message and call me. I set up exceptions for necessary contacts.

The other thing I did was remove Instagram because that application is a black hole. The reasons I used Instagram were not compelling enough for me to have access to it 24/7. I instead moved to using the web version. The web version is less addicting and my addiction slowly faded into nothing.

After about 2-3 years I can only imagine how many hours I’ve saved myself. 3-4 hours a day over the course of 2-3 years adds up. We’re talking something like 2-3k hours?!

I’d highly suggest for anyone wanting to deal with this to come up with a plan. To avoid doom scrolling and being sucked in - to the roulette machine. Cal’s books are a good starting point. He may convince you to use them in a way that’s less detrimental than the way these apps were designed to be used.

Prior to learning about blockchain I’d learned about how open source development can be a great learning tool and experience. There were many projects to choose from so at first I wasn’t sure which project to work on. After some research I decided to contribute to the Chainlink project. The project attempts to solve what’s known as the Oracle problem for blockchains.

The blockchain oracle problem refers to the inability of blockchains to access external data, making them isolated networks, akin to a computer with no Internet connection. Bridging the connection between the blockchain (onchain) and the outside world (offchain) requires an additional piece of infrastructure—an oracle.

from chain.link

Chainlink also piqued my interest because the developers used Go, Ethereum and Solidity which were technologies I found interesting and wanted to learn about. I immediately jumped in and over the course of a year I began working on various tasks like building out new command line commands, adding pagination to API endpoints, and contributing to the core of the chainlink node.

The project is an example of an excellent codebase. I reference the chainlink codebase still today for best practices in Go standards and overall design. The other great thing I got out of contributing to it was meeting some very talented people and they helped me grow.

Steve Ellis (Cofounder of Chainlink) and the maintainers provided me with great feedback. That feedback was invaluable in helping me learn about Go, design patterns, and working with others remotely. This turned out to be a great decision because everything became remote during the COVID era.

If you’re looking to learn about a specific set of technologies while working on a project that’s interesting to you then try dabbling with open source. You’ll most likely find projects that are enjoyable and a breath of fresh air. In the open source world you don’t necessarily need to contribute code to benefit. Being able to observe and study popular technologies is highly beneficial too.

Work that’s contributed to open source impacts many people in a profound way. Millions of developers rely on various open source technologies to build software without having to reinvent the wheel. It’s rewarding and fascinating that my code has been running on potentially thousands of different machines.

In the end I was able to use open source as a tool to assist me in learning new skills, advance my career, and meet knowledgeable people. If you want to advance your understanding in any technology then give open source a try.

← Back to Posts

I’ve devised an alias that helps you find that lovely little command you like to run. fa. To know what find alias does (fa) we need to find it.

1➜  blog git:(master) fa fa
2fa='alias | grep'
3gfa='git fetch --all --tags --prune --jobs=10'
4gofa='go fmt ./...'

This alias helps us search and grep for aliases by simply typing fa keyword. I’ll conclude with how I use it.

I need to see commands that deal with volumes. So I type fa volume and I get the following.

1➜  blog git:(master) fa volume
2dvi='docker volume inspect'
3dvls='docker volume ls'
4dvprune='docker volume prune'

If you want to have this alias for yourself simply add it to your bash/zshrc.

1alias fa='alias | grep'

← Back to Posts

As a developer I’ve been using this strategy to mentor/pair/think with teammates. When I mentor or onboard someone new I spend a bit of time each week pairing with them. This is the only chance I usually get to understand the person at a deeper level. I’m then able to determine what kind of resources that person needs. The individuals that work with me on this always end up teaching me something new too.

I noticed that the meetings tend to be very productive where a lot of information and knowledge is shared rapidly. I’ve shared many small tips and tricks related to software development. Once I showed a teammate how good fzf was and it blew their mind. The biggest advantage is that both people level up and can usually focus really well.

Keep these sessions short and sweet and if you’re finding them extremely advantageous do them regularly.

Not everyone likes to do this because some people are introverted but some love it.

← Back to Posts

There have been instances where I’ve had to make adjustments in my code so that I could get tests to pass locally. Some developers might accidentally write unit tests without knowing that those unit tests will fail on another machine in a different timezone. Code that will fail on a different machine can look like this.

1// this code asserts that the timestamp is equal to the value below
2// assume the one who wrote this has their machine set to UTC
3got := time.Unix(1729825337, 0).Format(time.RFC3339)
4assert.Equal(t, "2024-10-25T03:02:17Z", got)

If you run the above 2 lines on a machine not in the utc timezone you’ll get an error. This is because time.Unix will use the local timezone of the machine.

Output on my machine

 1➜  days git:(master) go test
 2--- FAIL: TestTimeAssertion (0.00s)
 3    time_test.go:24:
 4        Error Trace:    time_test.go:24
 5        Error:          Not equal:
 6                        expected: "2024-10-25T03:02:17Z"
 7                        actual  : "2024-10-24T22:02:17-05:00"
 8
 9                        Diff:
10                        --- Expected
11                        +++ Actual
12                        @@ -1 +1 @@
13                        -2024-10-25T03:02:17Z
14                        +2024-10-24T22:02:17-05:00
15        Test:           TestTimeAssertion
16FAIL
17exit status 1
18FAIL    github.com/whatsadebugger/golangplaybook/days   0.115s

There is a short and sweet solution. You could match your timezone to match what’s written in the test. This helps you avoid rewriting many lines of code where the timezone is using local time. This approach is sometimes seen as a hack rather than a fix by some.

1➜ TZ="UTC" go test
2PASS
3ok      github.com/whatsadebugger/golangplaybook/days   0.112s

When writing code it helps to validate that it can work on any machine to reduce friction. This helps developers/consumers of the application tremendously. In my career I’ve seen many instances where it’s difficult to run go test without setting up dependencies.

Setting the timezone explicitly here creates a specific expectation that’s reproducible across machines.

1got := time.Unix(1729825337, 0).UTC().Format(time.RFC3339)
2assert.Equal(t, "2024-10-25T03:02:17Z", got)

Thank you for reading.

← Back to Posts

When creating a new function or api one might assume that the caller of that api is very familiar with it. This assumption can lead to friction and potentially make it more difficult for the consumer. A good interface should assume the caller has as little understanding as possible.

The go ecosystem contains some examples where documentation is easy to consume and learn from.

Let’s show an example from the fmt package explaining fmt.FprintF. This example is taken from here. I’ve also added the go doc string below.

Fprintf formats according to a format specifier and writes to w. It returns the number of bytes written and any write error encountered.

func main() {
    const name, age = "Kim", 22
    n, err := fmt.Fprint(os.Stdout, name, " is ", age, " years old.\n")

    // The n and err return values from Fprint are
    // those returned by the underlying io.Writer.
    if err != nil {
    fmt.Fprintf(os.Stderr, "Fprint: %v\n", err)
    }
    fmt.Print(n, " bytes written.\n")
}

Output:

Kim is 22 years old.
21 bytes written.

This example does multiple things well. It explains what it’s going to do with your input and it explains how it’s going to respond. I don’t think you’ll need to jump inside of that function to read it’s implementation any time soon.

In an ideal world you’d have an interface that callers could intuitively understand and utilize with minimal effort.

Here’s a fantastic resource that I used early on in my career to learn go. gobyexample.com

← Back to Posts

This all began back in 2012 when I began studying computer science at the University of Texas at Dallas. Programming was a new concept to me at the time and it was tough at first. The courses that we attended back then focused on the OG curriculum of C++, Java, Data structures, Algorithms, and various Operating Systems classes. Graduation approached much quicker than I could have ever anticipated. My job search was concluded after no-lifing a Java book for many hours in my last semester.

Jail software is an interesting domain to start with as a fresh software engineer. Jail software makes you realize that even inmates are at the mercy of computers. This organization was also pretty OG as they were still using Visual Basic, and many many different versions of Visual Studio. The initial setup took days and many agonizing hours of tuning windows to have the right settings and version. The engineers that worked here were spectacular and friendly. The office was quiet and filled with cubicles which I came to realize later on were actually not that bad. One day during lunch I learned about blockchain. After a few conversations about how revolutionary this technology was I wanted to learn more. This led me to contribute to some open source projects written in Golang.

My first introduction to Golang was in 2017 where I contributed to Chainlink an Oracle software (connect blockchains to the internet). Golang became my bread and butter and miraculously it turned out that many companies were looking for this language. After attending a Golang meetup hosted at Toyota Connected I applied to work there.

At Toyota I worked on supporting and building the in vehicle virtual assistant. That assistant uses real time voice data to assist users in navigation and other various domains like calendar. The goal of this project was to use machine learning models that we trained ourselves to figure out what a user wants. If they wanted to go to Starbucks we’d route them there in real time. Testing this project was difficult due to the probabilistic nature of machine learning systems. We had to ensure none of our use cases broke during a deploy. This led to a very comprehensive integration testing framework that’s in use till today.

Toyota also taught me about the “fun” world of kubernetes. As a developer there were already enough things to learn and master. In a serious sense I’d describe kubernetes as container orchestration platform that makes it easy to deploy hundreds of services in real time. Along with monitoring and rollback capabilities and many other deployment steroids. A less serious description I’d give kubernetes is that it’s just YAML. Kubernetes is YAML.

After spending some time writing go/python at a few companies I eventually end up working at Bitly where I wrote more Golang.

I was on the QR Code team building and maintaining a new product. QR Codes are everywhere and this was an impactful project. We built a system to generate QR Codes in real time but they also had to be more aesthetic. At first the QR Codes product only had minor customizations and a few color options. As a team we improved it a lot in a short time span. We added the ability to create any color, color gradients, crazy shapes, frames, and templates (preset settings of colors).

Since my first day of programming I developed a love for using the terminal. I’m not sure why I started obsessively using the command line but it drew me in for being insanely cool. Being a command line user leads you down different rabbit holes of hacker like optimizations. Vim is one of those optimizations that will always show up if you spend any time in the terminal. If you start learning vim you’ll wonder why a sane person would do this to themselves. There is no autocomplete in most cases and moving requires spamming ctrl-d and ctrl-u all day to navigate files. Eventually I became some sort of wizard to everyone.

As a backend engineer in a distributed systems it was a necessity to have good debugging and profiling skills. These are my favorite tools to understand what happens at a deeper level in any system. The skills came in handy every time there was a memory leak or weird bug. It helps being able to set break points and follow the execution of a program.

After learning the coolest technology and techniques I began teaching others. Explaining things simply to others is something I excel at doing. Once I grasp a concept or idea my goal is to help impart that knowledge to others so that everyone benefits.

Non Exhaustive list Technology that i’ve used

• Golang
• Kubernetes
• Git
• Bash
• cloud ( Amazon web services, Google Cloud Platform )
• pprof (golang’s performance profiler)
• debugging ( delve )
• Chainlink
• Datadog
• Redis
• Postgres
• Docker
• Make
• Google APIs
• Building and Integrating Oauth

Contact/Online Presence
Github
Linkedin
Resume