Rubbie kelvin

Forgive Me, Sam.A, for I Know What Not to Build

dev.rubbie@gmail.com — Mon, 24 Aug 2026 00:00:00 GMT

> PS: Unlike my last note, this blog post isn’t anti AI. I just want to talk about a problem most of us don’t really treat as one and that oversight only increases the damage and cost of whatever we pay for or with. > Also need to clarify that i use AI in my development daily, it doesn't negate the problems discussed here. These days, every product seems to come with the tagline: "Build anything" And sure, these days, that's true to some extent it's tempting, even exciting. But it's also worth remembering that our energy and time are still finite. Knowing *what not to build* is just as important as knowing what to build. Since AI wrote its first "Hello, World" (if it actually did), the speed at which we can crank out code has gone through the roof. Everyone's shipping code like it's monday morning which. is great if you're iterating fast on a feature, an mvp or testing a hypothesis. But there's one thing we seem to have forgotten; **code is a liability.** Every new instruction increases the chance that something goes wrong. That matters a lot when you're building accuracy critical tools, at a time when we're debating whether we even need to *read* code anymore. Makes you wonder where everyone's sanity went. To be clear, none of this depends on whether the code came from a human or an AI. The issue is scale. If AI can generate 1000x (random number, don't quote me) the code a typical human could, the stakes stack up fast. More code does not equal a better product. The real priority should be getting a feature up and running with as little code as possible. ## Hold on, let me ask Claude Let's talk about the addictive dependence that creeps in when you let AI take over your project (*without oversight*) until no part of the codebase looks remotely familiar to the actual developers. People will say, "Skill issue. You should do it *this/that* way." And yeah, they're right, it *is* a skill issue. But what they overlook is how it starts.. how it creeps in. you give the AI a simple task. It nails it. Impressively. And then you give it another. And another. Before you know it, you’ve handed over the judge, jury, and executioner roles to a model. It's like a drug you can't let go of. And why would you? It feels good. It makes your work easier. It strips away the boring stuff and lets you move on with your life. That’s cool, until it’s a project you actually care about. I know that sounds cringe, *"a project you care about"*; but when you’re no longer involved in the development process, everything starts to feel foreign. You can't explain the *hows* or the *whys* as clearly as you could if you'd actually been in the trenches. Maybe that's a personal flaw. But hey, this is my blog post. Surely, this same problem exists when large teams work on a codebase too. But once again, the more code gets churned out over a short period of time, the bigger the problem becomes.

Humans not required

dev.rubbie@gmail.com — Tue, 26 May 2026 00:00:00 GMT

Before I begin, everything stated in this post is my opinion and I have no statistical evidence to prove anything. So take my opinion with a grain of whatever gives you your high. I might hold certain biases, so I'm going to say a few things about me so you have more detail on how to weigh the points I pass across in this blog post. I'm a software developer, so if you can't already tell, my domain of expertise has been at risk since the dawn of copilot and the likes. But I assure you, that's not why I'm writing this. I use AI at work with heavy supervision & review because companies need you to ship faster these days or you're out the window. On my personal projects, I try not to use it at all except I need to find some crazy bug and I've been stuck for a while, and if I do use it for anything other than diagnostics, I'm generating snippets or project boilerplates. I use AI to do analysis and get insights on fields I'm about to explore or things I'm about to learn. I've been against AI in my editor since copilot and I never actually used copilot, but I've used AI (via cursor) in my editor since it got better because it was mandated at work. That being said, my articles are not written by AI. # The public's introduction to Apple of Eden ![Sam Altman's tweet](/images/chat-gpts-intro.png) I remember seeing this tweet when it dropped and I thought it was the coolest thing ever. It was a fun tool I played around with and I remembered it felt like a nice tool to summarize knowledge and get specific answers to questions without running around on the internet. It didn't always work well, it didn't exactly feel smart at the time, and that was okay. Back then it felt like a toy. You'd ask it something dumb and it would give you a surprisingly coherent answer and you'd laugh and show your friends. It was novel, not threatening. Except for those that could see the future, nobody was talking about AGI or job displacement or the death of the web. Fast forward a couple years and that same toy is being shoved into everything. Your search engine, your documents, your photo library, your phones, your operating system, your girlfriend, and your fridge... once someone figures out how. It stopped being a thing you choose to use and became a thing that must be there regardless of whether you wanted it to be or not. And with that shift, the vibe changed. # AI is good To deny that AI has tons of benefits and has been a really helpful tool is to deny that sugar is sweet. Medical research just got a shot in the arm because AI can actually read medical images and find tumors faster than some radiologists. Protein folding, drug discovery, real time translation breaking down language barriers, these are not nothing. For a blind person, AI describing the world through a camera is basically a superpower. There's genuine good here, and pretending otherwise is just as dumb as the people who think AI can do no wrong. # AI is cancer To deny that AI does more damage to society and humanity as a whole is to deny that sugar can be bad for your health when you ingest lots of it, and to be fair, most of all the bad things I have to say about AI are especially pointing to generative AI. I'm not gonna say _"in the earlier days of the internet"_, because just 4 years ago, you could search something on the internet and you could be sure that any site you choose to read from had the content written by a person, and everyone had different opinions taste and you could find content that suits your needs. ## ** "Did you use AI for this?" ![Imagine putting your best into your work only for it to be reviewed by AI and judged "too" perfect. This isn't the first time and I'm genuinely tired](/images/esther_stan_tweet.png) If you're an artist, writer or an expert in any creative field, you must have gotten this question for at least every piece of work you put out there. Somehow everyone seems to have developed mass amnesia and forgot that humans were capable of jaw dropping feats before the release of AI. It's now expected that every little thing has to hold a >90% stake in its creation. For something as little as writing an essay, a single well formed paragraph, or damn! a nice letter to your friend wishing him a happy birthday! It's beyond sickening, it's like we seem to be losing IQ points every single day. And this **NEVER** helps those who are learning, it's more damage than it's worth, because why learn X when AI can do X, Y, Z? The simple ability to reason is being offloaded to a third party tool you pay $20-$200/m for, sad. # The Human factor Everybody says "AI won't replace you, but a person using AI will." or "AI wont replace you if you're good enough". But if we look closely at the trajectory of this technology, everywhere begins to "unblur". and i'm not all about job displacement, i'm looking at a fundamental shift in what it means to be human. AI is not just a tool, it can't reason, but it seems to learn... at least by statistical inference and at a scale that no human can. If we blindly outsource every vital aspect of our existence to these systems, we aren't just upgrading our workflow, we are volunteering to become the ultimate training data. ## ** The Atrophy of Thought Here's the thing nobody wants to say out loud. Every time you reach for AI to write, think, or decide for you, you're outsourcing a piece of yourself. You get the answer faster, but you lose the muscle, day by day, little by little, until it's all gone. The ability to struggle through a problem, to be wrong, to arrive at something messy and yours, that compounds. And what grows in its place is dependence. ## ** Empathy & Illusion This dependence is already creeping into our most sacred, vulnerable spaces. We are beginning to witness a real shift in our daily lives where AI is used as a surrogate for genuine human connection and empathy. An alarming number of people are now turning to AI companions and algorithmic girlfriends/boyfriends for emotional fulfillment. Rather than navigating the vulnerability of human-to-human therapy and connection, we seem to be opting to use chatbots as therapists because it feels "embarrassment proof" or within reach. I was able to put my laziness aside and actually do some [research](https://news.llu.edu/health-wellness/can-i-use-ai-my-therapist-truth-about-turning-chatbots-therapy) here. AI cannot feel, yet we are allowing it to simulate the active ingredients of human healing, empathy, and connection. When we trade the risk of real relationships for the safe, predictable comfort of an algorithm, we are not just using a tool. We are slowly replacing the very things that make us human. # AI, AI, Go away Love it or hate it, it's already here. There's no no-AI anymore. US companies can't stop working on the technology even if they are aware of the impending doom because, _hell, the Chinese won't stop so if we do stop, we're just gonna be left behind_. That's the trap, eh? We've turned a technological choice into an arms race. No company can afford to sit out because their competitor won't. No country can afford to pause because the other won't. So we all just keep sprinting toward a cliff together, each one afraid to be the first to stop. # The Future. Unless we can go back to the past, I don't have a hopeful ending here. I don't have a plan or a call to action. Though that doesn't mean the future is grim or this post is meant to come off as a doomsday warning. The cat is already out of the bag, the machine is already running, and none of us were asked if we wanted it turned on. Maybe we regulate. Maybe we adapt. But one thing's for sure, we will all wake up one day and realize we handed over the one thing that made us human... the need to try, to fail, to be imperfect, to reason, to figure it out ourselves. Or maybe we just keep feeding it until there's nothing left to feed, until there's no human written content on the internet. Maybe then we'll realize that the future is already here, and we're not required.

Maybe love is in the past

dev.rubbie@gmail.com — Wed, 18 Feb 2026 00:00:00 GMT

The idea of love in the world we live in today feels almost laughable, as though something once luminous has been left out in the rain too long, watered down until it scarcely holds the depth and gravity it carried in the past. I know I'm opening with a bold claim, perhaps even a provocative one, but the evidence surrounds us in the stories we consume, the glossy romantic movies, the best selling novels, the endless reels of perfect moments. Maybe it's unfair to lay the blame entirely at the feet of media. After all, throughout human history we have gently reshaped grand ideas until they glow in ways that please our eyes and seduce our ears. A diamond ring becomes the unspoken proof that you truly love her. An expensive wedding isn't just a celebration, it must become the talk of the town, a spectacle remembered long after the flowers wilt. We've invented metrics for romance, little scorecards running from "barely romantic" to "storybook perfection", as if love could be quantified like a restaurant review. Yet as life unfolds, through quiet mornings, ordinary arguments, shared silences, we discover how flawed those measurements truly are. They collapse under the weight of reality. So what, then, is love? How do we truly show it? When does it feel unmistakably real, and why does it slip away even when everything appears flawless on the surface? To be honest, I don't have all the answers, i don't think i'm the right person the answer these, and i might not even answer this questions in this piece. But it's 2am and i feel like writing, so here we are. ## What's going on Why am i suddenly writing about love? Well, it started with a couple of late night watches that hit me harder than expected. Last night I watched **Top Gun: Maverick (2022)**, and man, it was absolute cinema pure adrenaline, heart, and that perfect Tom Cruise energy. Then tonight I put on **The Last Samurai (2003)**, and oh boy, I was completely sold. I don't know the exact global ratings this movie pulled in, but I'd give it five stars in a heartbeat without hesitation. Enough review, what really got me? In the film, Nathan Algren, the American captain hired to train the Japanese army in modern warfare, ends up undergoing one of the most intense character transformations you'll see on screen. He starts as an outsider, a hired gun enforcing a new order, only to find himself drawn into the very world he was sent to help erase. By the end, he's fighting shoulder to shoulder with the people he once called enemies, defending a way of life that's slipping away. ## Love is hard. ![](/images/05c815f259d18861d82eff6600f26c4dd492d55c-1280x853.png) Love is hard. It doesn't arrive wrapped in ease or instant clarity. It demands we confront ourselves first, then reach outward through layers of pain, discipline, and quiet endurance. It begins with love for self, truly seeing that you are worthy of love, even when your past is stained, and accepting it when it appears without pushing it away. In the film, the captain carries the weight of having killed a samurai in battle, a man who turns out to be the husband of the woman now tasked with sheltering and caring for him. He could have drowned in self loathing and guilt, refusing any kindness as undeserved punishment. Instead, he chose to receive the gentleness offered by the widow, her family, and the village. That acceptance of forgiveness he didnt earned, of care he felt he didn't merit, became the foundation. Only then was he able to give love back in return, slowly rebuilding what shame had broken inside him. From there, love extends beyond the self to embrace others through their culture, their societal ways, their deepest values. The captain begins to notice the quiet beauty in how the people live.. rising each morning not only to survive, but to perfect whatever task or craft they've set their minds to. Politeness holds steady even when heavy emotions simmer beneath the surface; the widow, for instance, carries profound grief yet meets each day with grace and restraint. Their entire way of life is guided by discipline, a steady commitment to principles that shape every action, every interaction. Love like this isn't romantic infatuation, it's a deliberate choice to honor and adopt something larger and older than oneself, something worth the daily effort to understand and embody. Maybe love also stems from grief and the aching desire for companionship. Absence creates a void, and sometimes another person begins to fill it, not as a replacement, but as a presence that softens the edges of loss over time. Forced proximity plays its part. Grief doesn't vanish, but it evolves. In the quiet moments, leaning into that new presence becomes possible. Nn act of survival as much as affection, born from what was lost and what remains. And love grows from brotherhood and respect, forged often in adversity rather than ease. The samurai leader shows mercy at first, sparing the captain when death would have been simpler. He respects the resilience he sees the ability to rise after every blow, to keep standing. That respect grants freedom within the village, then full freedom when winter ends. Their bond deepens through shared trials.. night time assassins testing loyalty and skill, battles where trust is proven in action. What begins as wary adversaries becomes something closer to brotherhood, rooted in mutual recognition of strength and honor. In the end, after fighting side by side, the leader chooses to end his life with dignity, asking the captain to witness it, not as a stranger, but as one who truly understands the weight of that final act. Love is hard because it requires all of this. It rarely feels easy or immediate. But when it takes root through these quiet, disciplined efforts, it endures in ways the fleeting versions never can. Bye <3

My worst fear

dev.rubbie@gmail.com — Sun, 18 Jan 2026 00:00:00 GMT

This is my portfolio's blog, it should be tech inclined, every thing i post here should drive towards helping boost my career, and yeah, potential employers might read this…. I do not care. This is my space. I’m not proofreading, so expect typos, rubbish sentences, and zero apologies. This isn’t written for any audience. I’m just screaming into the void. ## **What does a man do, Walter?** "…*A man provides for his family … When you have children, you always have family. They will always be your priority, your responsibility. And a man… a man provides. And he does it even when he’s not appreciated, or respected, or even loved. He simply bears up and he does it… because he’s a man."* If you’ve seen BB, you know these are Gus Fring's words. the cold, calculated chicken man, delivered with that chilling calm by Giancarlo Esposito. And damn, he was cooking with that one. For a real family man, that speech lands like truth nine times out of ten (no stats, just life). But here’s the raw part: I’m not a family man. Not yet. So why the hell am I haunted by this? Well, because I’m terrified. Sometimes I already slip into the role of "the provider." A friend’s in deep shit? I fix it. Money, time, energy… if I can snap my fingers and make the problem disappear, I do. **The closer you are to me, the less I care about the cost to myself**. I’d like to believe it's because I'm decent. Generous or a nice guy, even. But for some people… it stops being a gift. It becomes expectation. Baseline. Normal. And when that shift happens, it’s suffocating. The weight settles in quietly, then suddenly it’s crushing. And the worst part? Half the time, the second the storm passes, the deeds vanish. Forgotten. Erased like they never happened. You pulled them out of the fire, bled for it time, sleep, money, sanity and the moment they’re safe on dry ground, they turn around, smile, and walk away like it was nothing. No “thank you” that lingers. No memory of the nights you stayed up. No acknowledgment that you carried what they couldn’t. It’s just… gone. You become the invisible scaffolding again, only remembered when something else breaks. And that silence? It cuts deeper than any ingratitude ever could. That’s not even the deepest fear, though. That part I’ve already lived with for years and I’ll keep living it. What truly scares me is the future. The day i have my own family and after a few years of love, laughter and bliss, i become *only* "the one who provides." The day the warmth fades, the appreciation dries up, the love evaporates, and all that’s left is me as the fixer, the silent engine keeping everyone else’s life running. Just the means. Never the man, it scares me. ## The Annoying reality of "It's Okay to Cry" ![](/images/1c1978f2fae75b2f7b7e63852814aa78bd1c6dd7-1400x700.png) We’ve all heard it a million times, men *(and some women too)* are being told it’s okay to cry. To open up. To stop being the unbreakable wall. And yeah… it *is* okay. In theory. We’re raised as granite.. never cracking, never buckling, no matter how much pressure’s put on. People see that stoicism and say "toxic masculinity!" And they’re not entirely wrong. Bottling everything up poisons you from the inside. When the dam finally breaks, the flood comes out as ugly rage, silence, destruction .. or it never comes out at all. But here's the cruel twist nobody wants to say out loud... The same people chanting "it's okay to cry" are often the first to run when the tears actually fall. They want vulnerability… until they see how hideous the real darkness is. Until they realize the "toxic" masculinity they hate is the only thing holding back something far uglier underneath. They beg you to pour it out, right up until they witness what’s really in the bottle. Then they vanish. Or worse: they judge. They recoil. They leave you standing there, exposed, feeling like a monster for finally doing what they demanded. So what happens when *everyone* else is crying? When the whole room is falling apart? Who carries the fear then? Who stays steady when the rest are crumbling? You can’t break down when everyone else is already shattered. You can’t scream when the people you love are already screaming. You swallow it. Again. Because someone has to. And suddenly "it's okay to cry" starts sounding like a luxury. A privilege for those who aren’t holding the line. At that point, the tears don’t even try to come out anymore. They crawl back inside where they belong locked up, silent, waiting for the next crisis that demands you stay unfazed. Because that’s what a man does. He bears it. Even when it’s killing him. Even when no one sees. Even when no one cares. Because he’s a man.

Frustration

dev.rubbie@gmail.com — Tue, 28 Oct 2025 00:00:00 GMT

Some mornings feel like the universe woke up early just to juggle flaming pineapples around you. Not exactly maliciously, Just… for the sport of it. Meanwhile you're there, trying to mind your warm cup and your gentle thoughts, pretending everything is perfectly ordinary. There's a delightful rhythm to moments like that. the swirl of noise, the puff of confusion, the little spark of "wait, what now?" drifting through the air. And yet humans are shockingly good at creating pockets of calm inside the carnival. A small inhale. A steady sip. A private bubble where the world can knock politely and wait its turn. I've come to love that balance. A kind of playful coexistence with the unexpected. Life does its jazz solos, and you give it a nod like a patient audience member who paid for a quieter show but won't demand a refund. There's power in not wrestling every odd moment to the ground. Sometimes the trick is to let it dance, let it twirl, let it finish whatever dramatic routine it's committed to. And in that tiny pause, before the next surprise leaps out, you get to be the calm center of your own little universe. Warm cup in hand. Thoughts unwrinkled. Chaos swirling just far enough away to be entertaining. After all, tranquility isn't the absence of noise. It's the ability to sip through it.

*Give up

dev.rubbie@gmail.com — Sun, 14 Sep 2025 00:00:00 GMT

If I'm being really honest, art for me is a hobby. I never really got into it professionally. I don't know color theory, I don't know shading, perspectives, and all those technical aspects, but I make pretty decent sketches. This one isn't just a sketch though. As you can see, it has everything I just said I know nothing about, and if you look a little closer, you'd notice this art was made in collaboration with a professional artist (check him out on twitter [@christianozoude](https://x.com/christianozoude)). ## Inspiration & Initial Sketch ![](/images/ea0e92fb46a8a6d3eea3ca7877a917ec415e8f2e-2048x1152.png) I'm sure if you've ever built rust from source on a potato machine, you'll have no trouble understanding this art. If we take a look at the elements in this piece, the first thing that catches your eye is the burning monitor. I'm trying to get some work done, but my machine is getting hotter than the surface of the sun. The fan is working overtime, making sounds that would make a jet engine jealous, and the CPU temperature is climbing into territories that should require a hazmat suit. Yet here I am, refusing to admit defeat, watching my system struggle through what should be a simple compilation process. Even with everything not entirely working as expected and processes running slower than the sloth on a slow day, there's still a smile on my face. I'm telling everyone watching me that everything is perfectly fine with my little gesture, though there's definitely a hint of embarrassment behind my eyes. You know that feeling when your demo starts failing right when someone important walks by your desk? Yeah, that's the vibe. Don't forget the Windows machine sitting in the trash bin. Since i switched to Linux in ~2020, I've never looked back. Asides the ease you get from software development, you don't have to deal with those annoying Windows updates that always seem to happen at the worst possible moment, or those bizarre ads that somehow show up in your operating system startup menu (for real). ## *Dont ![](/images/56b7892daad05c5598be8c867d6cf133cfd6a8da-480x270.gif) Though the title says "Give Up," I hope you can see the irony and humor behind it. because even when my program takes what feels like months to compile, even when my machine sounds like it's preparing for takeoff, even when I'm pretty sure I can smell something burning that probably shouldn't be burning, everything somehow works out in the end. The art captures that moment of stubborn optimism that every dev knows well. That moment when logic says you should probably take a break, maybe just buy an M4 mac *(which i ended up doing btw)*, or at least close a few of those browser tabs, but instead you just give a little wave and keep pushing forward. So please don't give up, be kind to your PC instead.

Building is hard

dev.rubbie@gmail.com — Mon, 08 Sep 2025 00:00:00 GMT

I'm writing this so I don't get lost in the abyss of all this Rust code as I continue building Native Doctor. Three months ago, I had a half-baked idea and a custom language-parser that barely worked. Today, I have something that actually executes HTTP requests based on YAML configuration, handles dependencies, and might even be useful to other people. The journey from there to here has been... stressful & educational. ## In the beginning I just want to build something okay? I think that's enough reason. But why this tho? I started a project in 2020 named snowman.. terrible name I know but it was basically postman but without the whole postman login crap. No UI tho, no CLI, so yeah there was no interface. The project was basically scrap and unusable, so I put that one in the trash where it belonged. Although that's behind me now, I still don't much like postman. The terrible sign-in wall and a ton of other things make me ick. So, like the time-wasting person that I am, I decided to build snowman again, but this time in rust. And this time, I'm calling it Native Doctor because apparently I still suck at naming things. The core idea hasn't changed: define API tests and workflows in a structured, human-readable format that lives somewhere in your project folder and can be included in your commits. No signing up for API testing tools, no losing your work when the service goes down, just files in your repo that everyone can see and edit. ## God strikes babel once again Three months ago, after doing what I generously called "DX research," I decided to create a domain-specific language. I settled on what I thought was a friendly syntax where you could specify environment variables, define multiple requests, and call them. It looked like this: > NOTE: Yes i considered *.http* but it wouldn't have worked out without modifying the *.http* file specification to fit my requirements ``` @env base_url = "https://api.yourapp.com/v1" base_url.dev = "http://localhost:800/v1" // Override for "dev" environment @end @request LoginUser POST {{base_url}}/auth/login @headers { Content-Type: application/json } @body:json { "email": "{{user_email}}", "password": "{{user_password}}" } @end @call LoginUser ``` The idea was simple: define your variables, requests, and specify which request to call. I was so proud of this syntax. I thought I was building the future of API testing but i was actually building a headache. ## Yes, let's write a parser in rust I moved on to write the parsing expression grammar because apparently I hate myself. First attempt was with nom.rs, and I got completely lost in combinator hell. The learning curve was like climbing Everest in flip-flops. I found myself spending more time fighting the parser than building anything useful. Then I switched to pest.rs and used gemini to generate the pest file *(shout out to google for enabling my bad decisions)*. While it worked better than nom, I was still spending way too much time on parsing instead of the actual HTTP request logic. Weeks turned into months, and I had a parser that could barely handle my custom syntax but couldn't actually make HTTP requests. After what felt like an eternity of wrestling with parsing combinators and grammar rules, I had an epiphany while staring at yet another "expected token" error: I was solving the wrong problem! I didn't need a new language. I needed a tool that worked. ## YAML isn't so bad i guess So I threw away months of parser work and switched to YAML. Best decision I made on this entire project. Now, a request can look like this: ```yaml name: Headers Inspection Test method: GET url: https://httpbin.org/headers doc: Test request headers inspection - returns all headers sent by client headers: User-Agent: "Native-Doctor/1.0" Accept: "application/json" X-Custom-Header: "custom-value" X-Test-Suite: "httpbin-native-doctor" X-Request-ID: "req-12345" ``` Clean, readable, and I get syntax highlighting and validation for free (after writing [the schema](https://github.com/rubbieKelvin/nativedoctor/tree/main/definations) of course). Plus, every developer (i guess) already knows YAML. Sometimes the boring solution is the right solution, and sometimes you need to waste three months learning that lesson. ## Actually building the thing With YAML handling the configuration, I could finally focus on actual problems. The first real challenge was request dependencies. I wanted requests to depend on other requests running first, like needing to login before accessing protected endpoints. This meant building a dependency system that could create a call stack and execute requests in the right order. The tricky part was detecting circular dependencies. Imagine if request A depends on request B, which depends on request A. That's an infinite loop waiting to ruin someone's day. I wrote recursive functions that traverse the dependency graph and throw errors when they find cycles. It took several iterations to get right, and I'm still not entirely convinced it handles all edge cases. I also introduced project files that can define sequences of requests. You can organize related requests and run them as workflows, which is perfect for integration testing where you need a whole chain of API calls to verify a feature works end-to-end. ## The scripting rabbit hole Originally, I wanted JavaScript for post-request validation, following the Postman model. This turned into one of those rabbit holes that makes you question your life choices. ### #1 Deno core I tried deno_core to embed a JavaScript runtime. The documentation was sparse, and setting up the runtime felt like using a nuclear reactor to power a flashlight. I spent days trying to get basic script execution working and kept hitting weird runtime issues that made no sense. ### #2 Rustyscript I found a crate called RustyScript that promised easy JavaScript integration. Got it working initially, but then encountered these bizarre runtime errors that were impossible to debug. The error messages were about as helpful as a chocolate teapot, and the documentation was basically "good luck, figure it out yourself." ### #3 Lua I also considered Lua with the hlua crate. Lua is simpler and has better Rust integration, but then I'd be forcing users to learn Lua just for simple assertions. That seemed like trading one problem for another. ### #4 Rhai Current plan: [Rhai](https://rhai.rs/), a scripting language designed specifically for embedding in Rust applications. It has Rust-like syntax, excellent error handling, and is built for exactly this use case. I haven't implemented it yet, but it feels like the right fit for post-request testing and validation. ## Where I am now > Development has not been linear, i have a full time job, so when i say 3 months i mean my free Saturday mornings in the span of 3 months Three months after that first attempt with the custom language, Native Doctor actually works. It can handle HTTP requests with YAML configuration, manage request dependencies, support multiple body types, and organize everything into projects. I even built a comprehensive test suite with [29 test files](https://github.com/rubbieKelvin/nativedoctor/tree/main/httpbin) covering all the httpbin.org endpoints because apparently I enjoy writing tests now. But it's still early development. Project sequence execution is partially implemented but not complete. Response output handling needs work. The Rhai scripting integration is still on the todo list. Error messages could be more helpful. There are probably bugs I haven't found yet. The thing about building software is that it's never as straightforward as you think. I thought I'd spend most of my time on HTTP request logic, but instead I spent months on parsing, weeks on dependency resolution, and countless hours debugging edge cases I never saw coming. ## Building is hard but worth it I learned some expensive lessons on this project. Don't build a language unless you absolutely have to. YAML solved 90% of my problems with 10% of the effort. Focus on the core problem first instead of getting distracted by shiny parsing libraries. The Rust ecosystem is amazing but overwhelming, with five different crates for every problem, each with different trade-offs. But here's the thing: even with all the frustrations, dead ends, and moments where I wanted to throw my laptop out the window, building Native Doctor has been incredibly rewarding. Every time I get a feature working, every time I fix a bug that's been bothering me for weeks, every time I see the tool actually solving a real problem, it makes all the struggle worth it. The goal is still the same as it was with snowman: a simple, powerful API testing tool that doesn't require signing up for anything, stores configuration in your repo, and just works. I'm not there yet, but I'm a lot closer than I was three months ago when I was fighting with parsing combinators. Building is hard, but it's also the most fun I've had in a long time. Even if the problems I'm solving are ones I created for myself by refusing to just use Postman like a normal person.

Implementing meeting transcription at Colabra labs

dev.rubbie@gmail.com — Wed, 27 Aug 2025 00:00:00 GMT

There's something oddly satisfying about watching a machine transcribe human conversation in realtime. It's like teaching a computer to eavesdrop, but in the most productive way possible. Over the past few months, I've been deep in the trenches building Colabra's transcript feature, and i'm ngl, it's been quite the adventure. ## The Problem That Wouldn't Go Away You know that feeling when you're in back to back meetings all day, frantically scribbling notes while simultaneously trying to look engaged? Yeah, that was our users' daily reality. Scientists and researchers were spending more time documenting their conversations than actually having them. Something had to give. The request came in simple enough: "*Can we just record our meetings and have them automatically show up in our projects?*" Famous last words, right? What started as a "simple" feature request turned into a fascinating deep dive into the world of automated transcription, AI processing, and the delicate art of making technology feel invisible. ## The Great Integration Dance The first challenge was picking our dance partner. After evaluating several options, we settled on Nylas for the heavy lifting. Their notetaker bot could join meetings, record everything, and deliver clean transcripts. Sounds perfect, doesn't it? Well, here's where things got interesting. We needed our system to be smart enough to know which meetings belonged to which projects. Imagine having a transcript from your weekend book club accidentally show up in your cancer research project. Not ideal. So I built what I like to call the "domain detective"... a system that looks at meeting participants' email domains and automatically matches them to the right projects. If someone from "oncology-research.edu" is in a meeting, chances are it belongs to the oncology project. Revolutionary? Maybe not. Effective? Absolutely. ## The AI Whisperer But here's where things got really fun. Raw meeting transcripts are like uncut diamonds... valuable, but rough around the edges. Speaker labels are inconsistent, timestamps are all over the place, and don't even get me started on the creative ways people pronounce technical terms. The tricky part was handling the sheer variety of input formats. Some users wanted to paste transcripts from Fireflies, others had JSON files from Granola, and a few brave souls were drag and dropping plain text files. Our system needed to be like a linguistic chameleon, adapting to whatever format users threw at it. ## The UX Puzzle ![](/images/22e135022fa6c3380c9cca0a7434d17f9f274eb2-717x377.png) > Here's something they don't teach you in computer science class: the hardest part isn't making the technology work it's making it feel effortless for users. We could have built the most sophisticated AI powered transcription system in the world, but if users had to jump through hoops to use it, what's the point? So we obsessed over the details. Drag and drop file uploads. One-click AI processing. Automatic project association. Toast notifications that actually tell you what's happening instead of just saying "Success!" The interface needed to feel familiar yet powerful. Think of it as the iPhone of transcript management, simple on the surface, but incredibly sophisticated underneath. ## The Automation Revelation The real magic happens when users don't have to think about it at all. Once you connect your calendar to Colabra, the system becomes almost prescient. Schedule a meeting with colleagues? A transcript placeholder appears in your project. The meeting happens? Our AI notetaker joins automatically. Transcript ready? It's processed, cleaned, and filed away before you've even left the meeting room. It's the kind of automation that makes you feel like you're living in the future, until you realize it's just really good software doing what really good software should do disappear into the background and make your life easier. ## The Challenges. Tbh, this wasn't all smooth sailing. There were moments when I questioned my life choices. Like when I spent three days debugging why certain transcripts were being chunked incorrectly by our AI processing pipeline. Or when I realized that meeting URLs could be formatted in seventeen different ways, and our system needed to handle all of them gracefully. The search indexing was another adventure entirely. Transcripts aren't like regular documents, they're conversational, timestamp heavy, and full of context that traditional search algorithms struggle with. We ended up building a specialized search system that understands the unique structure of meeting conversations. And don't get me started on the edge cases. What happens when someone joins a meeting late but the transcript starts from the beginning? What if the AI can't identify speakers reliably? What about meetings in multiple languages? Each edge case was like a small puzzle that needed solving. ## The Joy of Seamless Integration But here's what made all those late nights worth it... watching the feature come together as part of a larger ecosystem. Transcripts don't exist in isolation they're part of projects, they reference experiments, they connect to team members. Building this feature meant creating countless small connections that make the whole platform more intelligent. The real satisfaction came from seeing how naturally it integrated with existing workflows. Users weren't learning a new system, they were discovering that their existing system had quietly become more powerful. ## Stuff I learnt along the way Building this feature taught me that the best technology is invisible technology. Users don't want to think about AI models or processing pipelines or webhook integrations. They want to have a meeting, and then they want that meeting to be useful later. I learnt that automation is only as good as its failure modes. What happens when the AI can't process a transcript? What if the notetaker fails to join? When the internet cuts out mid meeting? The mark of good software isn't that it never fails, it's that it fails **gracefully** and recovers elegantly. ## Ripple Effects The most rewarding part has been watching how this feature changes behavior. Teams are having better meetings because they know they'll have perfect recall later. Researchers are more engaged in discussions because they're not frantically taking notes. Project timelines are clearer because every decision and discussion is automatically documented. It's one of those features that starts as a nice to have and quickly becomes indispensable. The kind of thing that makes you wonder how you ever lived without it. ## What's next? We're just getting started. The foundation is solid, but the possibilities are endless. Imagine transcripts that automatically generate follow up tasks, or AI that can identify when a meeting goes off track and gently nudge it back on course. Picture a system that can analyze communication patterns across your entire organization and suggest ways to improve collaboration. Building Colabra's transcription feature has been one of those projects that reminds you why you became a developer in the first place. And the best part? This is just the beginning, and i love that i get to be a part of this! Cheers 🥂

Porting my portfolio from vue to astro

dev.rubbie@gmail.com — Mon, 25 Aug 2025 00:00:00 GMT

# Intro I've had all my portfolios written in nuxt/vue for the longest time. i remember picking up vue since august 2020, it was so easy to learn and i wrote my first [first vue project](https://github.com/rubbieKelvin/pseudoapi) a day after reading vue docs. vue's still my go-to when building web apps, but when it comes to building static sites, astro just became my new love. ## Why the switch? The switch was made out of frustration actually. i needed a way to post static content on my blog and nuxt came through with [nuxt content](https://content.nuxt.com/). however, after some update i made, i couldn't really get the blog part working smoothly anymore. i noticed my post no longer showed up until i refresh the page. the error that showed up on my vue page was ``` Access to fetch at 'https://www.rubbietheone.com/?v=v3.3.0--vHJ6qT1DnX' (redirected from 'https://iam.rubbietheone.com/api/content/blog/database.sql?v=v3.3.0--vHJ6qT1DnX') from origin 'https://iam.rubbietheone.com' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource. ``` I spent a while trying to fix that error, then i concluded it wasn't worth it anymore. i decided to move to [sanity](https://www.sanity.io/), which i've used in the past to setup [Colabra's blogs and change-logs](https://colabra.ai/blog). Setting up sanity in nuxt, was pretty simple, until i hit this weird error: ``` Error: The requested module '_nuxt/react-compiler-runtime/dist/index.js' does not provide an export named 'c' on sanity ``` I spent a few more hours trying to fix this, maybe a skill issue idk... but truth be told i followed sanity's docs to the letter (except the names & credentials of course). I got tired and decided i should give something else a shot. > All of this was in one night btw. ## Okay, but why astro? Tbh i just went for the next cool thing and that wasn't react. Thank you xD. Also astro was listed in sanity's docs so sanity support was assured. # Astro so far. I haven't written anything in astro before now, so setting up a new site in a day was really awesome, i like how bare astro-out-of-the-box can be (i saw it was [framework agnostic](https://docs.astro.build/en/guides/framework-components/)). it's pretty close to html and maybe what the html-css-js trio would have been if it was designed in the modern day. Simplicity out of the box, static site generation is a breeze, and everything just works really good on the get go. Though i'm not sure how Astro plays out on big apps, it's a really awesome frontend framework and you should give it a try.

Tired

dev.rubbie@gmail.com — Thu, 19 Jun 2025 00:00:00 GMT

Art: Tired

Rubbie Kelvin

dev.rubbie@gmail.com — Thu, 20 Mar 2025 00:00:00 GMT

Rubbie Kelvin is a tall and charismatic cartoon character who exudes confidence and coolness. With his stylish demeanour, Rubbie stands out in a crowd with his well-groomed black hair and a pair of sleek, dark sunglasses that add a touch of mystery to his appearance. His African heritage is reflected in his rich skin tone, making him a distinctive and dynamic character. Rubbie is often seen donning fashionable shorts paired with a trendy hoodie, showcasing his keen sense of style. He accessorises with a pair of oversized headphones that not only highlight his preference for immersive sound but also serve as a statement piece, reflecting his bold personality. As a computer science graduate and a skilled programmer, Rubbie works at a cutting-edge tech company in California. His workspace is adorned with sketches and doodles, evidence of his love for art. Rubbie has a knack for drawing, and his artistic talent adds a touch of creativity to his otherwise tech-focused life. Coffee is Rubbie's elixir, and he is often found with a cup in hand, whether he's coding at work or taking a break to enjoy a quiet moment. His affinity for coffee shops and the rich aroma of freshly brewed coffee adds a warm and inviting element to his character. Rubbie's preference for a quiet and focused life is reflected in his minimal presence on social media. He values his privacy and finds solace in the world of programming and art. Despite his reserved nature, Rubbie enjoys the company of tall girls, finding a unique connection between their height and the depth of his artistic inspiration. In the vibrant landscape of Lagos, Rubbie Kelvin stands out as a tech-savvy artist who seamlessly blends the worlds of technology, creativity, and a laid-back lifestyle, creating a character that is both intriguing and relatable.

Creative thinking in the AI age

dev.rubbie@gmail.com — Sun, 05 Mar 2023 00:00:00 GMT

Let's take you through an interesting journey where we explore how artificial intelligence is reshaping creativity as we know it. We'll discuss the impact of AI on creative fields, examine how developers can harness AI to enhance their creative process, and dive into what creative thinking looks like when machines become our collaborators. ## The Dawn of the AI Era Over the past decade, we've witnessed rapid advancements in AI technology that have fundamentally changed how we live, work, and create. What started as a futuristic concept has become an everyday reality, transforming industries from healthcare to transportation, education to entertainment. But perhaps nowhere is this transformation more fascinating than in the realm of creativity. AI isn't just changing how we solve problems, it's changing how we think about problems in the first place. Creatives across various fields are discovering that their skills aren't being replaced but rather amplified and refined in ways they never imagined possible. The arrival of AI represents more than just technological progress. It's ushering in an era where human creativity and machine intelligence can work together, reducing mundane tasks while opening up entirely new possibilities for innovation and artistic expression. Artificial intelligence is here, and it's not going anywhere. ### Reshaping Creativity The impact of AI on creative fields like music, writing, art, and design is often misunderstood. Some see it as a threat, others as a savior. The reality is more nuanced and far more interesting than either extreme suggests. AI has quietly woven itself into the fabric of creative work, generating more fascinating ideas, providing solutions to complex problems, and making life genuinely better for creators. It's birthing new ways of doing things while making existing processes more seamless and intuitive. ### Productivity and Efficiency One of the most immediate benefits of AI in creativity is the dramatic increase in productivity and efficiency. AI excels at automating repetitive tasks and providing insights that accelerate the creative process, freeing creators to focus on the complex, nuanced work that requires human intuition and emotional intelligence. Consider graphic designers who now use AI-powered tools to automatically resize images or generate color schemes. This isn't about replacing the designer's eye for aesthetics, it's about eliminating the tedious work so they can spend more time on the creative decisions that matter. Adobe Sensei, for example, acts as an intelligent assistant that suggests design changes based on data analysis, allowing designers to work more efficiently while maintaining complete creative control. The result? Designers can explore more ideas, iterate faster, and deliver higher quality work because they're not bogged down by routine tasks. ### Sparking Inspiration Perhaps even more exciting is AI's ability to inspire and generate fresh perspectives. AI-powered tools can analyze vast amounts of data and surface insights that might take humans years to discover on their own. In music production, platforms like Amper Music use AI to generate custom tracks based on user preferences, not to replace musicians but to provide starting points for human creativity. A composer might use AI to explore harmonic progressions they wouldn't have considered, then build upon those foundations with human emotion and storytelling. Machine learning algorithms can analyze massive datasets to uncover patterns and trends that escape human notice, revealing connections between seemingly unrelated concepts and opening up entirely new creative territories. ### Enhancing Precision and Quality AI also brings unprecedented accuracy to creative work. Tools like Grammarly don't just catch typos, they understand context, tone, and intent, helping writers communicate more effectively. In visual design, AI can ensure consistency across large projects, maintaining brand guidelines while allowing for creative flexibility. The decisions AI makes are based on vast amounts of previously gathered information and sophisticated algorithms. When properly implemented, these systems can reduce errors to nearly zero while maintaining the human creative vision. ## How Developers Can Harness AI for Creative Enhancement For developers, AI represents a particularly exciting opportunity. We're uniquely positioned to not just use AI tools but to create them, customize them, and integrate them into our workflows in ways that amplify our creative problem-solving abilities. ### Automating the Mundane Developers can leverage AI to handle routine tasks that consume valuable creative energy. Image processing, code formatting, basic testing, and documentation generation can all be automated, freeing up mental bandwidth for architectural decisions and innovative solutions. This isn't about being lazy, it's about being strategic. When AI handles the repetitive work, developers can focus on the creative challenges that require human insight, experience, and intuition. ### Generating Fresh Approaches AI algorithms excel at analyzing large amounts of code, design patterns, and user data to identify trends and suggest new approaches. An AI system might analyze your codebase and suggest architectural improvements, or examine user behavior data to inspire new feature ideas. The key is viewing AI as a collaborative partner rather than a replacement. AI can generate the initial concepts, but human creativity transforms those concepts into meaningful, user-centered solutions. ### Facilitating Better Collaboration AI can enhance teamwork by providing real-time feedback, identifying potential conflicts before they become problems, and suggesting solutions that consider multiple perspectives. Code review tools powered by AI can catch issues that human reviewers might miss while learning from the team's preferences over time. ### Expanding Creative Possibilities Perhaps most exciting are the entirely new creative tools that AI enables. Neural style transfer allows developers to apply artistic styles to user interfaces. Natural language processing can help create more intuitive user interactions. Machine learning can personalize experiences in ways that were previously impossible. ## Creative Thinking in the AI Age As we embrace AI's potential, it's natural to have concerns about its impact on human creativity. Will AI replace human creativity? Will it limit our thinking by providing too many preconceived solutions? Will creative jobs disappear? These are important questions, but they're based on a fundamental misunderstanding of what AI actually does. AI isn't a replacement for human creativity, it's an amplifier. It doesn't think creatively in the way humans do. It processes patterns and generates outputs based on training data, but it doesn't have experiences, emotions, or the ability to understand context the way humans do. The most successful creative professionals in the AI age will be those who learn to collaborate with AI rather than compete against it. They'll use AI to handle routine tasks, generate initial ideas, and explore possibilities they might not have considered, but they'll apply human judgment, emotion, and experience to transform those AI-generated starting points into meaningful creative work. ## The Future of Human-AI Collaboration We're entering an era where the most innovative and impactful creative work will come from human-AI collaboration. AI will continue to get better at pattern recognition, data analysis, and generating variations on existing concepts. Humans will continue to excel at understanding context, emotion, storytelling, and making connections between seemingly unrelated ideas. The developers who thrive in this environment will be those who embrace AI as a powerful creative partner while maintaining their uniquely human abilities to empathize, innovate, and solve complex problems with elegance and insight. Creative thinking in the age of AI isn't about humans versus machines, it's about humans with machines, working together to push the boundaries of what's possible. The future belongs to those who can harness the best of both worlds.

Time management and productivity

dev.rubbie@gmail.com — Tue, 14 Feb 2023 00:00:00 GMT

Being productive at work is something most of us struggle with, and let's be honest, the tech industry doesn't make it easy. Between constant notifications, endless meetings, and that voice in your head saying "maybe I should rewrite this entire module," staying focused can feel impossible. Productivity as a developer means completing tasks efficiently while maintaining good quality work. Quality trumps speed every time nobody wants a half-baked product in production, and rushing usually means you'll be fixing bugs at 2 AM later. While quality is paramount, none of us have infinite time, and it's only wise to use what we have effectively. Here's what actually works for managing time and staying productive as a developer. ## Plan Ahead ![](/images/666b3394ffeb5f262292b806f9f327858f89be2b-880x880.png) Planning ahead is absolutely critical in time management. It saves you from diving into unnecessary rabbit holes that seem important but lead nowhere. Without a plan, you'll spend your day putting out fires instead of building something meaningful. Once you know what needs to be done for the day or week, you'll stay focused, organized, and productive. The developers I know who seem to effortlessly ship features aren't necessarily smarter, they just plan better. ## Prioritizing Tasks ![](/images/82ffec36f367d5ae89d91bb68679eed648b7e982-530x600.png) Not all tasks are created equal, and treating them like they are will drive you insane. That random feature request from marketing isn't as important as the security vulnerability you discovered yesterday, even if the marketing person is louder about it. The Eisenhower matrix helps you think clearly about what deserves your attention: **Important and urgent.** Drop everything and handle these. Production bugs, security issues, anything that's actively breaking things for users. **Important but not urgent**. Schedule these for when you have focused time. Code refactoring, documentation, learning new technologies that will help long-term. **Urgent but not important**. Delegate if possible. Someone needs a quick code review for a project you're not involved in? Maybe another team member can handle it. **Not urgent and not important**. Eliminate these or save them for when you have nothing better to do. That cool new JavaScript framework everyone's talking about can wait. ## Set Realistic Goals Before starting any project, be honest about what you can actually accomplish. We're all optimists when estimating how long something will take, and we're all terrible at accounting for the unexpected issues that always come up. Your goals should be achievable with the time and resources you actually have, not the time you wish you had. If you consistently miss your own deadlines, the problem isn't your work ethic it's your estimation skills. ## Use Time Management Tools Having tools that keep you accountable makes a huge difference, but the best tool is the one you'll actually use. I've seen developers spend more time organizing their task management system than actually completing tasks. Whether it's Trello, Asana, Notion, or a simple text file, pick something and stick with it. The fancy features don't matter if you abandon the tool after a week because it's too complicated. ## Automate the Boring Stuff If you're doing the same thing more than twice, consider automating it. This is where being a developer gives you superpowers.. you can write code to handle repetitive tasks. Set up email filters, write scripts for common deployment tasks, use code formatters and linters. The time you spend setting up automation pays dividends later. Plus, computers don't get tired or make careless mistakes at 4 PM on Friday. Look for patterns in your daily work. Manually testing the same API endpoints? Write some automated tests. Copying and pasting the same code snippets? Create templates or snippets in your editor. Formatting code by hand? Let your IDE handle it. ## Eliminate Distractions ![](/images/dfddfae6ec927df232dc0344593dc273b8d41b6b-612x483.png) Distractions are productivity killers, and modern technology is designed to steal your attention. Every notification is someone else's priority interrupting your work. When you need to focus, be ruthless about eliminating distractions. Put your phone in another room, close unnecessary browser tabs, use website blockers if you have to. Your future self will thank you when you actually finish that complex feature instead of spending the day reading random articles. The hardest part is recognizing when you're procrastinating. Sometimes we convince ourselves that reading about best practices or watching coding tutorials is "work" when we're really just avoiding a difficult problem. ## Take Actual Breaks This might be the most important point, and it's the one most developers ignore. Working for 10 hours straight doesn't make you productive, it makes you tired and prone to mistakes. The Pomodoro Technique; 25 minutes of focused work followed by a 5-minute break sounds almost too simple to work, but it's surprisingly effective. Your brain needs time to process information and reset. During breaks, actually step away from the computer. Go for a walk, make coffee, talk to a colleague about something other than work. Some of the best solutions to coding problems come when you're not actively thinking about them. ## Learn to Say No ![](/images/0431904fa5fbb279a5b33dd4f8795fff2750752f-320x178.gif) This is probably the hardest skill to develop, especially early in your career. Every opportunity seems important, every project seems interesting, every "quick favor" seems reasonable. But your time and energy are finite resources. Being helpful is good, but being helpful to everyone means being effective for no one. It's okay to disappoint people sometimes if it means you can deliver quality work on your actual responsibilities. Before saying yes to something new, ask yourself: what am I going to stop doing to make time for this? If you can't answer that question, the answer should probably be no. ## The Reality Check Here's what most productivity articles won't tell you: some days you'll just suck at time management. You'll spend three hours debugging a problem that could have been solved with a five-minute Google search. You'll get distracted by an interesting technical rabbit hole and emerge hours later with nothing to show for it. That's normal. The goal isn't perfect productivity, it's better productivity. Small improvements compound over time. The developer who gets 1% better at time management each week will be dramatically more effective after a year. ## Stay Productive, Stay Human Time management isn't about squeezing every second of productivity out of your day. It's about creating sustainable habits that let you do good work without burning out. Take care of yourself, be realistic about what you can accomplish, and remember that being a good developer is a marathon, not a sprint. The most productive developers aren't the ones who work the most hours, they're the ones who work the most effectively. With these strategies, you can improve your time management and productivity skills while maintaining your sanity. Because at the end of the day, productivity is just a tool to help you build better software and have a better life. Till next time, stay productive.

Trends / IOT

dev.rubbie@gmail.com — Sat, 04 Feb 2023 00:00:00 GMT

Hi, let's explore the technology trends that are reshaping our industry and examine how they're defining the future of development. We'll dive deep into one of the most transformative trends and discuss what it means for developers like us. ## The Technology Wave That Won't Stop The world is evolving at breakneck speed, and technology keeps taking new forms that would have seemed impossible just a few years ago. These trends aren't just changing how we work, they're accelerating the pace of change itself, creating a feedback loop of innovation that's both exciting and overwhelming. The recent years have brought us discoveries that leave even tech veterans in awe. We've seen AI systems that can detect diseases through scent, blockchain networks that eliminate traditional banking intermediaries, and conversational AI like ChatGPT that can write code, poetry, and everything in between. Each breakthrough feels like science fiction becoming reality. But here's what's really interesting: these aren't isolated innovations. They're interconnected pieces of a larger puzzle that's fundamentally reshaping how we think about technology, business, and human interaction. The implications go far beyond cool demos and tech conferences. For developers, this rapid evolution means our role is constantly shifting. The skills that made you valuable five years ago might not be enough today, and the technologies you're learning now might be foundational to entirely new fields tomorrow. Staying relevant means embracing continuous learning as a core part of your professional identity. ## Connecting Everything to Everything IoT represents a fundamental shift in how we think about the internet itself. Until recently, internet access was limited to devices we consciously used, computers, phones, tablets. But IoT is about embedding internet connectivity into every object around us, creating a world where your coffee maker talks to your alarm clock, and your car coordinates with traffic lights. This isn't just about convenience, it's about creating systems that can respond intelligently to real-world conditions without human intervention. Your home doesn't just have smart devices, it becomes a smart system that learns your patterns and optimizes itself accordingly. Imagine your alarm goes off in the morning, and your IoT system automatically opens the blinds, starts the coffee maker, adjusts the thermostat, and even warms up your car if it's winter. You're at work and realize you might have left the AC running, instead of driving home, you check your phone and turn it off remotely. Your refrigerator notices you're running low on milk and adds it to your grocery list. But the real power of IoT isn't in these individual conveniences. It's in the data these connected devices generate and how that data can be analyzed to improve everything from city traffic flow to hospital patient care. IoT works through a network of sensors, actuators, and smart devices connected via wireless or wired communication. These devices collect data and send it to processing systems (often in the cloud) that can analyze patterns, make predictions, and trigger automated responses. The communication happens through specialized IoT protocols designed for efficiency and reliability. Each device has a unique IP address and can be monitored and controlled remotely. The data they generate becomes the foundation for machine learning systems that can identify patterns humans would never notice and make decisions that optimize for outcomes we care about. ## The Developer's Challenge As exciting as these trends are, implementing them comes with real challenges that developers need to scale through. Complexity is perhaps the biggest hurdle. These technologies often involve multiple interconnected systems, each with their own protocols, security requirements, and failure modes. Building robust IoT applications requires understanding hardware, networking, cloud infrastructure, data analytics, and user experience design. Different IoT devices often use incompatible protocols, making it challenging to create unified systems that work reliably across different manufacturers and platforms. There's also security and privacy concerns are paramount when dealing with connected devices that collect sensitive data. Every IoT device is a potential entry point for attackers, and protecting user privacy while enabling useful functionality requires careful design. Skills Gap is real, there's a shortage of developers who understand both the technical aspects of IoT and the domain expertise needed to build useful applications for specific industries. To succeed in this environment, developers need to embrace continuous learning, collaborate across disciplines, and focus on building systems that are secure, scalable, and genuinely useful rather than just technologically impressive. ## Looking Forward The world is evolving as waves of technology trends continue to emerge and mature. As developers and technology professionals, we can't ignore these changes because they're making life genuinely better while creating new opportunities for innovation and growth. With AI and Machine Learning, Blockchain, 5G, IoT, and Cloud Computing converging, we're positioned for the next big leap in how technology serves human needs. The Internet of Things, in particular, has the potential to bring positive changes to virtually every aspect of our lives while driving innovation across industries. The future belongs to developers who can navigate this complexity, build bridges between different technologies, and create solutions that make the promise of connected, intelligent systems a reality for real people solving real problems. I had so much fun putting this together, and I hope you found it as fascinating as I do. The technology landscape is changing rapidly, but that's what makes it such an exciting time to be a developer. Till next time, keep learning and practicing 👏

Python vs *

dev.rubbie@gmail.com — Sun, 15 Jan 2023 00:00:00 GMT

Python is widely used in a variety of fields such as web development, scientific computing, machine learning, and lately has established its foothold in the world of data science and data analysis. it's simplicity & ecosystem gives it an edge over other programming languages as corporate sponsors and giants like Intel, Pixar, IBM, and Google use Python, thus pushing its popularity even further. Though Python is criticized for its runtime, which is relatively slow when compared to other languages, there is however a workaround to this specific challenge. When performance takes priority, Python gives you the ability to integrate other, higher-performing languages into your code. [Cython](https://cython.org/) is a good example of such a solution. It optimizes your speed without forcing you to rewrite your entire codebase from scratch. ## Comparison with some other languages ![](/images/88bfb42280692f2675fdcce00c3c17039f4dce1f-900x504.png) ### Python vs. Java Python prioritizes simplicity and speed of development, while Java focuses on enterprise-level stability and performance. The learning curve difference is significant, you can get productive with Python in weeks, while Java takes months to master the basics. The code difference is striking. In Java, a simple "Hello World" program requires a full class definition with public static void main methods and system output calls. In Python, it's just one line: `print("Hello World")`. This difference extends to everything you build. When it comes to development speed, Python lets you build MVPs in weeks, making it perfect for startups and rapid prototyping. Java takes months but offers enterprise-grade stability that large corporations depend on. Python excels in AI/ML, data science, and rapid prototyping, while Java dominates large enterprise applications and Android development. ### Python vs. Ruby Both Python and Ruby are beginner-friendly, but they take different philosophical approaches. Ruby offers multiple ways to solve problems with maximum flexibility, following the principle that there should be more than one way to do something. Python takes the opposite approach, advocating for one clear way to solve problems with maximum readability. Ruby shines in web applications and startups needing rapid development. It's particularly strong for high-traffic websites thanks to frameworks like Ruby on Rails. Python, however, is more versatile, excelling in data-heavy applications, educational projects, and AI/ML work. The popularity trends tell an interesting story. Ruby has been declining over the past decade while Python's growth has been explosive. This shift reflects the broader move toward data science and AI, where Python has become the dominant language. ### Python vs. JavaScript JavaScript dominates frontend and real-time applications, while Python excels in backend and data processing. They serve different primary domains - JavaScript is the king of web development and real-time interactions, while Python rules backend services, data processing, and scientific computing. Performance characteristics differ significantly. JavaScript is faster for real-time interactions thanks to Node.js and its multithreading capabilities. Python is better suited for CPU-intensive, data-heavy tasks where raw computational power matters more than response time. The learning difficulty is where Python really shines. JavaScript has a steeper learning curve with complex debugging and confusing concepts like closures and prototypes. Python is consistently rated as the most beginner-friendly language available, with syntax that reads almost like English. Scalability is another key difference. JavaScript applications are highly scalable with multithreading support, while Python is somewhat limited by its Global Interpreter Lock (GIL), though this can be worked around with multiprocessing libraries. ## Making the Right Choice The best programming language isn't about which one is objectively superior, it's about which one fits your specific needs. Choose Python if you're a beginner learning to code, work with data science or AI/ML, need rapid prototyping, value code readability, or want extensive library support. Java makes sense if you're building large enterprise applications, need maximum performance and stability, work in corporate environments, or develop Android apps. Ruby is perfect if you focus primarily on web development, work at a startup needing fast deployment, or prefer flexible, expressive syntax. JavaScript is your best bet if you build web applications (frontend or backend), need real-time features, or want to use one language for full-stack development. The best language is the one that fits your project requirements, team expertise, and long-term goals. Don't get caught up in language wars, focus on solving problems effectively. Each language has its strengths and ideal use cases, and the most successful developers are those who choose the right tool for the job rather than trying to force their favorite language into every situation. Happy coding! 👨‍💻

Choosing the right Python Web Framework

dev.rubbie@gmail.com — Wed, 12 Oct 2022 00:00:00 GMT

With Python reaching new heights of popularity in the modern era, it is vital for developers to understand its framework and which one is best for their project. Python is a very powerful language that is simple to learn and provides a quick development environment. It is a sophisticated, interpreted programming language with simple syntax. It has a plethora of libraries for web-related tasks and is ideal for large-scale web applications. There are numerous Python web frameworks; some offer more features than others. facilities than others, and some provide a higher level of flexibility or greater adaptability Some attempt to provide everything required for a web application and require the use of very specific components, whereas others focus on providing you with the bare necessities in order for you to can select only the components required by your application Either way, developers need frameworks to make things easier as it saves developers from spending time on redundant tasks. ### What we'd discuss - Python frameworks - Types of frameworks - Why using a framework is important - What every developer should know before choosing a Python Framework for their project. - Best Framework options to choose from > I'm confident that by the end of this article, you'll have no trouble choosing the best framework for your next project. Now, Let's get started! ## Web frameworks? What are they? A web framework is a collection of packages or modules that allow developers to write Web applications or services. With it, developers don’t need to handle low-level details like protocols, sockets, or process/thread management. Web frameworks help deploy, and scale web apps. Most Python web frameworks are made to run on HTTP servers such as Apache or Nginx. Frameworks can be used to reduce the amount of code a developer needs to write when creating a web application. ## Types of python web frameworks I'd be sharing with you 3 types of python frameworks... ### Full-Stack Framework Full-stack frameworks are suitable for both back-end and front-end development. Web development consists of front-end tools for graphic user interface (UI) design and back-end services like databases, security protocols, and business logic. Such frameworks are a one-stop solution for all developer requirements. Form generators, form validation, and template layouts are usually available with a typical full-stack framework. A full-stack framework will facilitate all a developer needs to carry out a full-stack development. ### Microframework These are lightweight frameworks that don’t offer additional functionalities and features, such as database abstraction layer, form validation, and specific tools and libraries. Developers using a microframework need to add a lot of code and additional requirements manually. While this might seem like a bad thing, it actually encourages flexibility for developers who want to leverage control over their software, only adding in the relevant third-party libraries when they’re completely necessary. ### Asynchronous Framework Gaining popularity recently, any asynchronous framework is a microframework that allows for handling a large set of concurrent connections. Asynchronous programs are event-driven. Rather than line-by-line operational handling where one function runs after the other, asynchronous code doesn't wait for one event to execute before starting another. Typically, an asynchronous framework built for Python uses the programming language’s asyncio library. ## Why it's important There are several redundant operations in web development. Python frameworks allow developers to reuse code for common HTTP operations. The projects are structured in such a way that other developers with knowledge of that particular framework can easily use it to build and maintain web applications. Python Framework will help you with; - Interpreting requests (getting form parameters, handling cookies and sessions, etc) - Producing responses ( presenting data as HTML or in other forms) - Persistently storing data - Secure framework - Open-source - Code reusability - Easy integration ## What you should know before selecting a web framework Every developer should consider the following while deciding on a Python framework: First, evaluate the size and complexity of your project. If you have to develop a large system packed with features and requirements, a full-stack framework will be the right choice. On the contrary, if the project at hand is small and straightforward, you can work with micro frameworks. The second aspect to consider is whether or not the framework allows the scope for scaling both vertically and horizontally. This is particularly necessary when building a project that will run on multiple servers, handle a huge traffic load, and support adding new features for functionality optimization. Developers should focus on finding the right framework for them, let your desired framework be well suited to handling the kind of project you are working on. There is indeed a need to use a framework with good documentation. Good documentation allows a developer to start working rather than trying to find how to use the framework's features. Developers as well should choose reliable frameworks. A reliable framework is one that tries to stay current with the new ways of working as the python language evolves. Also, developers must ensure to choose extensible frameworks. If a framework offers well-designed and documented extension points, it will be easier to adapt to your special requirements in a way that doesn’t break with version updates. Also, it will be easier to take advantage of general extensions or plugins that other framework users have created. ## BEST FRAMEWORK OPTIONS TO CHOOSE FROM. Below are recommended frameworks to choose from, however, you are not limited the ones listed here. Remember to search and understand others, as they may end up becoming the right one that best suits your project. ### Django > Type: Full-stack web framework Django is a free-to-use Python web framework that allows python developers to quickly create complex code and apps. Developers can quickly create high-quality web applications and APIs using the Django framework. It’s because this top-of-the-line Python web development framework comes with a robust set of features and libraries. This eliminates the need for a lot of coding and allows for code reuse. As a result, the web application development project streamlines and shortens the time it takes for an app to reach the market. #### KEY FEATURES - Assists Developers in defining patterns for app URLs. - Built-in authentication system. - A simple but effective URL system. - Object-oriented programming language database that offers the best data storage and recovery. - The automatic admin interface feature allows you to customize the editing, adding, and deleting of items. - Multiple cache mechanisms are supported by a cache framework ### Pyramid > Type: Full-stack web framework Pyramid is one of the Python web frameworks with lots of features. It also has a wide range of applications, including websites, web APIs, and anywhere you may want to use a popular programming language like Python is needed. Pyramid is also known for its expandability, testability, and flexible, modular architecture. One of Python’s most valuable assets as a developer language is its community support, which is evident here in the form of user involvement on mailing lists, IRC channels, Stack Overflow, and other sites. #### KEY FEATURES - It allows you to run both small and large apps efficiently. - HTML structure validation and generation - All-embracing templating and asset details - Testing, support, and extensive data documentation - Customizable Authentication and Permission helpers ### FastAPI > Type: Micro web framework FastAPI is a modern, fast, high-performing web framework for building APIs with Python 3.6+. The reason it works with Python 3.6 or later is that it gets the Async feature. It was created by Sebastián Ramírez after he was not impressed with existing frameworks such as Flask. One of the aspects of FastAPI is that its performance is on par with NodeJs & Go. FastAPI supports both synchronous and asynchronous requests and also has built-in support for data validation, serialization, authentication, and authorization. It is built on top of starlette, thereby allowing the creation of asynchronous APIs that allow for performance comparisons with NodeJs & Go. ### KEY FEATURES - Speed: FastAPI is indeed fast when it is compared to frameworks such as Django and Flask. - Async code: One of the promising features of FastAPI is that it supports asynchronous code using async/await keywords. - Fast to Code: The amount of code that needs to be written with FastAPI is lesser when compared to Django and Flask. ### Bottle > Type: Micro web framework Bottle is also one of the most prevalent Python micro-framework, and it’s ideal for rapid development and small web apps. It’s a WSGI-compliant framework that’s quick, simple, and lightweight, and it’s distributed as a single file module. Bottle, which was originally designed for building APIs, implements everything in a single source file and includes only the most basic tools, such as routing and templating. For those with a basic understanding of Python and web development, the learning curve is extremely simple. Bottle is the most useful python framework for creating mobile applications. #### KEY FEATURES - Using simplified syntax, create spotless and dynamic URL routes for mapping. - Built-in template engine and backing that is quick and pythonic. - WSGI framework is compatible with CGI, and understanding WSGI internals is simple. - Allows data, cookies, file uploads, and other HTTP-related metadata to be accessed quickly. - Worked as an multi-threaded web server and backend for glue, fapws3, flup, and other WSGI-capable HTTP servers. - Speed optimizations for testing and high performance ### Cherrypy > Type: Full-stack framework Cherry Py is a fantastic popular python web framework that can be used to build a wide range of web applications. It’s intended to be simple to understand and use. It is one of the most approachable frameworks on our python frameworks list because of its focus on simplicity and usability. Cherry Py might be perfect if you’re an intermediate developer looking to attempt something new. While advanced developers may find its features lacking, it provides an opportunity for beginners to gain experience with Python before moving on to more complex frameworks. Cherry Py’s main selling point is that it enables users to operate their code without having to rely on other people or services. You can create an application entirely from CherryPy components. #### KEY FEATURES - A WSGI thread-pooled webserver that is consistent and HTTP/1.1 compliant. - It’s simple to run multiple HTTP servers (for example, on multiple ports) at once. - Python 2.7, 3.5, PyPy, Jython, and Android are all supported. - Cross-site scripting, sessions, caching, authentication, static content, and many other features are all built-in. - A powerful configuration system for developers and deployers alike - Built-in profiling, coverage, and testing support ### BlueBream > Type: Full-stack framework BlueBream is also a web application framework, server, and library for python developers that is open-source. This framework works best for medium and large activities that are divided into reusable and well-suited segments. BlueBream (ZTK) uses the Zoop Toolkit. It has extensive experience ensuring that it meets the primary requirements for long-lasting, consistent, and adaptable programming. #### KEY FEATURES - It emphasizes Python Web Server Gateway Interface (WSGI) compatibility. - Frameworks for unit and functional testing. - The fundamental approach to plugged security. - An XHTML-compliant language for developing templates. - A tool for automatically generating forms. - Separation of concerns is used in the Zope Component Architecture (ZCA) to create reusable components.Flask > Type: Micro web framework Flask is one of Python’s most popular web frameworks, and it continues to grow in popularity. Flask basically provides routing and templating, wrapped around a few configuration conventions. Its objective is to be flexible and allow the user to pick the tools that are best for their project. It provides many hooks for customization and extensions. Flask is simple to learn, exquisite to use, has a large add-on library, and is simple to deploy. Its popularity stems from its ease of use allows you to get up and run with minimal effort. Flask provides for an accelerated way to build websites with Python. It doesn’t have the same level of structure as Django or Pyramid, but it’s still a great place to start building useful apps. #### KEY FEATURES - Integrated debugger and development server. - Request dispatching via RESTful API. - Support for integrated unit testing (code with quality). - Jinja2 templating is used (tags, filters, macros, and more). - 100% WSGI 1.0 compliant. - Multiple extensions provided by the community ease the integration of new functionalities. ### Tornado > Type: Asynchronous web Framework Tornado is a combination of an asynchronous networking library and a web framework. It is intended for use in applications that require long-lived connections to their users. It is well-known for its high task performance, as the framework is capable of threading more than 10,000 connections simultaneously. Tornado is an open-source asynchronous framework for performing I/O operations. Tornado has its own HTTP server based on its asynchronous library. While it’s possible to use the web framework part of Tornado with WSGI, to take advantage of its asynchronous nature it’s necessary to use it together with the web server. #### KEY FEATURES - Allows third-party authentication and authorization schemes. - Superior quality, real-time services, and non-blocking HTTP customers - It produces high-quality results. - Assistance with interpretation and localization. - Web templates and user authentication are both supported > Yay! And this comes the end of this article. I believe you have learnt a lot. Hurry now and put into action what you have learnt Thank you for reading my article!

Every developer's story i guess

dev.rubbie@gmail.com — Mon, 26 Sep 2022 00:00:00 GMT

*The day begins with a regular weekday ritual. Boots PC, machine humming, screen flickering to life, fingers dancing across the keyboard. logs in. Stares in the abyss for like 2 seconds, snaps back to reality, creates "untitled-project", opens vscode.* *And then, silence. Not the good kind. The kind that seeps into your neck, sharpens into a migraine, and leaves you staring at a glowing screen at 2 AM as though it holds the answers to all your problems.* *Thoughts scatter, chasing themselves in circles... What now? What’s worth building? Something cool? Something useful? The pressure tightens, the silence grows.* *Until, finally, a voice breaks free, this time it's your voice. ****"F*ck!"****. Burnout; The word tastes bitter, heavy. But it’s only the beginning.* I've been there, you've been there, we all have been there. According to the World Health Organization, burnout is a syndrome conceptualized as resulting from chronic workplace stress that has not been successfully managed. Burnout is an everyday reality. However, due to the high demands for productivity and workload complexities, the tech industry might just be the most affected. ## When the Code Stops Flowing There are several factors responsible for burnout, ranging from internal to external pressures. The constant pressure to ship features, learn new frameworks, debug complex issues, and meet impossible deadlines creates a perfect storm. You want to be sure your mind is properly cleared of all the mental clutter before you start coding again. The pain of getting something done after you've just suffered burnout is probably the most frustrating feeling you'll experience as a developer, right alongside debugging production issues at 3 AM and meeting deadlines at godspeed. Hence, you must properly handle burnout before you kick off with work. You wouldn't want to experience a second wave of burnout after just recovering from the first. Let's get real about what went wrong. Maybe going through what happened isn't the best idea right now, so I'll assume you've already started addressing the emotional aspects and you're ready to get back on track. Dealing with any form of emotional distress can be overwhelming, and trying to code in that state usually results in nothing productive. It's best to be completely healed before picking up that laptop again. Haven't solved your emotional problems yet? Take your time to heal, be true to yourself, and identify the root cause of your burnout. Give it time, you'll recover. Keep your head high. ## Getting Back on Track Different approaches work for different people. There are several ways to recover from burnout because there's no *one-size-fits-all* solution. The key is doing what works best for you after identifying your specific stressors. Start with doing absolutely nothing. Take some time off and find a new hobby. You probably haven't played your favorite sport in weeks or months. Make time for things you genuinely enjoy. Watch that movie you've been putting off, catch up with friends, eat your favorite meal, go on that date you've been postponing. Practice mindfulness as well because it clears your mind and puts things in perspective. It makes your priorities simple and crystal clear. When you're ready to return, remember not to overwork yourself. You're still recovering, so learn to say no when assigned multiple tasks. Focus on getting things done one at a time rather than juggling everything simultaneously. Start slowly when you come back. Avoid jumping straight into 8-10 hour coding sessions like you used to. Ease yourself back into the rhythm to avoid overwhelming yourself with pressure. Consider trying a different programming language or technology stack. Work with new databases and tools you haven't explored before. Change your coding environment entirely. Switch up your workspace, try coding in a different location, or if you're a Windows user, experiment with Mac or Linux. Use a different text editor or IDE. Learning new things helps reignite your passion for development and breaks you out of the monotonous routine that might have contributed to your burnout. ## Preventing Future Burnout Trash unimportant tasks and stay focused on what matters. Look at your task list and decide which items aren't critical to finish first. Rank each task by importance and impact. Eliminate work that requires significant effort but provides minimal value. Always keep things fresh and maintain your passion for coding. Working with the same old technology stack every day gets boring fast. Even if your job responsibilities don't allow you to experiment with different technologies, find ways to explore on your own time. Try new libraries, take on freelance projects, contribute to open source projects, and venture beyond your comfort zone. It won't help instantly, but it pays off in the long run. Avoid marathon coding sessions and take regular breaks throughout the day. Sitting in front of a computer for 8-10 hours without breaks doesn't make you more productive. Science has proven that productivity decreases sharply after 4 hours of focused work. Stretch every hour, take a walk, grab a snack, or chat with colleagues. Offer to help with code reviews or assist with unit tests. Don't just code all the time. Spend quality time with family and friends. Read books, attend meetups or conferences, listen to industry podcasts, or write technical blog posts. Diversifying your activities keeps your mind engaged in different ways. Exercise regularly and get enough sleep. Don't stay glued to your chair all day. After work, do some physical activity and eat healthy food. Your brain needs proper fuel for all the complex work it does. Identify your specific stressors and actively work to avoid them. Whether it's unrealistic deadlines, toxic team dynamics, or perfectionism, knowing your triggers helps you develop coping strategies. Always follow an iterative development process on large projects. Don't try to code an entire massive program at once because that's a quick path to frustration. Develop small parts, test them, and then move on to the next piece. This approach provides regular wins and keeps you motivated. It's much harder to recover from burnout once you've been deep in it for weeks or months. Seek help immediately when you notice early warning signs. Choose a lifestyle and work approach that prevents burnout rather than trying to cure it later. Understanding that burnout reduces your productivity to almost zero and makes life miserable should motivate you to take prevention seriously. Burnout is like a tunnel that just keeps going, so it's better to avoid it before things get worse. ## The Gap and Your Career Coming from a recruiter who just reviewed your resume, explaining career gaps can be challenging, especially when those gaps resulted from burnout. How do you explain that you needed time away without raising red flags about your reliability? If you've been away for weeks or months, you already have a gap in your career timeline. The longer the gap, the more difficult it becomes to explain, but you still need to start applying for jobs when you're ready. When asked about the gap during interviews, you definitely don't want to launch into your burnout history with your potential employer. If you say "I got burnt out and stopped working," you'll spend the entire interview trying to convince them you won't quit halfway through a project. No recruiter wants to hire someone who might leave unexpectedly, regardless of their technical skills. They'd rather hire someone new who will learn your previous work than risk another departure. You need to tell your story strategically. This doesn't mean lying about your time away, but rather framing it in a way that demonstrates your value and commitment. ## Explaining Resume Gaps like me xD Start by avoiding discussion of the burnout entirely. Instead, talk about skills you developed and focused on during your time off. For example: "I took time away from work from this time to that time. In anticipation of my return to the workforce, I've done X, Y, and Z." These don't have to be computer-related activities. If you can demonstrate that during your break you learned better project management skills, resolved personal matters that won't recur, or developed new capabilities, that shows growth and intentionality. Employers will want assurance that your technical skills are still sharp. Take refresher courses if needed, practice on coding challenge platforms like HackerRank, and work on personal projects to demonstrate your continued engagement with technology. When asked "Why should we consider employing you, despite these gaps?" this becomes your opportunity to sell yourself. Focus on your qualifications and previous project successes. If you completed courses or earned certifications during your time away, these signal active pursuit of professional development. Discuss the soft skills you gained during your break and how they contribute to your readiness to work effectively. Be prepared for gap-related questions so you don't get caught off-guard during interviews. By staying positive, honest, and proactive, you can navigate the challenging conversation about career breaks successfully. ## Something for tomorrow To prevent future work interruptions due to burnout, establish social circles and routines that support your mental health. It's crucial to have a life outside of work that includes physical activity and social interaction beyond solitary hobbies. Find a therapist who works well with you, join a recreational sports team, find a running club, or engage in activities that ensure regular social and physical interactions outside of work. These connections provide perspective and support when work stress increases. Remember that frequent burnout significantly reduces productivity, so seek help at the first signs of trouble. Create systems and structures that keep you mentally healthy and engaged. Burnout is like a tunnel that just keeps going, so it's better to prevent it before the situation becomes unmanageable. Keep your head high and remember that taking care of your mental health isn't a luxury, it's essential for a sustainable career in tech.

Joining Colabra

dev.rubbie@gmail.com — Thu, 10 Feb 2022 00:00:00 GMT

In 4 days i'll start my new role at [Colabra](https://www.colabra.ai/), and honestly, I'm pretty excited about it. I've been looking for a company that's working on something that actually matters, and Colabra feels like that. They're building tools to help scientists collaborate better... which sounds simple but is actually a huge problem. Most researchers are still stuck with tools that feel like they're from the 90s. The welcome email they sent was... intense. In a good way? It's clear they've thought a lot about how to work as a remote team and go async first in communication. - "Do what adds value to the team, not what you're used to". I like this pragmatic approach - Assume good intentions when things go wrong (revolutionary, I know) - Everything gets documented, which as a someone who's going to jump into a gigantic codebase, I deeply appreciate The tech stack looks fun too. They're using Vue.js *(i picked vue sometime 2yrs ago)* and some interesting collaborative editing tech Y.js for realtime collaboration and tiptap for rich text. It's the kind of stuff that makes building a collaborative platform for scientists actually possible. They have a really cool mission: "increase the world's scientific output." Simple and straight to the point. They believe that better tools can help scientists discover things faster, and honestly, why shouldn't that be possible? The team seems solid, I'll be working with engineers across different time zones, which is isnt new for me and feels like the future anyway. They're sending me actual books to read ("The First 90 Days" and "The Culture Map"). I'm curious to see what we build. If we can make scientists' lives even a little bit easier, that feels like time well spent. More updates to come as I figure out what I'm doing here.

Courier

dev.rubbie@gmail.com — Mon, 24 Jan 2022 00:00:00 GMT

## Overview Courier is a desktop application written in Python and Qt for data transfer between machines connected to the same network. The connection uses WebSockets to send text and binary data.WebSockets is a web technology providing full-duplex communications channels over a single TCP connection. The WebSocket protocol was standardized by the IETF as RFC 6455 in 2011. ## Application Flow ![](/images/6901200d50e0664b3a94a280ba7ed1abb85fa397-2048x1457.png) The whole process begins at the server application, the server searches for an incoming connection, waiting for a client to connect. Once a client is connected, it is handled in another thread called the client thread. While repeating the process in the main thread, the server handles the client thread in the background. Login password is collected from the handled client, which is used to initialize the handshake process. If the handshake is unsuccessful, the client is purges off the network, ending the thread. If the handshake is successful, (password is correct), a client profile is created on the server. This allows other clients to identify the specific client, enabling direct messaging and file transfer from one client to another. When a client sends a message it is bundled with meta-data that tells which client the message is coming from, what client the message is sent to and also some extra information. The message is sent to the server, which is then parsed in the server application. The server identified the receiver client address, and then sends the message. For binary data, the server helps initialize a direct client-server relationship between the clients. which enables faster file transfer without data passing through a middle man. ## The User interface ![](/images/d4fc99b07377647efe23e2722eda1d50101e5410-1152x700.png) The application is designed as a single screen application with 3 split sections. The first section contains the contact list for easy handling of contact profiles. Contact profiles are structured data in the server application that holds details about connected client applications. This detail is sent by a single client application to the server, which is then shared to other client applications for profile update. The second section contains the main functionality, the chat space for sending messages and files. The third section is used to manage multiple view like settings, user profile, and menu. For ease of user & wide area on the second section, the third section is design to be closable. ## Python & Qt Qml ![](/images/d25a523739ce993471b2448d59b3ac8dcbe3276f-512x233.gif) Python is known for its ease of use & its role in fast development time. Thankfully, Qt's binging for python makes building this application in record time possible. Qt's QtQuick UI technology makes it very easy to create modern interfaces, hence, being a very good choice for the project.

Getpass: Hiding sensitive input from the shell

dev.rubbie@gmail.com — Thu, 14 Jan 2021 00:00:00 GMT

# Getpass: Secure Password Prompt > This article is mostly part of Doug Hellmann's "The Python3 Standard Library by Example" book. The strength of [Python’s](https://python.org/) standard library is its size. It includes implementations of so many aspects of a program’s structure that developers can concentrate on what makes their application unique, instead of having to write all the basic pieces over and over again. This series covers some of the more frequently reused building blocks that solve problems common to so many applications. This article would be short and straight forward, compared to the last one i wrote on argpase... Let's just get started. ## getpass() : the function. Many programs that interact with the user via the terminal need to ask the user for password values without showing what the user types on the screen. The getpass module provides a portable way to handle such password prompts securely. The getpass() function prints a prompt, then reads input from the user until the user presses the enter key. The input is returned as a string to the caller. ```python import getpass try: password: str = getpass.getpass() except Exception as e: print('ERROR:', e) else: print('You entered:', password) ``` The result on the terminal: ``` $ python file.py Password: You entered: mypassword ``` The default prompt is *"Password"*, and the prompt value can be altered by adding a new argument. ```python import getpass age = getpass.getpass(prompt="How old are you?") age: int = int(age) # lets assume the user only inputs an integer value if age >= 18: print("logging in...") else: print("you cant access this content!") ``` The result on the terminal: ``` $ python file.py How old are you? logging in... ``` ## Changing the stream By default, getpass() uses sys.stdout to print the prompt string. For a program that may produce useful output on sys.stdout , it is frequently a better choice to send the prompt to another stream such as sys.stderr. ```python import sys import getpass password: str = getpass.getpass(stream=sys.stderr) print('You entered:', password) ``` Using sys.stderr for the prompt means standard output can be redirected (to a pipe or file) without seeing the password prompt. The value entered by the user is not echoed back to the screen. ``` $ python file.py > /dev/null Password: ``` ## Using getpass without a Terminal Under Unix, getpass() always requires a tty it can control via termios , so input echoing can be disabled. With this approach, values will not be read from a non-terminal stream redirected to standard input. Instead, getpass tries to get to the tty for a process, and no error is raised if the function can access it. ``` $ echo "not secret" | python file.py Password: You entered: secret ``` The caller is responsible for detecting when the input stream is not a tty, and using an alternative method for reading in that case. ```python import getpass import sys if sys.stdin.isatty(): password = getpass.getpass('Using getpass: ') else: print('Using readline') password = sys.stdin.readline().rstrip() print('Read: ', password) ``` Output with a tty: ``` $ python file.py Using getpass: Read: secret ``` For the most basic cases all you'll need is the getpass() function, but if you find the extra details helpful, as well as the rest of the article... feel free to [follow me on twitter](https://x.com/kelvinrubbie). and also leave a comment if you have any issues following this tutorial. Happy coding!

Argparse: Command-line parsing.

dev.rubbie@gmail.com — Sat, 02 Jan 2021 00:00:00 GMT

The strength of [Python’s](https://python.org/) standard library is its size. It includes implementations of so many aspects of a program’s structure that developers can concentrate on what makes their application unique, instead of having to write all the basic pieces over and over again. This series covers some of the more frequently reused building blocks that solve problems common to so many applications. Argparse is an interface for parsing and validating command-line arguments. It supports converting arguments from strings to integers and other types, running callbacks when an option is encountered, setting default values for options not provided by the user, and automatically producing usage instructions for a program. This article will help you apply your knowledge of argparse in an actual project. # Gear Up! ## What we'll be doing We'll be creating a simple todo cli app, using argpase. With our app, we'll be able to: - add a task - list all tasks - check a task - uncheck a task - delete a task ## What we won't be doing I assume you're experienced with the basic aspects of python programming. We would not be going over the basics of python you're expected to have knowledge of python language while reading this article. Also, We'll not be going over the basics of argpase. checkout these articles to get started with argparse. - [realpython - argpase](https://realpython.com/command-line-interfaces-python-argparse/) ## Getting started Firstly, we'll be going over features of our app, and the format in which our todo list will be stored. We'll be representing our features with functions, but just before we go over writing our functions, lets determine how our todo list will be stored. ## How we'll store our todo list the todo file will be saved as a json file, with the top-level object being a javascript array. the array will contain objects representing a todo item with 3 basic keys: id, task, checked. - the id is a unique key representing the todo item. we'll need this as a pointer to perform specific actions on a todo item. - the task key will simply contain the task - the checked key will be used to store boolean values, to indicate if the task has been completed Here's an example: ```json [ { "id": 0, "task": "fix that bug in line 877", "checked": false }, { "id": 1, "task": "visit angie at her gandma's", "checked": true } ] ``` Now that we have an idea of how we'll be storing our todolist, lets go ahead and write our functions. ## Coding the features The most basic thing we need right now, are functions to write and read a todo file. Since its clear we'll be manipulating json strings, you can go ahead and import the json module. For this totorial, we're using a fixed todo name. You can alter the source after understanding this article. ```python import json TODO_FILENAME = '.todo' ``` ## Writing a todo-list To write our todo list, all we need to do is open our filename, then write our python list to it as a json file. Opening the TODO_FILENAME with the 'w' parameter, attempts to open TODO_FILENAME and creates it if it doesn't exist. ```python def write_todo_file(data: list): # opening a file as write mode,... # creates the file if it doesnt exist with open(TODO_FILENAME, 'w') as file: # the indent option is to improve readability json.dump(data, file, indent=2) ``` ## Reading a todo list Now we'll need a function for reading our todo list. you'll notice the code snippet below is slightly complex than the one above. Here, we'll first need to check if the file exists, and we'll do that using the os.path module. let's go ahead and add a new import. ```python import os # ... ``` After importing this library, we can now write our function. first we check is the file exists. if the file exists we just read the data from the file and return whatever we find. In a case where the above operation isn't successful, i.e, the file doesn't exist, we'll create and return an empty list, representing an empty todo list. ```python def read_todo_file() -> list: # check if the file exists if os.path.exists(TODO_FILENAME): # if it exists, the load the data and return it with open(TODO_FILENAME) as file: result: list = json.load(file) return result # else just write and return an empty list write_todo_file([]) return [] ``` ## Generating unique id To manipulate our todo-list efficiently, we'll need each todo item with a unique id. We could do something like *every* *n* *number of todo-item in the todo list will hav an id of n.* that could work, but would crash if a number between 1 and n was deleted, and then we add a new item. so instead we find the todo with the biggest number, and then create a new id by adding 1 to its id. ```python def generate_todo_id(todo_list: list) -> int: if not todo_list: return 0 # ----------(i) max_id_todo: dict = max( # ------------(ii) todo_list, key=lambda todo: todo.get("id", 0) ) max_id: int = max_id_todo.get("id", 0) return max_id + 1 ``` ## Creating a todo-item All we need to do here is construct a new dict object and add it to the list. ```python def add_todo(task: str): todo_list: list = read_todo_file() todo = dict( id=generate_todo_id(todo_list), task=task, checked=False ) todo_list.append(todo) write_todo_file(todo_list) ``` ## Deleting a todo item To delete a todo, all we have to do is fish out the todo wth the given id, and then make a new list without it. ```python def delete_todo(id: int): todo_list: list = read_todo_file() todo_list = [todo for todo in todo_list if not (todo.get("id") == id)] write_todo_file(todo_list) ``` ## Checking/UnChecking a todo item To check a todo item, we'll also need the todo's id to locate the todo item. Looping through the todo list, we test if each todo's id match the given id, if we find a match, alter the checked state. ```python def check_todo(id: int, state: bool): todo_list: list = read_todo_file() for todo in todo_list: if todo.get("id") == id: todo["checked"] = state break # let's quit the loop write_todo_file(todo_list) ``` ## printing out a todo list ```python def print_todo_list(): todo_list: list = read_todo_file() for todo in todo_list: todo["checked"] = "checked" if todo.get("checked", False) else "not checked" print("{id} [{checked}] {task}".format(**todo)) ``` ## Testing out our code Suppose we saved our source as todo.py, launch a python or ipython console in the same directory where your source is located, and then try the following lines. ![](/images/f75c5e574664a4ee360d1c288c754c80aca98c06-656x502.png) open the file named .todo and you'll see something like this: ```json [ { "id": 0, "task": "publish this article", "checked": false }, { "id": 1, "task": "like all my own tweet :(", "checked": true } ] ``` ### Setting up a parser Remember our app is a command-line application, we'll now have to set up argparse in our code. our program should be written, so it should work as such: ``` python todo.py --task "take my imaginary girlfriend to dinner" # adds new to-do python todo.py --check 1 --id 0 # checks a to-do item with id=0 python todo.py --delete --id 3 # deletes a to-do item with id=3 python todo.py --print # prints the to-do list ``` > TIP: if you want to skip the python prefix, add the following shebang to the first line of your script. ```sh #!/usr/bin/env python #... ``` Now you can do somthing like this on your shell: ``` ./todo.py --print ``` ## The argparse.ArgumentParser Class The first step when using argparse is to create a parser object and tell it which arguments to expect. The parser can then be used to process the command-line arguments when the program runs. The constructor for the parser class ( ArgumentParser ) takes several arguments to set up the description used in the help text for the program and other global behaviors or settings. ```python import argparse if __name__ == "__main__": parser = argparse.ArgumentParser( prog="todo", description="a simple cli app for managing todo", allow_abbrev=False, epilog="with love by rubbie" ) ``` ### Defining arguments argparse is a complete argument-processing library. Arguments can trigger different actions, specified by the action argument to add_argument() . Supported actions include storing the argument (either singly or as part of a list), storing a constant value when the argument is encountered (including special handling for true/false values for Boolean switches), counting the number of times that an argument is seen, and calling a callback to use custom processing instructions. The default action is to store the argument value. If a type is provided, the value is converted to that type before it is stored. If the dest argument is provided, the value is saved using that name when the command-line arguments are parsed. For this simple program, we'll need 5 arguments: - id: for specifying a todo items id to be used with actions like delete, check. - print: for printing our todo list to the console - task: for creating a new task - check: for checking/unchecking a todo item - delete: for deleting a todo-item Let's go ahead and write our code. ```python # ... if __name__ == '__main__': # ... # arg for passing id parser.add_argument( "-i", "--id", action="store", type=int, help="specify a todo-items id" ) # args for creating a new to-do item parser.add_argument( "-t", "--task", action="store", type=str, help="create a new todo item" ) # args for deleting a to-do item parser.add_argument( "-d", "--delete", action="store_true", help="deletes a todo item with the given id" ) # args to check a to-do item parser.add_argument( "-c", "--check", action="store", type=int, help="checkes or uncheckes a todo item [0|1]" ) # arg print the to-do lisy parser.add_argument( "--print", action="store_true", help="prints the todo list" ) args = parser.parse_args() # ----------------(i) ``` Now we've set up our arguments and parsed into a variable named args. we'll just need to access our arguments and then call our functions. ```python # ... if __name__ == '__main__': # ... # editing operation if not (args.id is None): if args.delete: # ... delete to-do delete_todo(args.id) if args.check: # ... check to-do check_todo(args.id, bool(args.check)) # add operation else: if args.task: add_todo(args.task) # ... if args.print: print_todo_list() ``` now that we have this in our script, we can go ahead and test our new application in the terminal. ``` ./todo.py --task "wrap this up" ./todo.py --check 1 --id 0 ./todo.py --print ``` That's all for this tutorial, I hope it works for you 'cus it worked on my machine. if you're having troubles getting this done, please leave a comment below. if it goes well for you, feel free to follow me on [twitter](https://x.com/kelvinrubbie). If you'd like to follow through the exact same code, you can find the source at [github](https://github.com/rubbieKelvin/argparse-tutorial). happy coding!.

Annotating stuff in python

dev.rubbie@gmail.com — Thu, 10 Sep 2020 00:00:00 GMT

> Annotations in Python are a way to attach metadata to function parameters and return values, primarily used for type hints. They help improve code readability and can be utilized by tools like IDEs and static type checkers, but they do not enforce type checking at runtime. A lot of times, we run into bugs while writing python scripts, most of which is caused by wrong variable types in the wrong places. Unlike other languages like c++ and java, python is dynamically typed, which is an advantage of the language as well as a disadvantage because a variable type can be change at any point in run time. Most times we try to fix these bugs by commenting & documenting several parts of the code. Although using annotations doesn't compare to C++ (or java, C) static typing and isn’t a way to validate types “out of the box”, annotations could be used for further documentation as they can describe variable, argument and function return types. ## Pushing through While you follow up with this article, you’ll notice I assume you have basic knowledge of python, especially variables and function. I assume you’re running python 3, as syntax support for annotations was introduced in python 3.0. I’ll encourage you to give feedback and also report errors i made at some point in this article. Also to follow up with this article, you’ll need a python IDE or a modern text editor like sublime text, vs code (make sure code suggestions are enabled and necessary python plugins are installed). ### Annotating variables ```python name:str = "rubbie" ``` While studying the line of code above, you notice the only difference between this and naming a variable regularly is that there a colon between the variable name and the proposed variable type. Pretty easy right? Just to be in check, lets go through a few points to note about annotations. - Annotations are optional - Annotations do not ensure static typing - Annotations simply provide type hints to variables - Annotations let IDEs show function arguments and return types - Annotations are nothing more than a way of associating python expressions with a variable or various parts of a function at compile time. Python itself, doesn’t attach any significance to annotations. Having read the points above, you should understand how the following code works. ```python age:int print(age) ``` the code above would raise a NameError in line 2, because line one doesn't define the variable age, but only registers a description for it. ### Annotating Functions Arguments ```python def triple(num:int): """ triples a number :num this number would be tripled """ return num*3 ``` annotating functions is really useful, especially if you create python libraries for other developers. When writing in this function’s scope, your IDE would think of num as an integer and would suggest you pass an integer when you try to call it. ### Annotating Function return value annotating return types isn’t like the first two we discussed, but still isn’t difficult to understand. ```python def triple(num:int) -> int: # … return num*3 ``` this piece of code describes the return value of triple to be an integer in your IDE. Go ahead an try out these examples on your IDE, as you use annotations, you’ll figure out how helpful they are while writing your next script. ### Accessing Annotations All annotations are stored in a dictionary named __annotations__, which is an attribute of a function. Here’s an example. ```python def tenPercent(num:int) -> float: # … return num * .1 print(tenPercent.__annotations__) ``` That’s all for this article. If you need to provide type checking in your functions, there are simple ways to go about it, which I wouldn't be going through in this article. *Happy bug hunting.*

As early as print()

dev.rubbie@gmail.com — Thu, 25 Jun 2020 00:00:00 GMT

Ah! you're here. I guess you're just learning to code (welcome to the alternate universe) or you already learned to code but skipped a lot of the boring parts. Well, you're here, so how about I take you far back, as early as print()? In this article, I'll be taking you through Python's inbuilt function print(), and also a bunch of stuff that'll be useful as you continue your journey in this universe. ## "Hello, World!" If you started your programming journey from tutorials or an article like this, *Hello, World!* must have been your first program (it wasn't for me...). A "Hello, World!" program generally is a computer program that outputs or displays the message "Hello, World". In Python, it'll be written like this: ```python print("Hello, world") ``` We wouldn't really be focusing on the basics, so let's get down to business. ## Printing Multiple Objects The print function is used to print Python objects to the console. There might be cases where we would need to print multiple objects to the screen. All we need to do is add multiple arguments to the print function, and we'll get a clean result. ```python is_active = True name = "Harry Potter" language = "JavaScript" print("rubbie knows", language) print(name, "is active:", is_active) print("hello, world.", "my name is Rubbie") # Unpopular opinion: print("hello, world." + " my name is Rubbie") ``` Someone from the crowd: *"what's the difference between* *print('hello, world.', 'my name is Rubbie')* *and* *print('hello, world.' + ' my name is Rubbie')?"* Okay... looks like I just got a question 😂. In the first example, we're actually printing two string arguments, which are automatically separated by a whitespace once printed. In the second example, we're printing a single string argument. Both strings are just added together in the print function's parentheses. This produces the same results but may not work so well on other data types aside from strings. ```python # you can't add a string and an integer print("i am" + 6) # --> TypeError # both lines produce different results print(5, 5) # --> 5 5 print(5 + 5) # --> 10 ``` ## Separating Arguments with the sep Keyword Argument If we were to write a story using multiple print statements, we'd want to preserve newlines: ```python print("Rubbie woke up in the morning.") print("He took his dog down the street for a walk.") print("Few minutes later, he came back home.") print("The end.") ``` If we wanted to write this same story with one print statement and still preserve the new lines, we'd pass "\n" to the sep keyword argument. ```python print( "Rubbie woke up in the morning.", "He took his dog down the street for a walk.", "Few minutes later, he came back home.", "The end.", sep="\n" ) ``` ### Other examples ```python print("hello", "world", sep=",") # result: hello,world print(3, 5, sep="*") # result: 3*5 ``` ## The print Function's end Keyword By default, when we use the print statement, it ends with a newline, making the next text appear below it. To make the next printed statement start next to the previous line, we can pass a value to the end keyword argument. ```python print("hello", end=" ") print("world") ``` ## Packing and Unpacking This part isn't only common to the print function; arguments and keyword arguments can be packed into other functions too, but I thought I shouldn't leave this out. Instead of looping through a list to print each element, we can unpack the list directly in print: ```python days = ["Mon", "Tue", "Wed", "Thur", "Fri", "Sat", "Sun"] print(*days, sep=", ") ``` ### Practical Example ```python name = "rubbie kelvin" languages = ["python", "javascript", "c++"] print(name, "can write in", end=" ") print(*languages, sep=", ") def inclinedplane(char, height): char = char[0] # we need only one character return [char * i for i in range(1, height + 1)] result = inclinedplane("*", 10) print(*result, sep="\n") ``` ## Suppressing the print Function The print function is a good debugging tool, but sometimes, we may want to remove all print statements. Instead of manually deleting them, we can disable the print function by overwriting the standard output. ```python import sys, os def disable_print(): sys.stdout = open(os.devnull, 'w') def enable_print(): sys.stdout = sys.__stdout__ print("this will be printed on console") disable_print() print("this wouldn't be printed") enable_print() print("re: this will be printed on console") ```

Tips to help you write clean python scripts

dev.rubbie@gmail.com — Wed, 10 Jun 2020 00:00:00 GMT

## Avoid Overriding Built-in Functions Using Python's built-in names as variable names can override their default behavior, making them unavailable or causing errors. ```python # Bad id = 2 zip = 567890 class = "physics" # Keywords would throw a syntax error # Good user_id = 2 zip_code = 567890 class_ = "physics" ``` ## Follow Naming Conventions Use proper naming conventions for better readability. Camel case and snake case are the most common styles. ```python # Bad secondary_Title = "hello world" Name = "rubbie" # Use lowercase for variables # Good secondaryTitle = "hello world" # Camel case secondary_title = "hello world" # Snake case # Use PascalCase for classes class ProximitySensor: def read(self): """ 1. Use triple quotes for docstrings. 2. Explain the purpose of the function clearly. """ pass # Use UPPERCASE with underscores for constants PI = 3.141592 OPERATIONAL_EFFICIENCY = 0.67 ``` ## Use Spaces Instead of Tabs > I'm a tabs person btw Using tabs can cause inconsistent formatting across different editors. Use spaces instead (preferably 4 per indentation level) to ensure consistent readability. ## Simplify Boolean Expressions Avoid unnecessary conditional statements when assigning Boolean values. ```python # Poor boys, girls = 5, 19 if boys == girls: equal = True else: equal = False # Better boys, girls = 5, 19 equal = boys == girls ``` ## Use Ternary Operators for Simple Conditions ```python # Instead of this if is_active: x = 1 else: x = -1 # Do this x = 1 if is_active else -1 ``` ## Improve Readability of Large Numbers Use underscores to separate digits in large numbers for better readability. ```python connections_accepted = 1_000_000_000_000 connections_rejected = 1_000 connections_total = connections_accepted + connections_rejected ``` ## Manage Resources with Context Managers Manually opening and closing files is prone to errors. Use with statements to manage file resources efficiently. ```python # Bad file = open("text.txt") content = file.read() file.close() # Good with open("text.txt") as file: content = file.read() ``` ## Track Index While Looping Avoid manually tracking index variables when looping through lists. ```python # Bad items = ["apple", "pear", "papaya", "mango"] index = 0 for item in items: print(index, item) index += 1 # Good for index, item in enumerate(items): print(index, item) # Start from index 1 for index, item in enumerate(items, start=1): print(index, item) ``` ## Loop Through Multiple Lists with zip Instead of manually managing multiple lists, use zip(). ```python # Bad names = ["rubbie", "jerome", "carlie", "angie"] hobbies = ["painting", "surfing", "cycling", "singing"] index = 0 for name in names: print(f"{name} loves {hobbies[index]}") index += 1 # Good for name, hobby in zip(names, hobbies): print(f"{name} loves {hobby}") ``` ## Use Underscore for Unused Variables If a loop variable is unnecessary, replace it with an underscore (_). ```python # Bad for i in range(6): do_something() # Good for _ in range(6): do_something() ``` ## Use Annotations for Code Clarity Annotations help define function input and return types, making the code easier to understand. ```python # Without annotations def add(a, b): return a + b # With annotations def add(a: int, b: int) -> int: return a + b ``` Annotations are optional but improve code readability, especially in larger projects. These tips will help you write cleaner and more efficient Python scripts. There's always more to learn, but this is a great starting point!