Forem: Dylan Oh

API and SDK, What Are These Two Terms Actually?

Dylan Oh — Sun, 01 Jun 2025 15:59:42 +0000

If you are just starting to look into AI (or any software) development, you might hear terms like API, SDK, etc. One of my friends who just got into this hype of AI development asked me these questions, and he did not have any technical background: “What are APIs? What are the differences between API and SDK?” I thought it would also be nice to have a simple-to-understand explanation for you guys.

API (Application Programming Interface)

Let’s start with the API. To put it simply, API is how software talks to each other.

If this is too vague, consider it a clearly defined way one program can request services or information from another. Instead of a human clicking a button, one piece of software makes a structured call to another.

Many larger software platforms are providing API services to interact with their software. Let’s take X (formerly Twitter) as an example.

Their APIs are like a set of specific, clearly labeled “service windows” or “access doors,” often called “API endpoints.” Each door is designed for a particular task, e.g., one for posting a tweet, another for getting the followers count, and so on.

Imagine you are building an AI agent. When your bot wants to post a tweet, it goes to the “PostTweet()” door (this might not be the actual name, just an example) provided by the X API, and presents the tweet text in the required format. The API takes care of the rest, ensuring it gets posted correctly within X’s system. Your bot doesn’t need to know the complex inner workings of X; it just needs to learn how to use the designated API doors.

Your next question might be: I am a non-technical person who wants to learn about AI. Do I need to know all these things?

Well, yes.

Today’s most powerful AI capabilities are services that developers can tap into through APIs. Companies like OpenAI (GPT models), Google (Gemini), and Anthropic (Claude) provide APIs. This means developers can integrate sophisticated features like advanced text generation, image creation, or speech recognition directly into their applications without building these incredibly complex AI models from the ground up. APIs are making advanced AI accessible to a much broader range of builders.

SDK (Software Development Kit)

API provides the rules and access points for software communication. But sometimes, especially when you’re working with a complex service or a new platform, just having the list of “doors” (API endpoints) and the rules for knocking isn’t quite enough to get you building quickly and efficiently.

This is where an SDK, or Software Development Kit, becomes incredibly helpful in making a developer’s life easier when working with a particular platform or API.

A helpful analogy for this:

Imagine you’ve bought some flat-pack furniture (IKEA or anything). The API might be the design specifications — how the pieces should connect. The SDK, then, is the box that arrives containing:

Pre-drilled holes and essential components (these are like code libraries — pre-written chunks of code that handle everyday tasks, like formatting your API requests or managing authentication, so you don’t have to write them from scratch).
The tools needed for assembly (like helper utilities or specific compilers).
Clear, step-by-step instructions and diagrams (this is the documentation, code samples, and tutorials that guide you through the process). An SDK bundles these libraries, tools, documentation, and code samples to help developers build applications for a specific platform (like the Android SDK for building Android apps) or integrate a particular service (like using an AI provider’s SDK) much more smoothly.

Suppose the API is the blueprint for the conversation. In that case, the SDK provides ready-made phrases, connectors, and helpful tools in your preferred programming language (like Python, Java, or JavaScript) to make that conversation happen with less friction. It helps you get up and running faster.

How do we call an API?

If we were to interact with an AI model’s API directly without an SDK, we would construct an HTTP (Hypertext Transfer Protocol) request. This involves specifying the endpoint URL, setting headers (for authentication with an API key and content type), and sending a JSON payload with our request details.

Conceptually, using a command-line tool like curl (which sends HTTP requests), it might look something like this:

curl -X POST https://api.ai-provider.com/v1/completions \
     -H "Authorization: Bearer YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
           "model": "the-ai-model-name",
           "prompt": "If I have a next life, I would want to become a...",
           "max_tokens": 50
         }'

You don’t have to understand what a “curl” is, but it is a tool or interface that we use to send an HTTP request. We are “calling” the API of this AI provider’s services, with the endpoint of “completions.” APIs of these services are generally provided in the form of a URL. In this example, there would be a base URL: ”https://api.ai-provider.com”, and the endpoint is “completions”.

This is a high-level idea of calling an API (there are more concepts about different HTTP request methods, such as the “POST” you see in the example, but we shall save that for later).

How do we use an SDK?

Many AI providers offer SDKs in various programming languages. Let’s imagine we’re using Python with an SDK from an AI provider, similar to how you would use OpenAI’s or Google’s SDK.

from ai_provider_sdk import AIClient

# this is to initialize the client (often handles API key automatically if configured)
client = AIClient()
try:
    response = client.completions.create(
        model="the-ai-model-name",
        prompt="If I have a next life, I would want to become a...",
        max_tokens=50
    )
    # the exact way to access the text will vary by SDK
    print(response.choices[0].text.strip()) 
except Exception as e:
    print(f"An error occurred: {e}")

`
For example, the AI provider mentions that they provide a Python SDK for their services. In that case, you could just import the AI provider SDK and use their services. For example, we can initialise the SDK client and use the SDK function (the “client.completions.create()”) to call the services without knowing the underlying API.

You can focus more on what you want the AI to do, rather than the nitty-gritty of how to make the web request. This is why developers love SDKs when they are available, they speed up development and reduce the chance of errors in the communication layer.

Here’s another handy benefit: SDKs can often act as a buffer if the API provider makes behind-the-scenes changes to their API. If the provider, for instance, updates an internal address or tweaks a minor detail, the SDK maintainers will typically update the SDK to adapt. For you, this often means you can update to the newer version of the SDK, and your code that uses the SDK’s functions might not need to change at all, or only require minimal adjustments. This makes maintaining your application easier over time. Of course, for extensive, fundamental changes to an API (which are less common), the SDK itself might have major updates requiring more code changes on your end. However, it is generally a smoother process than deciphering raw API changes yourself.

I hope this article simplifies these two glossaries and ensures you don’t get intimidated by them going forward in learning AI application development!

If you find this insightful, subscribe to this newsletter for more articles like this.

https://dylanoh.substack.com/

Why Your Results‑Driven Goal System Is Sabotaging Your Progress (And How to Finally Finish What You Start)

Dylan Oh — Sat, 19 Apr 2025 08:10:06 +0000

I used to pride myself on setting “results‑oriented” goals: hit a revenue target, grow my LinkedIn to 2000 followers, master a new skill in 30 days.

But every Saturday morning, I would stare at my to‑do list—draft outlines, plan campaigns, code features—and feel my motivation drain away. My brain whispered, “Why not just chill a bit?” And before I knew it, I was scrolling social media instead of moving forward. I wondered,

_Is this as good as it gets?

Am I doomed to feel stuck?_

I thought it was just me.

After diving into habit and productivity science (and books), I realized our brains are wired to protect us, to resist anything that feels uncomfortable or new.

Over the past few months, I have experimented with a handful of simple, research‑backed strategies. They aren’t about sheer willpower or marathon work sessions, but tiny actions that trigger momentum.

Here’s exactly how I turned my weekends from “list paralysis” into “finished first drafts”:

1. Light the Fuse with a Mini Commitment

Do just a sliver of tomorrow’s work today.

For example, if I know I must complete some presentation slides the next day, I will open a blank slide deck and jot down three slide titles the night before. That five‑minute “pre‑action” carves a channel in my brain: I’m not facing an empty deck when I sit down—I’m resuming progress.

Getting started is half the battle. By lowering the activation energy, you bypass the part of your brain that screams “too hard” and give yourself a running start.

2. Bust Inertia with the 10‑Second Kick‑Start

Pick a task you can complete in ten seconds—so small it’s impossible to talk yourself out of it.

On Sunday mornings, before my coffee even cools, I open a fresh doc and type a word: “Go.” That tiny hit of progress floods my system with dopamine, and I’ll often keep writing long after the buzzer stops.

Look, your brain hates uncertainty.

A guaranteed win—even as trivial as opening a file—short‑circuits the resistance and primes you for the next step.

3. Harness Focus with 15‑Minute Sprints

Break your work into short, intense bursts.

When I’m buried under emails or research, I set a fifteen-minute timer and attack one thread or section—no distractions allowed. When the timer pings, I take a mini‑break: stretch, refill my water glass, or glance out the window. Then I dive into the next sprint.

Parkinson’s Law tells us that work expands to fill the time available. A tight deadline creates urgency, and those little victories add up faster than marathon sessions ever could.

You don’t have to set 15 minutes like me (it might be too short for you), but you would be amazed by how much you could do with laser focus in such a short time.

4. Anchor Your Expectations for Effortless Progress

Use the first number you think of (your “anchor”) to make more realistic goals seem easy to achieve.

Instead of telling myself, “Write 200 words,” I start by mentally anchoring “1,000 words.” Then, I scale back to 200. Compared to 1,000, 200 feels like a breeze—yet I often overshoot anyway.

Our brains latch onto the anchor and judge everything relative to it. A daunting anchor makes the target seem trivial, so you breeze past it.

5. Turn Reflection into Forward Motion with a Weekly Review

Build a simple feedback loop—review what worked, what didn’t, and plan micro‑steps to improve.

Each Sunday evening:

List what I set out to do.
Check off what I did.
Analyze the roadblocks behind each miss.
Plan one tiny next action for each obstacle.

For example, if I skipped “outline blog post,” I note “got stuck finding data,” then schedule a five-minute Google search first thing Monday morning.

Reflection without action is just rumination. By pairing insights with micro‑commitments, you close the loop on procrastination and kickstart progress for the week ahead.

Procrastination isn’t a personal failure—it’s a habit shaped by how our brains protect us. But with the right micro‑actions, you can hack that system and turn every challenge into a series of small, easy wins. Try these five strategies this weekend: light the fuse, kick‑start the engine, sprint in short bursts, anchor your goals, and review smartly.

Before you know it, you’ll look back at a completed list and wonder why you thought starting was the hardest part. Let me know how you feel after implementing!

Subscribe to my substack newsletter (in the profile) for the weekly insights I share about what I learned, including emerging technologies, productivity, and anything that triggered my curiosity.

Cheers.

Software Engineering Is Here To Stay In The Age of AI

Dylan Oh — Tue, 01 Apr 2025 09:01:22 +0000

I remember the first time I asked an AI to help debug my code. It was a chill afternoon, and instead of Google, I typed a question into ChatGPT. In seconds, it pinpointed the bug and suggested a fix. I felt amazed — and a tiny jolt of fear.

If an AI could solve my problem that quickly, what did that mean for me as a software engineer?

Many developers are feeling this mix of excitement and anxiety. With AI tools writing code, answering questions, and even building entire apps from a prompt, it’s natural to wonder: Will AI replace software engineers?

I am giving you the reassuring answer, from experts and everyday coding experience — no. Our profession is not vanishing; it’s evolving. AI is changing our daily work and skills, but it’s more like getting a supercharged assistant than facing a takeover. In this article, we’ll explore how AI reshapes software development, the future of coding, and how engineers can adapt and thrive in this new era.

AI Tools in the Developer’s Daily Life

Walk into any software company today, and you will most likely find AI-powered tools in the coding toolbox. From GitHub Copilot auto-completing lines of code, ChatGPT answering programming questions, Replit’s Ghostwriter writing and explaining code in the browser, these helpers are becoming as common as version control. Rather than eliminating the programmer, they’re taking over the repetitive grunt work and giving us more time for the interesting stuff.

For example, AI pair programmers like Copilot can suggest the next few lines of code as you type, sometimes even generating entire functions on the fly. One study found that developers using GitHub Copilot could complete tasks up to 55% faster, and 85% felt more confident in their code quality with the AI’s help. Another survey of 730 developers reported that most programmers see AI as a helpful collaborator that handles routine tasks, freeing them to focus on more complex, creative work. In practice, that means the AI might write the boilerplate or unit tests, while you design the system or tackle a tricky algorithm.

AI chatbots like ChatGPT have quickly become the new Stack Overflow for many of us. Instead of combing through pages of search results, developers can ask an AI a question and often get a direct, useful answer. It’s telling that the volume of new questions on Stack Overflow has plunged by over 75% from its peak since tools like ChatGPT became available. The workflow is changing: we consult the AI assistant for quick answers and code snippets, and then we (humans) double-check and integrate that solution into the bigger picture. AI might catch a syntax error or suggest an API call, but we are the ones to decide if it fits our application’s architecture and requirements.

Even low-code and no-code platforms are riding the AI wave. Take Replit, for instance — a popular online coding environment. Replit’s new AI Agent can turn a natural language prompt into a working web app. You can say, “Build me a simple to-do list app,” and watch as the AI generates the code for you in the editor. It’s “like having an entire team of software engineers on demand, ready to build what you need — all through a simple chat,” according to Replit’s announcement. This doesn’t make developers obsolete; it lowers the barrier for basic projects and prototypes. Professional engineers are freed up to work on the harder problems or refine and productionize these AI-generated prototypes.

Importantly, AI tools are not infallible. They sometimes write sloppy code or even make things up (we have all seen ChatGPT confidently spout nonsense if it’s unsure about an answer). So while these tools can generate code, they can’t guarantee it works in your unique context. That’s where we, the developers, come in — reviewing AI contributions, testing and debugging, and providing the insight and context an AI lacks. In other words, AI is becoming a powerful extension of the developer’s toolkit, automating the tedious parts of coding so we can focus on the more intellectually demanding parts.

AI as a Coding Partner, Not a Replacement

Whenever a new automation technology emerges, there’s a familiar fear: “Will this replace me?” But in the case of AI and programmers, think of it less as a replacement and more as an augmentation. AI is like a junior developer who works at superhuman speed — but still needs supervision. It takes direction well and can churn out a draft, but it relies on a senior dev (that’s you) to review, correct, and guide it.

Someone wisely said, “AI won’t replace developers, but another developer using AI will.” (I can’t find the original because too many people said this.) In other words, developers who embrace AI will outpace those who don’t. This has rung true in practice: teams that leverage AI coding assistants ship features faster and with fewer errors, whereas those sticking purely to manual methods might fall behind. The software engineer’s role is shifting from the one who writes every line of code to the one who orchestrates and validates AI-generated code.

We become the director, with AI as our eager assistant.

It’s also useful to remember the limitations of these AIs. They don’t truly understand the why behind your project — your users, business needs, the creative leap needed to solve a novel problem. A senior developer on your team brings years of intuition and creative problem-solving ability that an AI can’t match. AI can crunch data and patterns from millions of lines of code and suggest something that looks plausible. But figuring out if that suggestion is innovative or suitable is a human skill. An AI might suggest a solution that technically works but isn’t optimal for your customers or might introduce subtle bugs. We’ve seen cases where AI-generated answers look perfect at first glance but are incorrect upon careful inspection. This is why critical thinking and oversight from human engineers remain indispensable.

Leading voices in the industry echo this balanced view. Janel Garvin, CEO of Evans Data Corp, put it succinctly:

“AI will not replace programmers but will fundamentally change the development landscape, making human creativity and problem-solving essential.”

So, rather than fearing replacement, it’s better to see AI as a catalyst for change — one that elevates the importance of our uniquely human skills. Creativity, problem decomposition, judgment, and domain expertise become even more important when routine coding is handled by AI.

Many companies now explicitly position AI as a “co-pilot” (to borrow GitHub’s term) rather than an autopilot. AI helps write the code, but a human pilot is still in control. Microsoft’s developers reported feeling more fulfilled and enjoying coding when using AI assistance because it takes away some drudgery and lets them focus on interesting problems. Coding isn’t becoming a push-button job; it’s becoming a dialogue between developer and AI.

The Evolving Role of the Software Engineer
So if we’re no longer spending all day writing boilerplate code, what will software engineers do in the future?

The job is already evolving into something even more engaging. Imagine that instead of grinding out every CRUD function, you’re designing the system architecture, defining high-level logic, and letting AI fill the lower-level gaps. You might spend more time thinking about product requirements, user experience, and how to break a problem down, then hand off some of those sub-tasks to an AI agent to implement under your guidance.

In essence, we will become more like architects, product thinkers, and orchestra conductors in our projects.

One likely shift is that software engineers will focus on system design and integration. AI can help write code, but someone needs to decide what code should be written and how different pieces of an app should fit together. Engineers will put more effort into defining the right modules, interfaces, and data flows — the tasks that require understanding the broader context. We’ll also take on roles akin to quality control and coaching. Just as a senior dev today might review a junior dev’s code and offer feedback, tomorrow’s dev might review AI-generated code and correct its mistakes or refine its style.

We’re even seeing new hybrid roles emerge. A buzzword you might have heard is “prompt engineer.” This refers to someone who specializes in crafting the right prompts (inputs) to get the most useful output from an AI. It sounds a bit futuristic, but it’s a skill many developers are already informally learning: figuring out how to ask things from ChatGPT or Copilot to get the best results. The demand for such skills has grown so much that companies like Anthropic have job listings for prompt engineers with salaries reaching six figures. The rise of generative AI has created a hot market for prompt engineers — jobs that sometimes pay up to $300k–$375k a year (in 2023, though). Essentially, being good at guiding AI has monetary value! Even if “prompt engineer” doesn’t remain a long-term job title, it signals that knowing how to work effectively with AI is becoming a core part of software development.

Another area where developers may spend more time is training and refining AI models (for those inclined towards machine learning). As AI-generated code becomes common, understanding how these models work — their strengths, weaknesses, and failure modes — can be hugely beneficial.

Some forward-looking developers talk about “Software 2.0,” a term popularized by Andrej Karpathy. This term refers to a paradigm in which, instead of writing detailed algorithms, engineers mostly gather data and train neural networks to solve problems. In this view, tomorrow’s programmer might curate datasets and tune AI models as often as writing traditional code. That’s a specialized path, but it shows how some engineers will morph into AI trainers and curators, operating at a higher level of abstraction.

And let’s not forget the soft skills. The further we go from writing boilerplates, the more our communication and collaboration skills will emerge. Engineers will be interfacing even more with product managers, designers, and stakeholders to decide what needs to be built, because figuring out the right problem to solve is something AI cannot do for us. Understanding user needs, brainstorming creative solutions, and then translating that into AI instructions or an architectural plan requires empathy, teamwork, and leadership. Software developers will become more well-rounded technologists, blending technical knowledge with strategic and creative thinking.

Adapting and Thriving with AI: Tips for Engineers

The changes in our field don’t mean you must toss out all your hard-earned skills and start over.

It means adapting and upskilling in smart ways.

Here are some actionable ways to future-proof your software engineering career in the age of AI:

Embrace AI Tools in Your Workflow: Don’t shy away from tools like GitHub Copilot, Replit’s Ghostwriter, or whatever your team uses (please). Get familiar with them. Treat them as your coding sidekick. The more you practice using AI helpers, the better you’ll get at prompting and catching their mistakes. Remember, developers who leverage AI will have an edge, so it’s wise to be among them.
Focus on System Design and Big-Picture Thinking: Since AI can handle the small stuff, double down on your ability to design robust systems. Practice designing architectures, choosing frameworks, and considering scale, security, and user experience. Your expertise will shine in these areas when AI-generated components need to come together seamlessly.
Hone Your Problem-Solving and Creativity: Work on projects that require solving novel problems or finding clever solutions. This could mean contributing to open source, participating in hackathons, or tackling different domains. The goal is to strengthen the muscles that think outside the box because AI, which learns from existing code, often can’t handle entirely new approaches or truly creative solutions.
Learn to Review and Maintain AI-Generated Code: Code review is a critical skill in AI. When an AI writes some code for you, don’t take it at face value — read through it and understand it. You might discover a bug or an inefficiency that the AI didn’t catch. Develop a habit of writing tests and using debugging tools to validate code written by you or an AI. Being the quality gate is a valuable role.
Improve Your “AI Literacy”: Not every developer needs to be a machine learning expert, but understanding how AI models work will help you use them better. Spend a weekend learning about how GPT or code transformers work at a high level. Know their limits (e.g., they can’t access new knowledge not in their training data, they can produce wrong answers that sound right). This knowledge will help you troubleshoot when an AI assistant is giving weird outputs, and it will let you explain AI-driven decisions to non-engineers on your team.
Develop Soft Skills and Domain Knowledge: The human elements — communicating, leading a team, understanding the customer — are becoming even more important. You might find yourself explaining an AI’s output to a manager or client, or working with a non-technical team that wants a feature built. Being able to speak their language and collaborate is key. Also, deepen your understanding of your domain (be it finance, healthcare, gaming, etc.). The more context you have, the better you can guide AI tools to build the right thing. AI is clueless without context — you provide that missing piece.
Adopt a Lifelong Learning Mindset: Stay curious and keep learning. The tech world changes fast, and AI is turbo-charging that. The good news is that the same AI tools can help you learn faster (ever used ChatGPT to explain a new framework to you?). In 5 or 10 years, the hottest tools and best practices might be things we can’t imagine now. The engineers who thrive will remain flexible and enthusiastic about picking up new skills throughout their careers. Focusing on these areas will ensure that you drive the AI tools, not the other way around.

Coding Careers Are Here to Stay (and Get Better)

The rise of AI in software development is not the end of coding careers — it’s the beginning of a new chapter. If you’re an aspiring developer, rest assured: there’s plenty of demand for human programmers, but the job might look different from a decade ago. If you’re a seasoned engineer, you’ve probably seen the industry change repeatedly; this is just another evolution that can make your work more interesting and impactful if you adapt to it.

Every upheaval in technology (from the invention of high-level languages to the advent of the internet to the proliferation of frameworks) has sparked fears of job loss. Yet, each time, software development has expanded and thrived. AI is the latest tool to automate parts of our job and open new opportunities. It can write code but still needs direction, creativity, and critical oversight — all things at which we excel. As AI takes over the rote tasks, developers get to focus on more rewarding aspects of building software. In the future, you might spend less time debugging null pointer exceptions and more time brainstorming features, refining user experiences, and solving high-level design puzzles with the help of an AI partner.

The profession is maturing into something even more creative and empowered. Just as using calculators didn’t eliminate the need for mathematicians, using AI to assist coding doesn’t eliminate the need for developers — it elevates it. The companies that understand this are investing in their engineers, not replacing them. Developers at Google, for instance, are already using AI to generate about a quarter of their new code. Yet, Google is hiring developers, not firing them — because someone has to define that other 75% and ensure the whole product makes sense. Across the industry, early evidence shows productivity is going up, not down, when AI is in the mix (Salesforce even reported a 30% productivity boost from AI automation).

In the end, coding as a career is not going away. Instead, it’s becoming more about strategy, creativity, and human insight. So the next time you see an AI solve a problem in seconds that took you hours, don’t panic. Take it as a preview of how much more efficient and exciting your work could become. By welcoming our new AI companions and leveling up alongside them, software engineers can ensure that we remain relevant and central in shaping the future of technology. After all, behind every great AI, there’s a great human engineer who taught it, guided it, and knew where to point it — and that’s a role only we can play.

Learning to Code Has Changed My Life, Forever.

Dylan Oh — Mon, 31 Mar 2025 08:51:56 +0000

Life has a way of taking you on unexpected detours, doesn’t it?

A few years ago, I was a restless soul—full of ambition but without clear direction.

I bounced from job to job, chasing a spark I couldn’t define. I tried it all in sales, marketing, interior design, and even as a management trainee at HaiDiLao (a famous Chinese Hotpot chain, in case you haven’t heard of it). Each role was a stepping stone, but none felt like home. My wallet stayed thin, my confidence wavered, and yet, deep down, I knew there was something out there I would love doing if I could find it.

Then came a New Year’s Eve countdown party that flipped my world upside down. A chance conversation with an old friend introduced me to coding—a field I’d never considered (I would blame my high school’s computer class teacher for that)—and set me on a path of relentless self-study, late-night debugging, and, ultimately, a career that quadrupled my salary and gave me a sense of purpose I had been craving. This is my story: a messy, inspiring journey from being lost to finding my calling as a software engineer and why coding remains a game-changer, even with AI on the rise.

Buckle up—it’s long, but I promise it's worth the ride.

Ambitious, Lost, and Trying Everything

We all had that self-centric moment when we thought we were the world's center. Growing up, I imagined myself doing something big—something that mattered.

But as I stepped into the working world, that vision blurred. I didn’t have a clear path, so I threw myself into whatever came my way, hoping to stumble into my passion.

First up was a marketing job introduced by my sister. I pictured myself as the smooth-talking closer, sealing deals over coffee. The reality? I was the first marketing guy they had hired. I had my biotechnology degree but didn’t know how to do marketing or sales.

Then came interior design, a curveball even for me. Although it was more like a sales job than designing the house (I had to sell renovation packages to the house owners), both were challenging. I learned much through the job, including more about humanity, communication skills, stress tolerance, etc. It was a great learning experience, but nah, that’s not something I want to do in the long run.

So, I changed again.

I decided not to go through all, but here is the list of jobs that I have tried before my software engineering career, in historical order:

Sales and Marketing Executive

Sales Designer

Management Trainee in HaiDiLao

Sales Rep in a Medical Company

Application Sales Executive

After multiple job switches, I was burned out. Each job left me with scraps of experience—communication, teamwork, grit—but no real progress. My salary hovered at entry level because I kept resetting the clock. Friends were buying cars and planning vacations while I was still scraping by, wondering why I couldn’t find my fit. It wasn’t just about money, though. I wanted to wake up excited, not dreading the day ahead. I was ambitious, yes, but I was also really lost.

Hitting Pause and the Self-Reflection

Jumping from job to job wasn’t working—it was like throwing darts blindfolded and hoping for a bullseye. I needed a new approach. So, I stopped chasing the next thing for the first time and started looking inward.

I grabbed a notebook and got honest with myself.

**_What did I enjoy about those jobs?

What drove me up the wall?_**

I scribbled furiously, dissecting every role. I picked which part of those works that I loved and which I hated the most.

Patterns emerged. I thrived when I could create, solve puzzles, and use my brain hands-on. I also wanted a career with room to grow—something that wouldn’t cap out after a few years.

Technology kept popping into my head. I’d always been fascinated by apps and websites—how did they work?—but I’d never considered it a viable path.

I wasn’t a “tech person,” or so I thought.

One night, I sat on my couch, staring at my notes. “What if there’s something out there that combines all this?” I wondered. “Something challenging, creative, and future-proof?” I didn’t have the answer yet, but I felt a shift.

I was done drifting—I was ready to dig deeper.

The Countdown Party That Counted

Enter New Year’s Eve in 2018, the night that changed everything. A friend invited me to her countdown party, and I almost bailed. I was in a funk, questioning my life choices, and the idea of plastering on a smile felt daunting. But I dragged myself out the door, figuring a change of scenery might shake me loose.

The house was buzzing—music thumping, people laughing, a table piled with snacks. I grabbed a drink and started mingling, half-listening to small talk. Then I spotted a high school buddy I hadn’t seen in ages.

“So, what do you do now?” I asked.

“I’m a software engineer at IBM,” he said.

I blinked. “Wait, you went into computer science? That’s awesome.”

He laughed. “Nah, man. I studied something else. Coding came later—I taught myself.”

I nearly dropped my drink. “Hold up. You didn’t go to school for this? You just… learned it?”

“Yeah,” he said, shrugging like it was no big deal. “It took time, but there’s so much out there—tutorials, courses, forums.”

My brain was racing. “So anyone can do this? Like, become a real software engineer without a degree?”

“If you’re willing to do the work, sure,” he said. “It’s not easy, but it’s doable.”

The countdown started—“Ten, nine, eight…”—and as everyone cheered, I stood there, dazed. Fireworks popped outside, but the real explosion was in my head. I’d always pictured coders as math geniuses with fancy degrees, not regular guys like him—or me. But if he could do it, why couldn’t I?

“Happy New Year!” the room shouted. For me, it wasn’t just a new year—it was a new beginning.

The Grind of Determination: From Novice to Ninja

On January 1st, I woke up with a fire in my belly. I didn’t know much about coding, but I knew I wanted in. I hopped on Udemy and bought a web development course for beginners for $14.90 (discounted from $199.90; as you know, Udemy is on sale for 350 days a year). In that first lesson, I wrote my first line of code. It was basic, but seeing it work felt like magic. I was hooked.

After tackling the web developer boot camp (I spent a month completing that and faced countless issues), I moved on to picking up the React frontend framework (okay, library) and finally saw myself building some real stuff.

I then studied Git, databases, UNIX commands, and some basic networking concepts.

The schedule was brutal. I’d work my day job, come home, and code from 8 p.m. to midnight. Weekends? All coding, all the time—10 a.m. to 2 a.m., fueled by coffee and determination.

My social life shrank, but I didn’t care. This felt different. It was hard, sure, but it was my hard—progress I could measure in every line I wrote.

Challenges piled up. I’d spend hours on a bug—a missing colon, a dumb typo—cursing my screen until I fixed it. Those victories, though? Pure adrenaline. I remember my first real project: a web app that pulled all the campsites by region with search functionality. If you have taken the web development bootcamp from Colt Steele, you will know what I mean. Highly recommended course.

Five months in, I had a portfolio—small apps and a GitHub page. I applied to a couple of jobs, succeeded with my first on-site interview—and got the offer right after the interview. Shoutout to Justin, still a friend that I hang out with now, who taught me a lot and gave me the opportunity to start my software engineering journey.

The Transformation: A New Life in Full Color

Fast-forward to the present. My current salary is four times what I made before entering software engineering.

Four. Times.

Money stress faded, replaced by a strange new feeling: security.

But the real magic wasn’t the cash—it was the work. Coding clicked with me in a way nothing else had. I’d debug a tricky issue or ship a feature and feel satisfied. The job stretched my brain daily. I was learning, growing, and loving every minute (almost).

Coding didn’t just change my bank account; it rewrote my story.

The Big Question: Is Coding Still Worth It with AI?

Now, let’s talk about the elephant in the room: AI. Tools like ChatGPT can write code, fix bugs, and even design apps. I wrote an article about “Lovable,” an AI agent that helps you build an app with just prompt input.

Exploring How Lovable Can Empower Product Builders

So why bother learning to code? Is it a dying skill?

Not a chance. AI is a tool, but not here to takeover.

The future? Coders who embrace AI will thrive, blending tech smarts with human insight. The basics—algorithms, data flow, problem-solving—will stay golden.

I’ve got more to say about how software engineering is evolving, not vanishing, so watch for my next article. I will first drop my conclusion here:

There will be more software engineering jobs in the future, but they will look different from the current ones.

Reflections and a Nudge

Looking back, I see every stumble as a setup. The dead-end jobs, the sleepless nights, the countdown party—they weren’t random. Life was nudging me toward coding, even when I couldn’t see it. I’m grateful for the mess—it made the triumph sweeter.

Who knows, I might be bored by the software engineering career in the next few years. But I am not worrying at all. I am still exploring myself and discovering how I evolve along my journey.

If you’re stuck, lost, or itching for more, hear me: your path’s out there. Maybe it’s coding or something else, but don’t stop looking. Reflect. Experiment. Push through the hard parts. You will be rewarded handsomely.

Cheers.

Want to start learning LLM and Generative AI? Start with Ollama and this article.

Dylan Oh — Sun, 22 Dec 2024 05:39:23 +0000

Generative AI and Large Language Models (LLMs) are the buzzwords redefining how we create, automate, and interact with technology. From chatbots that sound almost human to tools that can generate lines of code or full-fledged content in seconds, the potential is limitless.

However, getting started with LLMs can feel overwhelming. The complexity of models, infrastructure, and jargon can make even seasoned developers pause. You must have asked, "Where should I start?”.

That’s where Ollama comes in. If you’re a developer who wants to experiment with Generative AI without getting lost in the setup maze or spending a fortune on cloud services, Ollama is the perfect starting point. It’s simple, powerful, and respects your time and privacy.

What is Ollama?

Ollama allows you to run and manage large language models locally. Yes, locally. That means no cloud dependency, no massive data transfers, and no recurring bills for cloud computing power.

Choose Your Language Model: Whether you want to explore conversational AI, code generation, or content creation, Ollama lets you pick from various models. No need to jump between platforms; everything you need is here.

Fast and Cost-Effective: Run models directly on your computer without relying on cloud services. That means no extra expenses for computing power and faster response times — perfect for beginners experimenting on a budget.
Start Small, Learn Big: Ollama is built for all skill levels. Whether you’re just starting with AI or looking to expand your toolkit, the platform provides an easy entry point into LLMs with a clear path to more advanced capabilities. The installation is an easy-breezy process. You may check out the quick installation guide here in the next section.
Hands-On Experimentation: Experiment locally without worrying about setting up complicated infrastructure. Download a model, start playing, and learn as you go — no need for a big upfront commitment.

How to install Ollama and get started?

Here’s how you can setup Ollama locally and start running the language models:

Head over to Ollama to download the installer for your OS.

After that is installed locally, bring up a terminal and run the following:

ollama run llama3.2

… or any model of your choice.

You are expected to see it downloading the models (if that’s your first time running the model), and once it is done, you will see a prompt:

You are set to go! You can experiment with various models (but please take note that the model images are pretty large).

That’s it for today’s article! If you are planning to get started with your Gen AI / LLM journey, do follow me on Medium (it’s been some time since I last posted, but I will dedicate myself to posting every week again with very useful technical blogs on AI).
Cheers!

What You Need to Know To Get Started with Blockchain

Dylan Oh — Sun, 08 Dec 2024 10:07:28 +0000

Blockchain is a term that can sound a little intimidating. Maybe you’ve seen it flying around in headlines or heard people linking it to Bitcoin (especially in Bitcoin bull run). Or perhaps this is the first time you heard it and thought, “Wait, isn’t blockchain just another name for Bitcoin?” (I know, that’s what my friend asked me exactly).

In this article, I’m going to explain what blockchain is in extremely simple terms—no jargon, no technical lingo. By the end, you’ll have a clear idea of what blockchain is, how it works, and why people won’t stop talking about it.

So, What is Blockchain Exactly?

Here’s the analogy:

Imagine you have a notebook that records every transaction you make—like buying a coffee or sending money to a friend. Now imagine that notebook isn’t just yours; it’s shared with thousands of people, and every time a new transaction happens, everyone updates their notebooks at the same time. That’s the basic idea of blockchain.

But here’s what makes it special:

No one owns the notebook—it’s shared by everyone (decentralization).

Once something is written in it, you can’t erase or change it (Immutability).

Everyone can see what’s written, so there’s no hiding (transparency).

This “notebook” is what we call a blockchain: a digital, shared ledger that keeps track of everything securely and transparently.

Why Is It Called Blockchain? What’s Inside a Block?
It’s a chain of “blocks” of information linked together. Each block acts like a digital container that holds specific, important data.

1) A list of transactions:

At its core, a block contains a list of transactions. This is the main purpose of the block: to record activities on the network. For example:

If someone sends cryptocurrency, the transaction details are stored here.

Some blockchains might include smart contract (we shall talk about this in the future) data or even supply chain records.

Each transaction includes:

The sender’s address (who is making the transfer).
The recipient’s address (who is receiving it).
The amount or details of what’s being exchanged.
A timestamp showing when the transaction occurred.

This makes the block a clear record of activities, like a digital ledger page.

2) A Unique Identifier (The Hash)

Every block is given a unique “fingerprint” called a hash. This is a unique string of characters generated by running the block’s contents through a cryptographic function.

Why does this matter? The hash ensures the block’s contents cannot be changed. Even the smallest alteration in the block—like editing a transaction—would completely change the hash, making tampering obvious.

Think of it like a seal of authenticity: once stamped, the block’s hash proves it hasn’t been altered.

3) A Link to the Previous Block

Each block also includes the hash of the previous block (so that it knows which is the previous block before it). This creates a chain of blocks, where every block depends on the one before it. This linking is what makes the blockchain secure and tamper-proof.

How it works: If someone tried to change a past block, the hash of that block would change. But because every block depends on the hash of the one before it, the entire chain would break, and the network would immediately detect the tampering.

4) Metadata (other information)

In addition to transactions and hashes, a block often includes some extra technical details to help the network function:

Timestamp: The exact time the block was created.
Block Number: Its position in the chain (e.g., Block 101).
Nonce (in certain blockchains): A number used to help create the block’s hash during the validation process.
Validator Information: Details about who verified and added the block (if applicable). We shall dive deeper into validation and mining in the future.

That’s all you need to know to get started with blockchain! Remember these: decentralization, immutability, and transparency. Connect these characteristics with the structure of a blockchain above, you will have a clearer picture of what a blockchain looks like.

Understanding Python’s Global Interpreter Lock (GIL) Mechanism: Benefits and Limitations

Dylan Oh — Sun, 13 Aug 2023 01:07:46 +0000

Global Interpreter Lock (GIL) is a critical component of implementing Python. It plays an important role in the way Python manages concurrent execution, protecting shared resources from potential race conditions. In this article, we will dive into how the GIL works, why it exists, its benefits, and the limitations it imposes on multi-threaded Python programs.

Why does GIL even exist?

The primary reason for the GIL’s existence is CPython’s memory management (CPython is the interpreter and compiler of Python) and its internal data structures. The GIL ensures that only one thread executes Python bytecode (central) at a time, preventing concurrent access to these data structures, which could result in inconsistent states and memory corruption. Without the GIL, developers would have to manage the complexities of fine-grained locking manually, making Python code more prone to subtle concurrency bugs.

The GIL allows Python to use a simple and efficient memory management system. Reference counting, which is the primary memory management strategy, becomes straightforward with the GIL since objects cannot be accessed concurrently.

Besides, the GIL also helps simplify the development of CPython extensions by providing a stable execution environment for C code. Extension developers don’t need to worry about managing the GIL explicitly since Python will release it when executing C extensions.

GIL ensures compatibility with several C libraries that are not designed to be thread-safe. Without the GIL, interacting with these libraries from Python threads could lead to unexpected behavior.

However, there are reasons that people are always complaining that Python is not performing well.

Due to the GIL’s global lock, Python threads cannot take full advantage of multi-core processors for CPU-bound tasks. Only one thread can execute Python bytecode at a time, which limits the potential performance improvements from multiple cores.

Developers often resort to using multiple processes instead of threads in order to overcome this limitation. The multiprocessing module (you can check the Python docs here) allows developers to take advantage of multiple CPU cores by using different Python processes.

Python’s GIL is less restrictive for I/O-bound tasks (where threads may spend considerable time waiting for external resources), such as network requests or file I/O. In such scenarios, the GIL is less likely to be a bottleneck. GIL will get released when I/O is happening, meaning that the threads can do parallel tasks (however processing is another story).

Let’s consider a simple example that demonstrates the GIL’s behavior:

import threading

def count_up(name, n):
    for i in range(n):
        print(f"{name}: {i}")

if __name__ == "__main__":
    # Create two threads
    thread1 = threading.Thread(target=count_up, args=("Thread 1", 5))
    thread2 = threading.Thread(target=count_up, args=("Thread 2", 5))

    # Start the threads
    thread1.start()
    thread2.start()

    # Wait for both threads to finish
    thread1.join()
    thread2.join()

    print("Execution Completed")

In this example, two threads, t1 and t2, run the count_upfunction concurrently. However, due to the GIL, the output will be like this.

Thread 1: 0
Thread 1: 1
Thread 1: 2
Thread 1: 3
Thread 1: 4
Thread 2: 0
Thread 2: 1
Thread 2: 2
Thread 2: 3
Thread 2: 4
Execution Completed

The GIL prevents truly parallel execution, and the threads may be executed alternately rather than simultaneously.

In conclusion, GIL is an essential part of CPython’s design, providing simplicity and safety for memory management. While the GIL limits CPU-bound parallelism, it still allows for effective concurrency in I/O-bound scenarios. Understanding the GIL’s behavior is crucial for writing efficient and responsive multi-threaded Python programs. Developers can also consider using multiple processes through the multiprocessing module to harness the full power of multi-core processors.

Do follow me if you would like to learn more about my future articles that involve different technologies (I am working on articles for AR/VR development too!). Cheers!

Generating a New IDEA

Dylan Oh — Sun, 30 Oct 2022 13:42:31 +0000

Ideas do not fall from the sky.

We have been telling ourselves that we would definitely start working on something if the opportunity comes. However, many studies have proven that luck doesn’t strike people for no reason. For example, optimists generally have better “luck” as compared to pessimists. There was also another experiment where a $50 dollar note was placed on the floor and picked up by a lady who was not paying attention to her phone while walking after 20 minutes. Coincidence? I don't think so.

Sames goes to any type of “ideas”. We have to do something to get this inspiration, instead of sitting on the sofa and waiting for them to knock on our doors. So what can we do to find these ideas?

From people around you

Talk to the people that you want to help solve their problems. For example, I want to serve freelancers as my target audience (as I am a firm believer in the gig economy dominance in the future), therefore I talk to my freelancer friends to understand what kind of pains are they facing throughout their businesses.

On the forum

I like to browse the forums where my target audience gathers, such as Reddit (with specific subreddit), Facebook groups, and discord channels. I read through their chats and the problems that they have been complaining about. This is a good alternative if you do not have the audience around you physically.

Personal pain

Another obvious one would be the issue that you faced day to day. It can be in your work or personal life. Ask yourself: What would be the things that I am willing to pay if someone can help me to do this?

From existing ideas

You do not have to create an original idea from scratch. Notion is not the first note-taking app and Google is not the first search engine. It can be from any existing products that you think at some sort of aspects that you could do better, that might be something you can work on. For example, if the existing products are too costly for smaller businesses to get onboarded, I can help to solve that by adjusting the features to offer, and much more friendly to my target audience (small businesses in this case).

You do not have to wait for the perfect idea to start. Begin with something small, and you will pivot countless times along the way.

I have recently faced some issues while communicating with a freelance team on a project. Sometimes, the project management tools are just overkilled for freelance projects (which could be just a few simple tasks), and there is no effective (including cost) communication channel for them as well. Therefore, I would like to create a product, where freelancers can communicate (a real-time chat system) with their clients, and have basic project management tools on the same platform. In that case, they do not have to use and learn so many different tools. Besides, the pricing model would be suitable for freelancers and small projects too, which is charging by days (instead of by month). Therefore, people would not feel so much pressure of having to pay while having no business or project.

I do not have a super clear features roadmap in terms of this idea yet, therefore I quickly put up a simple Webflow landing page to collect some feedback on this idea. If you faced the same issue, I would really appreciate it if you can help to join the newsletter and help to shape the product along the way. Of course, there would be some special royalty for people who joined this in the early journey. Check out the landing page here:

frecto.webflow.io

Hope to hear from you soon :)

Career Advice Given by a Technical Director

Dylan Oh — Mon, 29 Aug 2022 12:20:44 +0000

I met with a technical director last week, talking about software engineering in general. He has been one of the smartest people that I know, and an inspiring leader to me. It was great to catch up with him after some time, and I decided to write down his sharing with me.

Everyone has imposter syndrome. Literally everyone, including the seniors.

I was sharing with him how sometimes I feel like an imposter where all the engineers around me look smarter than me, etc. He shared with me his previous experience of failing a coding interview and being panicked. Having a little bit of imposter syndrome and being anxious is fine, that’s the motivation to drive you further and work harder. I have also shared with him how I always compare myself with others who have been in the company for more than years. He told me that we should not be thinking about starting to show the work while just joining for a few months. People hired you and might not expect you to perform on the very first day as the processes in companies are different. Just be like a sponge and absorb as much as possible. Sit in, learn and ask people who have been in the company for a longer time.

One of the differences between a senior and a junior engineer is that the senior engineer could digest a piece of code more precisely than the junior by just looking at it.

Both senior and junior engineers have to search on Google when writing code, even like “How to implement a hash map in JavaScript”. However, the difference is obvious when both of them were introduced to a block of code, or an issue, the senior is able to spot the crucial piece regarding the root cause fast. The seniors are also able to identify the anti-patterns and being able to guide juniors on how/why they should be changed. This has to be built with experience in the process of reading and writing in the different code bases.

It is not just about technical skills to be promoted to a senior engineer, but soft skill matters as well.

Senior engineers have to communicate well with all the team members, especially since they serve as an important layer between the juniors and the managers/leads. They can help to do high-level analysis, and pass on knowledge to the juniors.

Engineering managers should not just care about engineers’ job performance, but also about their personal well-being.

He shared with me that one of the roles of an engineering manager is to help the engineers under him/her to unblock things that could hinder them to progress. He tends to make the one-on-one talk with the engineers to be much more casual, checking if they are burned out or having any issues in life. This could make the engineers feel a sense of belonging and encourage the culture of being transparent.

Do things that make an impact at your company.

The most important part of working in a company is to make sure that the work you do has an impact. A good manager would guide the team into doing higher-impact work. Lower-impact but easy-to-do things are sometimes inevitable. However, we should try our best to avoid works that are low impact and hard to be done. It might be just wasting your time.

Your manager gets promoted when you are promoted. The same goes for you and the people under you.

When you are climbing the corporate ladder, you might feel that there’s no room for you to move up as your manager is still in his/her position. However, in most cases, the manager will get promoted higher when his/her people are promoted higher. For example, if you are now a manager, and you are able to grow people under you to be a manager, you would eventually grow into the director’s (manager of managers) position. Therefore, the managers will try their best to help people to grow, and be as independent as they go.

Focus on learning best practices on code structure, and writing tests.

I have also asked for his advice on what should I focus on at this stage of my career. He advised me to learn how to write code in the right and proper way, instead of more languages, or more frameworks. The former could be applied to any programming language that you learn in the future. It is also precious as something that might not be taught in school or in tutorials out there. Besides, always cover your code with unit testing. Start practicing this on every single piece of code that you write.

Don’t be chased away by “NO WORK LIFE BALANCE”. It is relative.

When we see someone working from 9 to 8, we might think: “Oh, that’s terrible. Doesn’t the company know what is a work-life balance?” However if engineers from the typical “996” working culture join the company, they might feel they are having the best “work-life balance” ever. More importantly, we should always focus on, what can I learn more from this company. How can I make an impact on work, or influence others? If work-life balance is the only thing that you look at in your 20s, you might be chilling with Netflix in the peak growing period of your life. Under the premise of being healthy, grind hard in your 20s and 30s so that you leave no regrets.

He also brought this message to me:

Software engineering is no different from other types of engineering… things are inherently complicated as time goes by — but the concepts remain similar. If we can look at a vehicle’s engine for example… good engineering makes it maintainable. In order to make it maintainable you need to define a clear structure, boundaries, and processes. The things that change the most often (like engine oil filter), must be easily accessible, and making a change to it should not affect the things that change less often (like the pistons in an engine). It may sound like common sense when you think of a car engine, but the same also applies to software.

The reality is that engineering is more thinking, testing, trying than writing/doing.

Lastly, he also shared a framework of career growth as the software engineering manager from this website: A framework for Engineering Managers.

Do follow me for future articles on programming, developer productivity, and more topics! Cheers.

Follow me on Medium

Procrastination? You just need to break down your task.

Dylan Oh — Mon, 22 Aug 2022 13:52:00 +0000

Have you ever had difficulty maintaining focus while working from home (WFH)? I believe most of us face this issue when we tried to adapt to WFH and I was one of the victims.

This was what it looks like when I started WFH: I know exactly what task I need to work on, but I just couldn’t get on it. Everything else just seems to be more attractive than the task itself, like cleaning your desk or scrolling through social media, even when you are clearly aware that there is nothing else new for you to look at.

Due to this, I chose to commute to the office almost every single day, to keep myself more productive. I had finally decided to look at the root cause of it and started to take action.

There is the only huge reason that this is happening for me:

Procrastination caused by Fear

Like I said earlier, I know the things that I have to work on for the day, however, I have no actionable steps for them. The task looks so huge that I just subconsciously escape from it. I would rather do anything else that I can to avoid facing the problem.

Just an example of a software engineering task: I need to find out what is the reason for a bug that happened yesterday. But the task seems to be too general to start with. If I am not in the office on that day, I will start to tell myself: I need to get myself a cup of coffee before I can start looking at the task, or I shall give myself some time (to relax, to do some house works) before I am ready to look at such a complex troubleshooting task. But the fact is I will never be “ready” to start. There is no perfect timing to start, but creating smaller subtasks will make the change.

Next time when you receive a task to work on, do not start doing any analysis or brainstorming on the root cause of the issue. Just open up your notepad, and start writing down a step-by-step guide for yourself to tackle the issue. What I can do for the example task mentioned earlier, the task can be broken down into (can be in sequence or not):

Find out the exact timing that the bug happened
Look at the server log to check if there is relevant information
Check if the bug is replicable in other environments
Look at the past Jira tickets to see if a similar bug has happened before
...

After you have listed out the to-dos for the task, you should have an idea of where to start looking, and procrastination is not going to hit you hard. I have been personally using Notion to keep track of my daily workable tasks, this is an example of my daily to-dos:

It seems to be treating yourself like a robot or machine, but this is the best way to beat procrastination based on my personal experience (and yes, I do write out what I want to say during daily stand-up in my to-dos). The reason that I do this is also to prevent myself from spending too much time thinking of what to do while in the midst of deep work.

If you do also have the problem of focusing while WFH, I do encourage you to try listing out all the tasks before the day starts. It can be as detailed as possible so that our brain is not suffering when we are executing it.

Do also follow me for more articles on a variety of topics!

Follow me on Medium

Becoming a Software Developer in 5 Months by being Self-Taught

Dylan Oh — Mon, 25 Jul 2022 13:43:00 +0000

I started my journey of learning in 2019 and spent around 5 months landing my first software developer job. This is a quick recap and I hope it might help some of you who wish to get started (especially those who do not have a CS degree).

Learning

First of all, I do not have a Computer Science degree (but I am a degree holder, just not related). I started by just sitting in front of the computer, searching on Udemy platform (I am not sponsored), and bought this course: The Web Developer Bootcamp, instructed by Colt Steele. This course gave me a good insight into how web development works overall. You get to build a basic full stack web app that you can extend the functionalities, and eventually make it as part of your own portfolio.
Besides this, I will also recommend picking up a front-end framework, and React is still one of the most popular ones in the job market. Check out the courses for React on Udemy as well and watch the preview videos of them first. You might want to know the capstone projects that these courses are building since they will be your portfolio for showcasing.
If you want to get more exposure to the full stack, I suggest taking up a MERN stacks course (MongoDB, Express, React, Node.js). With these technologies, you will be able to build more interesting projects to demonstrate your skills.

Building

This is a crucial part to land your first job. Show off the projects you built while or after learning. There are several approaches to this:
Follow through the projects built in taken courses
Volunteer to build a website for someone
Collaborate with other developers (Some of the courses do have communities for the learners. Make use of them!)

After building the projects, put them onto GitHub, and write a nice readme for each of them.
The next would be your LinkedIn profile. If you are collaborating with others, or you did build a website for someone, ask for their help to give a recommendation on your LinkedIn! This will definitely help you to stand out from the competition. Link GitHub to your LinkedIn profile as well, so that recruiters or hiring managers could easily see what you got.

Resume

Time to write your resume! I would suggest trying to keep the contents within a page since you do not have much experience in this field for showcasing. Do put in the highlighted projects (as in the projects you really want to show), and give a very brief summary of the technologies used. Remember to also include your GitHub, LinkedIn profile, and your portfolio website (if you have one).
You may now start applying for jobs on LinkedIn, or any other local platform for your country.

I know sometimes it's hard to force yourself to be disciplined to just sit in front of the computer after a tiring day's job. I had been there but I knew this is something that I shall not regret.
Keep it up and you may ping me on LinkedIn if you are unsure of what to do, or need some motivation and suggestions.

Follow me on Medium

Amazon 6-Pager

Dylan Oh — Fri, 08 Apr 2022 15:26:00 +0000

It has been a while since my last article. I have just gotten some new offers and decided to move on with one. Hard decision as I love all my colleagues at the current work place but it is a very rare and challenging position thus the decision was made. Hope all of you are doing great as well :)

Write up a short one to introduce something that came across my desk when I was reading a book "I Saw the Future At Amazon" by JJ Park (I am not sure whether this is the name of the book, as it was originally translated from Korean), called the "6-pager".

Traditionally (or what most of us do), we use Powerpoint presentation to present some business ideas, case studies, with all the point forms being listed in the slides. As the presenter, we then elaborate from the points by speech. For these occasions, some people might end up doing the slides at the very last minutes, and improvise during the presentation. This always ends up with an ineffective meeting as most of the participants do not get the clear picture of the discussion, including the presenter.

In this book, the author introduced how Amazon does this as the presenter will be preparing a 6 pages of "transcript", written properly to describe in depth on the topics to be discussed in the meetings, as if anyone could fully understand without participating in the meeting. When the meeting starts, each of the participants will receive a set of 6-pager, and everyone reads the transcript for 15-30 mins, without anyone making noise. They will jot down the questions that they have, instead of asking the presenter directly like in a PPT presentation which sometimes interrupt the presentation. They might even find the answers in the following pages of the transcript themselves after reading the whole document. When the participants finish reading the 6-pager, the presenter doesn't have to go through all the details again, but proceed to the Q&A session.

Besides, when we finished the PPT presentation, we sent the presentation slides to the participants for their reference. However, the slides only contain the main points, which they don't get the notes from the presenter. With 6-pager, the presenter has to properly prepare and write up the transcript in order to describe everything by words, so that all of the contents could be referred back in the future.

I found this method amazing, did a search up on the internet and saw an amazing article by Jesse Freeman, which gives a complete walkthrough and strategies of applying this 6-pager method. You can check out this article here.

That's it for the sharing today! I have started diving into the development of dApps and Web3 related technologies and I can't wait to share more with you guys when the time comes. I shall try my best to translate them in a beginner-friendly way to you guys and all of my non-technical friends who are interested in blockchain technology. Stay tune!

Follow me on Medium