antonyjones.org RSS Feed

What I Actually Use My uConsole For

Wed, 24 Sep 2025 16:00:00 GMT

The uConsole by Clockwork is one of those gadgets you buy first and figure out later. At least, that’s how it went for me. The painfully long wait only gave me more time to imagine what I might use it for.

When it finally arrived, my plan was simple: a pocket-sized dev machine. Something I could code on anywhere. In reality? The tiny form factor works against that unless you start adding peripherals. And the more you add, the less "portable" the whole thing feels.

Sure, the uConsole shines as a retro gaming device—I’ve seen plenty of people use it that way. But with the handhelds I already own, I wasn’t looking for another emulation box. I wanted something different.

Portability was the big draw for me, but the built-in trackball was the first big letdown—clunky, inconsistent, and frustrating. So I plugged in my own pointing device, and suddenly it felt less like a couch-friendly handheld and more like a desk-bound setup. Add a keyboard, maybe a monitor, and before long you’re staring at something that looks suspiciously like… just another PC.

But here’s the thing: it isn’t.

The uConsole struggles with desktop tasks (even YouTube stutters with a second monitor), but that’s not where it shines. Once I stopped treating it like a mini PC, things started to click.

I’ve got a handful of Raspberry Pis running headless around the house, and this little box has turned out to be perfect for managing them.

When docked with the extra peripherals, it becomes a surprisingly capable "remote programming station". Coding over SSH, network management, monitoring, tinkering—it all just works. In this setup, the uConsole is starting to feel like it’s finding its purpose.

It’s not the portable dev machine I first imagined. But it has carved out a niche: a quirky, flexible hub for coding and keeping my Pis in check.

Though, thinking about it, an old laptop with Ubuntu would’ve done the job. I might do that and stop overcomplicating my life.

Chasing Ergonomic Excellence... or Just New Toys? - Part 2: Keyboards and Beyond

Wed, 05 Feb 2025 17:00:00 GMT

In the first part of this series, I shared my experiences with trackballs. This time, we’re shifting gears to keyboards.

Let’s Get Some Controversies Out of the Way

Before we dive in, let’s clear up a few things. RGB lighting? Not for me. I don’t need my keyboard looking like a Christmas tree. And while some people chase the perfect “thock”, I’m more concerned with how a keyboard feels than how it sounds. As long as it’s not obnoxiously loud, I’m good.

Now that the mini-rant is out of the way, let’s talk about something that actually matters—ergonomics.

Logitech Ergo K860: My First Foray into Ergonomics

Years ago, I saw a colleague using a split-layout keyboard—probably a Microsoft model. At the time, it looked weird, unnecessary. Why go against the traditional keyboard layout?

Then, I spent long enough working on cramped laptop keyboards, and well… I get it now.

When I transitioned back to a desktop, I picked up the Logitech Ergo K860. I had grown used to the light, low-profile keys of laptops, but my work laptop’s cramped layout was becoming unbearable for 8- to 9-hour workdays. It was time to prioritise ergonomics.

Having used Logitech products for years—the MX Master, the Performance before that, and various other peripherals—I’ve always been impressed by their quality, and the K860 is no exception.

The K860’s split layout immediately made a difference. My posture improved, my hands sat more naturally, and the slight curve helped keep my wrists in a relaxed position. The built-in wrist rest is comfortable—though I wish it were detachable—and the reverse-tilt feet are a nice touch, even if I don’t use them.

The low-profile keys made the transition from a laptop keyboard effortless. Plus, it integrates well with Logitech’s ecosystem, though with Bluetooth, I don’t really need the Unifying Receiver.

The biggest downside? No backlighting. Given how often I type in the dark like some nocturnal creature, this was a bit of a letdown. But overall, the Ergo K860 served me well—until I needed something more portable.

Enter the Corne GLP: A Minimalist Experiment

If you thought the Ergo K860 was a leap, meet my new setup: the Corne GLP keyboard paired with the Ploopy Nano trackball.

Switching to the Corne wasn’t as jarring as I expected—at least in terms of the split layout. That felt natural after the K860. What did throw me off was the columnar stagger. My fingers kept reaching for keys that weren’t there. It’s been an adjustment, and I’m still tweaking my layers to make it feel seamless.

Since the Corne lacks the K860’s ergonomic curve, I use tenting legs to maintain a natural hand position. The ultra-compact design sacrifices the function row, number row, and dedicated arrow keys, but thanks to the VIA firmware, I can remap layers to make up for it. Still, it’s a work in progress.

Typing on the Gateron Low Profile switches strikes the perfect balance—giving me that mechanical keyboard feel without the bulk. It’s lightweight, portable, and surprisingly satisfying to use. Once I fully dial in my layers, I suspect it’ll be hard to go back.

Why the Ploopy Nano?

So why another trackball? Because I’m an enthusiast, a minimalist, and maybe a bit of a masochist.

The Nano is as simple as it gets—just the ball, no extra buttons. I got it to pair with the Corne and keep my setup as portable as possible. My goal is to program mouse clicks onto one of my Corne’s layers, making the Nano more functional. Without that, it’s pretty useless on its own.

A minor annoyance? Micro-USB instead of USB-C. Carrying an extra cable isn’t ideal, but not a dealbreaker.

What really intrigued me was the open-source nature of Ploopy’s hardware. I’m considering modding it, maybe experimenting with BTU ball bearings for smoother movement. These bearings drastically reduce friction, but that could impact accuracy, as some resistance is required to stabilise the ball. I haven’t tested it yet, but I’m curious.

The Wacom Intuos4 S

You probably spotted another device in my setup—the Wacom Intuos4 S. I’ve had it for years, mainly for pixel art (when I somehow find the time). With the bulky K860 gone, I finally have enough desk space to keep it out permanently.

Wacom’s software is surprisingly versatile. I’ve mapped the ExpressKeys to media controls (play, pause, skip, mute) and set the Touch Ring for volume adjustments or seeking through videos. In Aseprite, it controls brush size and layer selection. I’m still figuring out how to make it useful in my code editor, but that’s next on my list.

For an older device, it still holds up well. The one thing I wish it had? Trackpad gestures—something I took for granted after years of laptop use. But considering its age, I can’t really complain.

Wrapping Up… For Now

And with that, this series comes to a close—at least for now. If history is any indication, I’ll probably tweak my setup again in a few months. Maybe a Part 3 is on the horizon.

See you in the next one!

Practical Tips for Personal Growth

Tue, 15 Oct 2024 23:00:00 GMT

Excellence is always a pursuit worth undertaking. Unfortunately, excellence usually seems to elude me. 😅 Nevertheless, I continue to commit myself to personal development. To self-improvement.

On this quest, I've read numerous self-help books, many of which felt like extended blog posts filled with fluff rather than anything profound.

However, when I explored HBR's Emotional Intelligence series, I found—much to my surprise (or perhaps not)—that these books were no exception. Facepalm. That said, they weren't entirely without value.

Here, I've compiled the worthwhile bits into a single, ~~plagiarised~~ curated post, enabling others to benefit without sifting through all the filler. While none of this is particularly revolutionary, I have found it practical. I hope you will too.

Enough preamble; let's get into it...

Self-awareness 🧍

When it comes to self-improvement, a crucial first step is taking stock of where you currently stand. This requires developing a deeper understanding of yourself, which is why we'll begin with self-awareness.

I'm focusing on simply regurgitating the pertinent information, so my waffling will be minimal today. Here goes.

Discover how you are perceived at work

Select 5 people.
Try to arrange a face-to-face meeting, emphasising confidentiality. Explain that you're gathering feedback from multiple people to identify common themes; this will lessen the burden on them.
Pose these questions:
- "What's the overall perception of me?"
- "What changes could I make that would have the greatest impact on my success?" - If the person is uncomfortable, they might rely on task-related feedback; politely redirect with the following:
  - "I value your feedback. Can we broaden the scope and discuss the overall perception of me as a leader, colleague, or individual?"
Seek elaboration if necessary.
Manage your reaction.

Strategies for soliciting constructive criticism

Here are some prompts I've found effective for soliciting personal feedback from others:

Start with self-reflection:
- "I've observed that I often work alone and am naturally quiet and introverted. I'm looking for ways to improve my communication and collaboration skills. Any tips on how I can better integrate with the team? Also, I'm open to suggestions for other areas of improvement."
Make self-improvement a personal commitment and ask for help:
- "I've committed myself to enhancing specific aspects of my performance this year. Would you be willing to provide feedback on one area where I can grow?"
Reframe feedback as an opportunity for growth:
- "What insights do you have that could help me achieve my goals?"
Minimise the impact of negative feedback proactively:
- "If there's one minor habit I could adjust for the better, what would it be?" - This communicates to the other person that they don't need to downplay, apologise, or contextualise negative feedback to make it easier for you to accept; you've already taken that step.

Embracing feedback and criticism

"For those who want to avoid criticism: don't say anything, don't do anything, don't be anything."

Understand your tendencies. Recognise your habitual responses and inclinations.
Separate the content of the feedback from the person delivering it.
Prioritise coaching:
- Distinguish between evaluative feedback (e.g., "Your rating is a 4") and coaching feedback (e.g., "Here's how you can improve").
- Embrace coaching as a means to learn, grow, and perform at a higher level.
Deconstruct the feedback:
- Before accepting or rejecting feedback, analyse it thoroughly.
- Seek clarification on its origin and intent.
- Explore what went wrong, the underlying expectations, and actionable steps for improvement.
Seek specific guidance:
- Don't solely rely on annual reviews for feedback.
- Proactively request focused coaching from various sources throughout the year.
Experiment with incremental changes:
- Implement small-scale trials to test potential improvements.
- Use feedback as a catalyst for iterative progress and development.

Unhooking Yourself

Recognise your recurring patterns.
Label your thoughts and emotions consciously.
Embrace them without judgment.
Align your actions with your values - Follow effective action with quiet reflection.

Making time for reflection

Identify important questions but refrain from answering them immediately:
- "What are you avoiding?"
- "How are you helping your colleagues achieve their goals?"
- "How are you not helping or even hindering their progress?"
- "How might you be contributing to your least enjoyable relationship?"
- "How could you have been more effective in your last meeting?"
Choose a reflection method aligned with your preferences, such as journaling, for example.
Set aside dedicated time.
Start small.
Do it.
Seek help if needed.

Confidence 😊

It's common for many of us to struggle with confidence at times. I've personally felt the effects of "imposter syndrome", an enduring struggle that persists within me.

In this section, we'll explore strategies to provide ourselves with the occasional boost we all need.

Building confidence

Prepare: Regular practice not only builds confidence but also enhances overall quality.
Get out of your own way: Confident people understand they can't know everything and are open to seeking guidance when needed. Don't hesitate to ask for help or direction.
Seek feedback when necessary: While self-assurance should come from within, external validation can also bolster confidence. Seek feedback from individuals invested in your growth and performance, whose feedback will be entirely truthful.
Embrace risk-taking: While playing to your strengths is strategic, avoid shying away from new challenges. Growth often stems from discomfort, so don't fear failure; embrace it as a vital part of progress.

Principles to keep in mind

To support personal growth, be honest about your strengths and areas for improvement. Take on challenging activities and seize opportunities that highlight your ability to overcome obstacles.

Instead of concentrating on natural abilities, emphasise the value you provide and seek external validation when needed. Avoid letting concerns about others' opinions hinder your progress; focus on your own development rather than hypothetical judgments.

The Dunning–Kruger effect

The Dunning–Kruger effect is a cognitive bias where those with limited competence overestimate their abilities, while high performers may underestimate theirs. Take a moment to let that sink in.

Overcome the eight barriers to confidence

Confidence is the expectation of a positive outcome. It is not a personality trait; rather, it is an assessment of a situation that ignites motivation. If you possess confidence, you're driven to put in the effort, invest time and resources, and persist in reaching the goal. Success isn't solely attributed to confidence itself; it's the dedication and effort that ultimately yield results.

Avoid these eight traps to build the confidence needed to pursue your goals:

Self-defeating assumptions - Believing you can't leads to inaction.
Unrealistic or distant goals - Confidence stems from achievable wins, with each small step bringing you closer.
Declaring victory too soon.
Isolating yourself - it's a trap to think you can go it alone; build a support system and uplift others.
Avoiding responsibility - Confidence lies in owning your actions and moving forward.
Defensiveness - Refrain from defending when not under attack; apologise for mistakes but not for who or what you are.
Failure to anticipate setbacks - Confidence incorporates realism; avoid blind optimism.
Overconfidence - Confidence is a sweet spot between despair and arrogance.

Remember, confidence isn't just about feeling; it requires action.

Great leaders are confident, connected, committed and courageous

To lead effectively, you must be:

Confident in yourself.
Connected to others.
Committed to purpose.
Emotionally courageous.

Helping a colleague with self-doubt

Rather than engaging in conflict with your team members' inner critics, initiate a dialogue about self-doubt. Consider the following approach:

Introduce the idea of the "inner critic", emphasising that it represents a voice in our minds often characterised by unrealistic thinking. Use the table below to illustrate the disparities between the inner critic and more realistic perspectives.
Encourage them to develop the skill of managing their inner critics.
Prompt them to practice recognising instances when they're influenced by their inner critic, encouraging them to label these thoughts accordingly.

Inner critic	Realistic thinking
Focuses on problems	Seeks solutions
Very sure it knows the truth of the situation	Curious and conscious of the many unknowns of the situation
Asks yes/no questions - "Is it possible?"	Asks open-ended questions - "How might this be possible?"
Sounds anxious and pessimistic	Sounds calmer and generative
Thinks in black-and-white terms	Able to see subtleties
Is repetitive	Is forward-moving

Focus 🎯

We live in an age of constant distractions. Technology and social media have shortened our attention spans, making it difficult to focus and stay present.

To avoid falling into endless doom scrolling, we'll now focus on... well, focus.

Strategies for making better choices and enhancing focus

Take regular breaks from screens and digital devices.
Ensure you get sufficient sleep and take mental breaks throughout the day.
Engage in mindfulness exercises to stay present and reduce stress.
Pay attention to other people's feelings and needs to relieve your own stress and gain the satisfaction of helping others.

To improve focus, notice how you lose it:

First, you choose a focus.
Sooner or later, your mind wanders.
Sooner or later, you realise your mind has wandered.
Having "woken up", you may choose to return to the original focus.

Steps 1 and 4 are deliberate, while 2 and 3 happen naturally. With practice, you'll stay focused longer before getting distracted.

What to do when you're feeling distracted at work

Understand the risks of multitasking.
Acknowledge your emotions while maintaining control.
Center your focus.
Base decisions on your values.
Set clear boundaries.
Select your interactions carefully.
Encourage mutual support with colleagues.

A few helpful tips to consider

To manage anxiety and stay focused, use breathing techniques to calm yourself and let your ideal self-image guide your actions. Set clear boundaries for social media and email to minimise interruptions, and be aware of how distractions affect your concentration.

Avoid spending time with easily distracted individuals and prioritise self-care by taking breaks, eating well, and getting enough sleep.

Motivating yourself to work when unmotivated

Fear of failure causing procrastination? Embrace a "prevention focus".
Feeling unmotivated? Disregard your emotions.
Task seems difficult or unappealing? Implement if-then planning.

5 ways to channel energy during work crunch

Acknowledge the situation.
Identify and name your emotions.
Retain control by prioritising tasks, making tough decisions, and prioritising self-care. Ask yourself: What are today's top priorities? How can I recharge? What must I decline or delay?
Keep open communication with colleagues and loved ones. Discuss deadlines, set boundaries, seek assistance.
Be kind to yourself.

One last thought to keep in mind

Your brain has its limits on focus:

Take power naps.
When creativity stalls, shifting focus can help; try embodying a different persona.

Mindfulness 🧘‍♂️

Now that our confidence is high and our focus is sharp, let's take a moment to consider how we can be more mindful, the final theme in today's pursuit of excellence. 😎

If you're open-minded, you can try the following daily routine. But if you'd rather not attract curious glances, do it in a private space where you can focus undisturbed.

Upon waking, dedicate 2 minutes to simply observing your breath while still in bed. As thoughts about the day surface, acknowledge them and gently return your focus to your breath.
When you arrive at your desk, invest 10 minutes in boosting your brain with the following short mindfulness practice:
- Close your eyes, settle into a relaxed but upright posture.
- Direct your full attention to the sensation of your breath.
- Immerse yourself in the rhythm of inhalation and exhalation.
- To anchor your focus, silently count each exhalation.
- Should your mind wander, gently guide it back to your breath.
- Above all, relish these moments; for these 10 minutes, your attention is solely yours.
Prior to each meeting, allocate 2 minutes for mindfulness practice.
Following lunch, set a timer on your phone to ring every hour. When it rings, pause your current activity and engage in one minute of mindfulness practice.
As your workday concludes and your commute home begins, embrace mindfulness. Dedicate at least 10 minutes of your journey to switch off your phone, silence the radio, and simply exist. Focus on your breath, allowing yourself to be fully present.

For maximum mindfulness benefits, aim for a daily practice of 20 to 30 minutes.

Empathy

Practicing empathy involves actively listening, understanding others' emotions, and offering support without judgment. By incorporating these behaviors into your interactions, you can build deeper connections and strengthen relationships.

Pose insightful questions in every interaction and summarise key points shared by others.
Demonstrate attentive listening by facing the speaker, making eye contact, and expressing genuine interest verbally.
Show empathy when someone confides in you, using phrases like "I'm sorry" and "that sounds challenging," while refraining from immediately offering advice or judgment.
Prior to meetings, take a moment to consider the individual's circumstances and recent events in their life.

Gratitude

Practicing gratitude enhances mindfulness by encouraging individuals to acknowledge and appreciate the abundance in their lives, enriching their overall mindfulness practice.

Integrate sincere expressions of gratitude into your communication with others.
Send personalised messages promptly to colleagues, expressing appreciation for a job well done.
Publicly recognise the contributions of each team member.
Celebrate successes with appropriate gestures, such as pats on the back, fist bumps, or high fives.

Jerry's final thought

Continuous self-improvement and the pursuit of excellence are fundamental to personal fulfillment and success. Growth is a lifelong journey fueled by a commitment to learning, adapting, and pushing one's boundaries.

Set high standards for yourself, embrace challenges, and persevere through difficulties. By doing so, you can achieve your full potential and gain a deeper sense of accomplishment and purpose in life.

References

Self Awareness - HBR
Confidence - HBR
Focus - HBR
Mindfulness - HBR

Chasing Ergonomic Excellence... or Just New Toys? - Part 1: Trackballs

Tue, 16 Jul 2024 23:00:00 GMT

When it comes to ergonomic tools for productivity, the trackball mouse is often overlooked. Traditional mice dominate most setups, but if you've ever experienced wrist strain or RSI, a trackball can be a game-changer.

Kensington SlimBlade Pro

I first encountered a Kensington trackball as a kid—probably their Expert Mouse—during a chaotic visit to PC World. My mate and I, in our infinite wisdom, decided to mess around with the trackballs, drawing enough attention to get ourselves kicked out. As we left, one thought stuck with me: I need one of these. Something about it felt different—almost futuristic. Still, years passed before I finally got my own—the Kensington SlimBlade Pro.

The SlimBlade Pro has a design that immediately stands out. It’s sleek, low-profile, and its large central ball gives off serious HAL 9000 vibes—minus the ominous AI. Unlike thumb-controlled trackballs, which can feel cramped and imprecise, the SlimBlade’s top-ball design offers fluid, natural movement and greater precision.

Customisation & Software

The SlimBlade Pro is plug-and-play, but I highly recommend installing KensingtonWorks for full customisation. With eight programmable button actions (four physical buttons, plus four customisable combinations), the SlimBlade Pro lets you tailor its functionality to match your workflow. You can assign different functions depending on the app, making it a versatile tool for productivity.

Twist-to-Scroll: Odd but Addictive

Scrolling on the SlimBlade Pro isn’t done with a wheel—it’s all about the twist-to-scroll mechanism. A gentle rotation of the ball lets you scroll through pages, accompanied by a satisfying clicky feedback. Once you get used to it, it’s oddly addictive.

DPI & Performance

With four DPI settings (400, 800, 1200, 1600), the SlimBlade Pro adapts to different needs. A lower DPI gives fine-tuned precision, perfect for tasks like editing or design work. However, its low polling rate makes it a poor choice for gaming.

Connectivity & Build Quality

A big step up from the original wired-only SlimBlade is the new wireless connectivity—offering Bluetooth, USB dongle, and wired options. I’ve used Bluetooth extensively without issues, though I’ve heard performance varies based on the connection method.

The ball glides on static bearings, likely made from ceramic or ruby. These bearings don’t wear down, keeping movement smooth over time. However, they can sometimes suffer from stiction (a tiny bit of initial resistance). A quick clean usually fixes this.

Some users replace the stock bearings with silicon nitride ones—an inexpensive material reportedly used in space shuttle bearings, which speaks to its quality. However, I haven't seen the need to upgrade. The stock bearings have been reliably smooth.

Button Layout & Feedback

The SlimBlade Pro’s buttons aren’t individually cut out; instead, they are part of a continuous surface. Unfortunately, this means clicks may not register outside the "sweet spots," though personally, I've found the tactile feedback reliable and consistent.

Enter the Ploopy Adept

With the SlimBlade Pro ticking all the right boxes, you’d think my trackball search was over. Not quite. Since I split my time between two locations, I needed a second device—and that’s where the Ploopy Adept comes in.

Yes, Ploopy is a ridiculous name. But don’t let that fool you—this thing packs a punch.

Where Do You Even Buy This?

Unlike Kensington’s mass-market appeal, Ploopy is an independent company that sells directly from their website. So you won't find one of these bad boys at your local PC World—if that’s even still a thing? Options include preassembled models or DIY kits for the brave (or budget-conscious).

Being a sucker for a project, I went with the kit. In hindsight, my soldering skills were not ready for this challenge. But after some trial, error, and possibly minor burns, I got it working.

How Does the Adept Compare to the SlimBlade?

Now that I’ve spent some time using the Ploopy Adept, the big question is: how does it hold up against the Kensington SlimBlade Pro?

Connectivity: Wired-Only Simplicity

Unlike the wireless SlimBlade, the Adept is strictly wired. If a cable doesn’t bother you, it’s a non-issue. But if you’re chasing a clean desk setup, this could be a drawback.

Build & Design

Despite being 3D-printed, the Adept feels solid. Like the SlimBlade, it has an ambidextrous top-ball design, but the buttons are more compact. One small gripe—because the buttons sit so close to the ball, accidental nudges can shift the cursor when clicking. This can be frustrating when aiming at smaller on-screen targets, so I may have to experiment with different button mappings.

Customisation: VIA Firmware vs. KensingtonWorks

The Adept is powered by VIA firmware, which offers six programmable buttons and ten layers of customisation. Unlike KensingtonWorks, these settings are stored directly on the device, meaning they travel with you. However, if you rely on app-specific shortcuts, KensingtonWorks might still be the better option.

Bearings: Static vs. Dynamic

The biggest mechanical difference is in the bearings. The Adept uses dynamic roller bearings, which initially felt scratchy compared to the SlimBlade’s smooth glide. But here’s the trade-off: dynamic bearings eliminate stiction. This makes the Adept better for pixel-perfect adjustments, even if it lacks the luxurious feel of the SlimBlade.

Scrolling: Omnidirectional vs. Twist-to-Scroll

The Adept’s omnidirectional scrolling allows movement in any direction, making it more intuitive than the SlimBlade, which requires modifier keys for horizontal scrolling. While I miss the clicky feedback of the SlimBlade, the Adept wins in overall usability.

DPI & Polling Rate

With a 1000Hz polling rate, the Adept is snappier and more responsive than the SlimBlade. However, its DPI is fixed, meaning no on-the-fly adjustments.

Final Thoughts

If you want premium design, smooth bearings, and application-specific control, the Kensington SlimBlade Pro is the better option. It feels high-end, the buttons are more forgiving, and the twist-to-scroll is addictive.

But if you value customisation, precision, and responsiveness, the Ploopy Adept might surprise you. It’s wired, a little rougher around the edges, but incredibly powerful.

At the end of the day, it’s about what fits your workflow. If you haven’t given a trackball a shot yet, it might be time to see what it can do for you.

Red... Green... Refactor!

Tue, 21 May 2024 23:00:00 GMT

Who's ready to be taken on a journey through the world of Test-Driven Development?!

Alright, I am well aware of the lack of enthusiasm towards writing tests, which is why I deliberately obscured it from the title. However, fear not! I will try my best to keep this light-hearted and engaging. And who knows? We might just transform your entire approach to software development along the way - but no promises!

Firstly, what is Test-Driven Development (TDD)?

And what's all this red, green, refactor business? - These are the three main steps of TDD. Essentially, developers write their tests before writing the code itself. Sounds absurd, I know, but let me elaborate. Here are the basics:

Red - Write a small test that fails.
Green - Make the test pass quickly, using any means necessary.
Refactor - Clean up the code, eliminating any duplication introduced while making the test pass.

TDD helps you get quick feedback on your coding decisions and manage that feedback cycle effectively.

Why TDD deserves your attention

Alright, why should TDD matter to you, and what benefits does it offer? Well, since you asked, here are several key reasons:

It enables you to learn more from the code. If you rush to cobble together the first solution that comes to mind, you miss the chance to consider a second, better approach.
Improved code quality. TDD encourages writing more modular and maintainable code.
Tests are written earlier rather than relegated to an afterthought. Defects are detected and fixed early.
Reduced defect density in the code. - Fewer nasty surprises! 🕷️
If the defect density decreases sufficiently, we can deliver shippable software with new functionality more regularly.
Tests serve as documentation, providing a clear understanding of the code's behaviour.
Greater confidence. Developers gain increased confidence in both the product and their ability to make changes to the code. With thorough testing, developers can confidently refactor code, knowing that tests will catch any regressions.

Alright, now that we've covered the basics, let's dive into the example and apply what we've learned in practice...

The fundamentals: A simple example of TDD

The following example demonstrates the TDD process for a pure function that returns the sound associated with a given animal. It takes a single parameter, `animal`, which is a string representing the name of the animal.

I'm sticking with JavaScript for this example because it's the language I'm most comfortable with, but don't worry, this process is just as applicable in any other language. So, backend devs, you're not off the hook that easily. 😉

Step 1: Write a small test that fails (Red)

First, let's prepare to write a test for the `getAnimalSound` function. Since the function doesn't exist yet, the test won't even run, let alone fail. But that's exactly what we want at this stage. To begin, create a new file called `getAnimalSound.test.js`.

// getAnimalSound.test.js import { getAnimalSound } from './getAnimalSound'; describe('getAnimalSound', () => { test('should return the noise of the provided animal', () => { expect(getAnimalSound('dog')).toBe('Woof!'); }); });

Step 2: Make the test pass quickly (Green)

Now, let's create the `getAnimalSound` function and make the test pass quickly, even if it means we commit a few coding sins in the process.

// getAnimalSound.js export function getAnimalSound(animal) { return 'Woof!'; }

Alright, so we may have taken a bit of a shortcut in this step. While we successfully passed our test, we're now faced with a situation where providing any other animal could lead to unexpected behavior, such as a cat barking, for example. Not exactly ideal, is it? But we still have one more step to go...

Step 3: Clean up the code and eliminate duplication (Refactor)

So, let's talk about duplication. Typically, duplication occurs between two or more pieces of code, but in our case, it's between the data in the code and the data in the test. You'll notice that "Woof!" appears in both places now. Let's address this.

// getAnimalSound.js export function getAnimalSound(animal) { switch (animal) { case 'dog': return 'Woof!'; default: return "Meow?"; } }

I know what you're thinking; "Woof!" still occurs in the reworked function. However, the crucial point is that the duplication between the test and the function has been eliminated. In the reworked function, "Woof!" is dynamically determined based on the input animal, rather than being hardcoded as the return value for all cases.

So, there you have it. You're now officially a TDD expert! 🥳 How do you feel? I know this example might seem overly simplified, but it's meant to illustrate the core process. As we know, real-world scenarios are rarely this straightforward. Let's move on to a more complex scenario...

Beyond the basics: Exploring a more advanced example

For our next example, we'll write a function to compute the total cost of items in a shopping cart, including taxes. Yes, it's still fairly simple, but unlike the first example, it provides enough complexity to demonstrate the iterative nature of the process.

Tip: You can make the steps as granular as you like, finding the right balance for the size of each step. TDD is flexible in this regard.

Step 1: Write a test (Red)

When writing a test, we imagine the best interface for our operation. It's better to start with the ideal API and adjust as needed, rather than making things complicated from the start.

// getCartTotal.test.js import { getCartTotal } from './getCartTotal'; describe('getCartTotal', () => { test('should return the total cost for a cart containing one item', () => { const cart = [{ name: 'Rubber Chicken', price: 10 }]; const total = getCartTotal(cart); expect(total).toBe(10); }); });

Step 2: Make it run (Green)

Getting the test to pass quickly is paramount. If a quick and simple solution is evident, implement it immediately. If it will take a minute or two, make a note and return promptly to getting the test to pass within seconds. This is our primary objective.

There are several strategies to achieve a quick test pass, but two are commonly used:

Faking it: Begin by returning a constant and gradually replace it with variables until the real code is implemented. This was demonstrated in our first example.
Employing an obvious implementation: If the solution is straightforward, type the actual implementation right away. This is what we will demonstrate now.

// getCartTotal.js export function getCartTotal(cart) { return cart[0].price; }

Step 3: Make it right (Refactor)

While our test passes with the "actual implementation", we identify a design objection: our function lacks support for handling multiple items. However, we don't write new code unless a test fails. To address this, we write an additional test to cover the scenario.

// getCartTotal.test.js test('should return the total cost for a cart containing multiple items', () => { const cart = [ { name: 'Rubber Chicken', price: 10 }, { name: 'Snorkel', price: 10 }, { name: 'Fluffy Handcuffs', price: 10 } ]; const total = getCartTotal(cart); expect(total).toBe(30); });

With the new test in place, we refactor the implementation to support handling multiple items.

// getCartTotal.js export function getCartTotal(cart) { return cart.reduce((total, item) => total + item.price, 0); }

Step 4: Write a new test (Red)

We identify another design objection: our function doesn't support taxes. As you might have guessed, we write a new test to address this.

// getCartTotal.test.js test('should return the total cost including taxes', () => { const tax = 0.1; const cart = [{ name: 'Metallica Tickets', price: 100 }]; const total = getCartTotal(cart, tax); expect(total).toBe(110); });

During the TDD process, it's common practice to translate design objections, or side effects, into new tests. This iterative approach reflects the organic nature of system design through TDD, where running code continuously informs decisions.

Step 5: Make it run (Green)

Once again, we get our test to pass:

// getCartTotal.js export function getCartTotal(cart, taxRate) { const subtotal = cart.reduce((total, item) => total + item.price, 0); const tax = taxRate * subtotal; return subtotal + tax; }

After our new test passes, we transition back to the refactor step to ensure the code remains clean and duplication-free. Any additional tests are added as new design objections arise. For example, we might consider how the function should handle an empty cart.

And so, the cycle continues. This is the iterative nature of the process. I hope, through these examples, you can grasp the mechanics of Test-Driven Development.

Some useful tips and strategies for effective TDD

Writing tests

You should never be more than one change away from green. In other words, avoid writing tests in bulk. As you get tests passing, the implementation will naturally suggest new tests.

When writing tests, begin with the assertions. Tests are easier to write when you already know the expected outcome.

Envision the optimal interface for the operation. It's better to begin with the ideal API and make adjustments as necessary, rather than complicating things from the start.

Getting to green

At this point in time, passing tests swiftly is our primary goal. Outlined here are effective strategies for achieving this goal promptly.

Fake it 'til you make it

Start by returning a constant, then incrementally replace it with variables until the actual code is implemented. But why do something you know you'll have to discard later? Maybe it's the placebo effect, but it just feels good seeing those green tests.

Obvious implementation

If you know what to type and you can do it quickly, then do it. But remember to maintain the red-green-refactor rhythm. It's like headbanging to Slayer, the pace is faster, but be prepared to revert back to Metallica if your neck needs a break.

One to many

How do I implement an operation that works with collections? Begin by implementing it without the collection first, then adapt it to work with collections. In other words, start with a single value and then progress to using the collection.

Triangulation

Instead of making assumptions solely based on the initial test case, you introduce additional tests with varied input values or scenarios. These extra tests serve to "triangulate" the code's behavior by verifying it in multiple situations, reducing the chance of false positives.

Refactoring

You will often implement TDD in code that lacks adequate tests. When there aren't enough tests, you'll encounter refactorings that aren't covered. This means you could make a mistake during refactoring, and all tests would still pass. In such cases, write the tests you wish you had. Otherwise, you risk eventually breaking something while refactoring.

Bonus feature: Enhancing the TDD experience with Jest's watch mode

If Jest isn't part of your toolset, feel free to skip this section.

Jest's watch mode can be a powerful ally when integrated into the TDD workflow. Here’s how you might find it useful:

Immediate feedback: Automatically re-runs tests upon file changes, delivering immediate feedback on the success or failure of your code.
Efficient workflow: Removes the necessity of manually running tests after every modification, streamlining the TDD process.
Focused testing: Lets you filter by file or test name, so you can focus on the tests that matter most to your current work.
Enhanced productivity: Jest's watch mode keeps you focused and allows you to maintain momentum by offering real-time feedback and reducing the need for manual test execution.

To enable watch mode in Jest, you can run the command `npx jest --watch` in your terminal.

Wrapping things up

So, what are my thoughts on Test-Driven Development? Well, while TDD is still relatively new to me and I'm far from being an expert, I've enjoyed the learning process. Sure, there's a bit of a learning curve, but I believe that with time, I'll come to appreciate the benefits.

TDD proves practical not only for implementing new features but also for making changes to existing code. By ensuring thorough testing of both new features and code modifications, it promotes the creation of reliable and well-functioning code.

Finally, TDD encourages a different approach to code design, one that may lead you down paths you might not have considered otherwise. It's an interesting experiment, if nothing more. However, I think that if you give it a try, you'll soon begin to see its benefits and be able to add another string to your bow.