Forem: Abdulmumin Akinde

There's No Magic: Only Abstractions

Abdulmumin Akinde — Fri, 24 Jan 2025 22:05:37 +0000

"Magic is just an abstraction you don't understand."

I came across a post from Preston Thorpe, a brilliant, incarcerated software engineer. He wrote an article about how he became a professional software engineer from the prison. No, you aren't hallucinating. Prison! Truly inspiring, but I digress.

I then checked out another of his posts titled "Magic isn't real." While this is already beautifully written and packed with lessons and nuggets, it made me reflect on my own journey, and I thought to share.

In my experience learning how to code and solving problems with technology, I have come to realize that "magic" is really just a level of abstraction you haven't uncovered yet. Everything I know and can explain today was once wrapped in this dark shroud of mystery that I thought I would never be able to demystify. However, as I continue to learn and broaden my knowledge scope, things that seemed inaccessible at first suddenly (or eventually) become easy to make sense of. Trust me when I say there are a lot of instances. I am sure it's same for you too.

I remember writing my first fullstack app with Django. Anybody remotely familiar with this framework knows it's batteries-included and very opinionated. This means that you trade ultimate customizability for a relatively fast development experience. It however comes at a cost, especially if you're a beginner who wants to know how things work under the hood.

Django abstracts away a lot of implementation details and provides extensive boilerplate code needed in spinning up a robust server. As a result, beginners might find it tricky to immediately understand important server-side concepts like session management, middleware, among others.

I definitely didn't at the time. Middlewares especially felt "magical." In Django, you just define a class, implement some methods and Django does all the "heavy-middleware-lifting" for you behind the scenes. In fact, now that I think about it, this was supposed to be the "beginner-friendly" way to introduce the concept of middleware. But I did not get it. And I like to get things, so you can imagine my dissatisfaction.

At the time, I attempted to learn what middlewares were, but I ended up only having a surface-level knowledge of the concept. I just knew it was some logic that runs before your main (business) logic. Because I did not have to explicitly implement it on my own, I could not really appreciate it on a deep level like I desired.

Not until I started writing Go. You see, Go offers a more low-level approach when it comes to server-side development. You have more granular control of how things should be implemented compared to Django. This is also thanks to Go's powerful standard (http) library. But again, like everything in tech and system design, there is always a tradeoff. In this case, you enjoy flexibility at the expense of complexity, which may impact development experience and timeline. Things are a bit more low-level in Go compared to Django.

While writing Go, I was forced to think about how I would manage issues like session management and middleware chaining without the heavy abstractions. Only then did it really start to make sense. Now understand that this is a very simplistic example, but I really thought only superstar devs could write up middleware and bootstrap it in a framework like Django so that regular devs don't have to bother understanding it. This experience is also personal, and I don't imply that everybody learning Django would not be able to understand what middlewares are at a deeper level. It just happened that I needed to go a bit more low-level to really get it. Seeing how the request flow got modified was beneficial to my understanding.

Some people argue that you don't necessarily need to get into the weeds of how things work under the hood. I strongly disagree. Experienced developers thrive on their ability to understand technological layers below their current working level. You might ask, "Why does this level of understanding matter?"

Take networking, for instance. If you are working with HTTP, do you know how and why it works? Do you know what TCP is and how it helps http? And if you understand TCP, do you understand why and how TCP is built on IP? I can go on. Again, I think this is important because sometimes abstractions leak. If you don't understand the abstracted technology, you will have a hard time debugging issues that will inevitably come up. The deeper you can go into these bottom layers, the better troubleshooter/developer you will be.

Which brings me to a beautiful line in Preston Thorpe's post:

"This is just a reminder to everyone at different levels of their developer journey, that the “magic” is not real and the overwhelming majority of the time, you are simply lacking the necessary context and it will likely make perfect sense to you as soon as you have it."

I thought the line just sums it up.

Takeaway? Understand that the "magical" concept you are currently struggling with is not inaccessible to you. You just haven't gotten what it takes to make sense of it yet. And you will. Sometimes you have to peel back the layers one at a time. Other times, you need to step back for the big picture. Just keep looking. I promise the epiphany is always worth it.

Remember, the greatest developers are the most curious ones. So, what’s your “magic”? What’s a concept that felt incomprehensible until you peeled back its layers or gathered more context? I’d love to hear your story.

Introducing LiteLookup: Your Terminal Assistant

Abdulmumin Akinde — Sun, 24 Nov 2024 23:04:57 +0000

Quick question: How many browser tabs do you have open right now? How many of them are due to needing concise information about some random concept?

As a software engineer who practically lives on the command line, I’ve always been frustrated by the idea of switching to a web browser for quick references and simple explanations. Whether it’s a syntax issue, programming concept, or system command, I want to be able to access information directly from the terminal—without the hassles of window-switching and tab-juggling. That is why I created LiteLookup

Who Is This Tool For?

LiteLookup was created for anybody whose workflow revolves around the terminal. Whether you are a system administrator, DevOps professional, or backend engineer like myself, LiteLookup can save you valuable time that would have been spent switching windows and managing browser tabs just to find some quick information.

Key Offerings

LiteLookup is a simple command-line interface (CLI) tool that lets you access concise, on-demand information about a concept without leaving the terminal. Here is why LiteLookup is special:

Fast lookups: Get the information you need in seconds
Avoid distraction: Stay focused and don’t enter a rabbit hole you don’t need to.
Digestible explanation: Get beginner-friendly information on your queries
Conversational mode: You can go back and forth on an idea you want to brainstorm about right from the terminal.

LiteLookup In Action

At the most basic level, you can fetch quick, one-time information about any concept with the following command:
lookup “concept”

The tool returns a short, quick reference on the topic within seconds.

Let's play out a scenario quickly:
Imagine you’re deep in a coding project trying to manage your local git repository, and suddenly, while working in the terminal, you come across an unfamiliar git command: ”git stash.” Expectedly, you’re lost and need a quick reference on the novel command. Instead of leaving the terminal and opening another browser tab to search through various articles and potentially get distracted, you can simply type the following on the command line:

>> lookup "git stash"

Within seconds, you should get something like:

Just like that, you have gone from clueless to informed—all without leaving the comfort of your text-based haven!

Getting Started

LiteLookup is easy to set up and use:

Prerequisites

Redis server installed and running Redis is a lightweight, open-source key-value store used for caching. Learn how to install Redis here.
Python 3.11 or higher
Groq LLM API access (get your free API key here)

Setup

Ensure Redis is running:
- redis-cli ping
You should get PONG which indicates Redis is up and running.
Install LiteLookup via pip or pipx:
- pip install litelookup
Check Installation
- Enter lookup —-version to check if the tool is correctly installed
Configure your API key
- To use the tool for the first time, you should see a prompt asking you to input your API key: >>Enter API KEY here:
Simply paste the API key you got from Groq to use the tool.

Usage

Basic Lookup

To fetch quick concise information about a concept, type:
lookup "concept"

Get Help

To get a description of the tool and a list of available commands, use the -h or –help flag with lookup as so: lookup -h or lookup –help

Programming Mode

If you care for a more verbose, programming-centric response, you may include the -p flag in your query.

lookup "programming concept" -p

For example, lookup "print() in python" -p

Direct Mode

For even more concise, direct answers to command-related queries, use the -d flag in your query.

lookup -d "command to ..." or lookup --direct "how to ..."

For example, lookup -d "command to delete a file in Linux" or lookup -d "how to rollback a commit in Git"

This mode provides brief, actionable responses without additional explanations. For best results, start your query with "command to" or "how to".

Interactive Shell Mode

Enter an interactive mode for faster, continuous lookups because the tool does not have to establish new TCP connections whenever you have follow-up queries.:

Lookup -id for interactive direct mode
Lookup -ip for interactive programming mode (more verbose)

To exit the interactive mode, type:

“quit” or “q”

Conversational or Chat Mode

For a conversational interactive experience, LiteLookup offers a chat feature that allows you to go back and forth with the tool:

lookup -ic

As you can see, this mode lets you engage in a conversational exchange and could serve as a nifty terminal brainstorming buddy.

What’s Coming to LiteLookup?

LiteLookup is intended to be an indeed light tool that does what it’s meant for extremely well. It is currently in its early development stage but promises a lot of intuitive features that align with the original purpose of quick referencing.
It will also continue to be optimized to fix bugs that arise and improve user experience.

Try It Out!

Give LiteLookup a try today and share your thoughts! Your feedback is invaluable in making this tool better. Reach out to me on X or LinkedIn with your experience and suggestions. Thank you!

My Goals for the HNGi8 internship – Zuri Operated

Abdulmumin Akinde — Sun, 15 Aug 2021 16:09:43 +0000

As a self-taught backend developer, I’ve come to experience firsthand some of the challenges inherent in the solo mode of learning – especially when it is programming. I’ve had to deal with uncertainties and difficulties, and they can be quite overwhelming.

Zuri Internship
When you’re solo, you assume the responsibility of consuming the right information and resources necessary for your development. That said, there are tons of informational resources on the internet and you have to filter through all to find the most valuable ones. Without the right mentorship, therefore, you tend to spend an unholy amount of time and resources just trying to get the best tutelage. This is one of the challenges that I intend to circumvent with the Zuri Internship and I’m really excited at the prospect.

Goals
• During the internship, I intend to capitalize on the availability of mentors in getting feedback for my codes. This will help me in dealing with the impostor’s syndrome that most self-taught developers battle with. As a self-taught dev, you learn to appreciate the importance of feedback in the progression of one’s career.
• By the end of the internship, I expect to be more proficient in the usage of my language of choice (Python) to solve problems, and to have garnered a lot of valuable experience from the many tasks that would be given during the internship.
• Also, I expect that by the end of the internship, I’d be a better team player who is able to withstand and weather challenges, work under pressure, and ultimately become a better achiever.
• The importance of networking cannot be overemphasized in the life of any growth-minded developer. As such, Zuri internship has come to serve the opportunity on a platter. I hope to take advantage of the boundless benefits that a community presents by the end of the internship.

As a bonus for getting to the end of the article, I will leave below links to some of the beginner-friendly materials to get started on your software development journey. I advise, however, that you start to build as soon as you get the basics of whatever concept you intend to learn:

A Figma Tutorial Playlist for Beginners

A Beginner's Guide to Git

Side note: Git is an important skill in a developer's skillset with many advantages. Learn more here

A beginner's Guide to HTML

Python For Beginners

I hope this helps.