DEV Community: Jake McLelland

Sometimes the Best Work Ends with No Work at All

Jake McLelland — Thu, 03 Jul 2025 21:03:27 +0000

Most developers I know are eager to dive into code. Honestly, I am, too! There's something satisfying about building solutions, seeing immediate results, and having tangible commits to show for your time. But over the years, I've learned that some of the most valuable work happens outside of the IDE.

Recently, I received a ticket to fix a "bug" where tax calculations were incorrect on invoices. The obvious move would’ve been to tweak the tax logic, maybe add some conditional statements and patch it quickly. Instead, I paused and spent a little time tracing the data flow. Stepping through the frontend display, the server-side API code, down to the mainframe data imports.

That day, I discovered that the app wasn't broken at all. It was correctly calculating tax based on the data it received. The real issue was a single incorrect value in the client's mainframe system. The fix? A simple data update on their end. No code required.

This kind of discovery work doesn't generate impressive pull requests or flashy demos. But it protected the client’s development budget for features that really mattered, and prevented us from building a workaround that would have masked the real problem.

I've found that taking discovery seriously, even when it doesn't generate code, often produces more value. It's detective work that pays dividends in time saved, technical debt avoided, and clients who trust that you're solving their real problems, not just the symptoms they present.

The best developers I know aren't just good at writing code. They're good at knowing when not to write it at all.

What are your thoughts? Have you ever “developed” a solution by writing no code at all?

Some thoughts on AI

Jake McLelland — Mon, 14 Apr 2025 19:40:04 +0000

As a professional software developer, I’ve noticed it’s becoming increasingly difficult to avoid using AI. CoPilot is now built into Microsoft products like Word, Excel, and PowerPoint, to name a few. Most IDEs, like Visual Studio and Xcode, now have AI enabled by default to assist with coding.

There’s a difference between deterministic and non-deterministic AI. If you’ve ever googled anything or used spell check, you’ve already used a mix of deterministic (or pre-programmed) and non-deterministic or probabilistic AI. For the rest of this post, what I mean by “AI” is the non-deterministic generative AI, using tools like Perplexity, ChatGPT, and more specifically CoPilot.

While I’m often amazed by how AI appears to read my mind when it suggests the next bit of code, it’s obvious that it also has some limitations. My experience in using AI in the development process reminds me a lot of guiding a toddler through an obstacle course — I’m constantly adjusting and cajoling it to get the results I need. I often ignore its suggestions — and sometimes even defy them outright. Prompt engineering seems as important an art to learn now as is other aspects of development.

At its core, AI is just a parrot imitating the style and syntax of the code surrounding it. That could be a good thing or a bad thing. For example, imagine walking into the subway in New York City. There’s trash everywhere and 1 out of every 10 people who come through the system evade the fare by jumping the gates.

If you were AI, you might conclude that these details define correct behavior in the context of the subway because that’s what the majority do.

Just because something is common, popular, or even ubiquitous does NOT make it right!

This is what “vibe coding” with AI gives you.

The large language models that power AI are only predicting which word comes next. Sure, today’s more advanced models included lots of training and self-analysis. But, at the end of the day, AI is merely imitating what everybody else has already done, or what it already sees in your codebase.

Or to use an early computing term: GIGO (garbage in, garbage out)!

There’s a lot of brilliant software out there. There’s also a lot of trash. Even some of the training bootcamps I’ve seen don’t actually follow best practices and end up with some less than tidy code. Perhaps because a training project, or a portfolio capstone project has a pretty high entropy tolerance, who cares if the code is tidy or not? But a real, professional production product deserves some careful thought. I’ve always said that even though nobody except one or two other developers will ever see your code doesn’t mean the code can be sloppy! Production code especially should be as clean on the inside as it is intuitive on the outside.

I hope that someone figures out a way to cut through all the politics of curating the “best practices” or “correct information”, and ignore all the “trash” of lazy (I mean brilliant) developers. At the end of the day, “vibe coding” with AI will only give you code that perhaps, possibly, maybe works??? (And yes my AI companion yelled curses at me to “fix” that last sentence!)

Don’t get me wrong, I use AI all the time. But I believe AI works best as an analysis tool, the same way spell-check is a lifesaver for a document. It can do wonders for checking your work, debugging issues, and helping you simplify and optimize things. Relying on it to write ALL your code would be risky.

AI has come a long way in the past few years, but I’m not holding my breath for Mr. Data to show up in the office any time soon! Perhaps we have reached the point of having a real Eddie from HHGTTG, or maybe it’s more like Holly from Red Dwarf. As long as we avoid HAL 9000 and Skynet, we’re good!

What do you think? How do you use AI in your workflow?

Syntactic Elegance-The Developer’s Dream

Jake McLelland — Mon, 18 Sep 2023 23:49:45 +0000

I recently wrote that developers have to strike a perfect balance of delivering high-quality software that works well, looks good, and is delivered on time.

Of course, it's impossible to "have it all" unless all of your clients are fabulously wealthy and have all the time in the world.

I wanted to delve more into the aspect of Syntactic Elegance.

Just because nobody will ever see the code, doesn't mean it can be sloppy!

Code That Speaks For Itself

What I mean by Syntactic Elegance is code that appears to be simple and easy to follow, but that actually does a lot. Think of a high-end luxury sports car. With smooth curves and perfectly glossed paint, it seems both simple and supple at the same time. It got that way because someone spent a lot of time carefully refining and polishing it.

Unfortunately, in most cases, clients can't afford to wait for you to test and refine every aspect of your code. But just a few habits go a long way to producing elegant code.

Here are my top three recommendations

Avoid acronyms! Especially obvious ones.

Consider a scenario where you have a model used solely for serializing a class sent back and forth between the server and client. Some might call that a POCO object, or a DTO model. Don't! Not because there's debate about the meaning of both DTO and POCO (or as my coworker yells each time "you don't need to say 'object' after 'DTO' or 'POCO' because the word 'object' is part of the acronym!'), but because it should be clearly obvious what something is simply by looking at it. All modern IDEs show you what an element is simply by hovering the mouse over it or navigating to the definition. Embedding the type of something in the name is tantamount to calling your manager "JimBoss"! Name an object for what it truly is! Instead of CustomerDto, simply call it Customer.

Spell things out!

I once had a coworker who consistently used unnecessarily short and arbitrary abbreviations in their code. I had to hold myself together one day when they called me over to help work out some logic and I noticed they had used x, y, and z as variable names in code they had actually committed to the repository! To me, it seemed 2 parts lazy and 3 parts naive. Don't get me wrong, I tend to begin by inventing new code elements with whimsical variable names like pizza and cat until I understand their purpose and functionality. But as soon as you get to a point that you reasonably know what something is, give it a name!!! Humans have such a deep desire to name things that we arbitrarily name the full moon at perigee differently than the full moon in January differently than a second full moon during the same calendar month!

A good name conveys what the code does, what the object represents, and what the consequences of using it might be.

On one project, one developer wrote a method named GetNextValue that returned the next logical value in an alpha-numeric sequence for a kind of record identifier. Seems innocent enough. But, under the hood, in order to get that "next" value, it inserted a row into a table that stored the value it came up with (to ensure it was unique,) and also updated the Consumer table with that unique value. In other words, the method was anything but a simple Get! It altered the database under the hood! A good name should reflect that, perhaps with a name like RegisterConsumerRecord in this case. This is particularly crucial if other developers intend to reuse the method or if it might have unintended consequences (as was the case here). The day another developer innocently re-used that method had disastrous consequences because the poor naming of the methods they developed led both developers to misunderstood what the other's code did.

Observe the accent and style preferences of the language of the code

Which is more correct: to place the opening curly brace in-line with a method definition, OR immediately below it on the next line?

if(myValue > 42)
{
    DoStuff();
}

Figure A

if(myValue > 42) {
    DoStuff();
}

Figure B

The correct answer is: It depends on the programming language in which the code is written! Javascript developers prefer the style in Figure B, whereas C# developers prefer the style in Figure A. Both developers, who are both equally amazing, will say the other clearly just looks wrong! Should you use camelCase or kebab-case for variable names or other elements? The correct answer is: It depends on the language. Every language comes with it's own "accent", and any time you need to switch contexts to another language, do everyone a favor and adapt your code style to the preferences of the language your code is in!

You can't have it all, but cultivating a few simple habits can make your code more approachable for the next developer who follows in your footsteps!

Happy coding!

Handling Duplicate Records

Jake McLelland — Tue, 13 Dec 2022 21:47:25 +0000

Let's talk about a scenario that comes up occasionally:
How can I deal with duplicate records in a database?

This happens for various reasons outside the scope of this article. The question is how to deal with them.

You have a few options.

Ideally, you would have some indexes on your table that enforces unique constraints. That way, duplicate data simply gets rejected by the database instead of sneaking in. In my case, the table in question is a generic log that includes lots of optional fields. The complexity prevented me from making any kind of unique constraints that made any sense.

Another option is (if you have control over the software that inserts the records), you can update that software to first look for existing records instead of blindly doing inserts. If you can't apply unique constraints to the table at the database level, this is your next best option, and is what I did. However, I still had all the duplicates sitting there in the database from before I added the code to my API to protect against them.

If you have just a few dupes, you could manually locate them, and manually execute delete statements using whatever primary keys or other specific data that identifies just the duplicate records. The drawback here is that you could end up accidentally deleting non-dupes, other data, or worse, the whole table. Terrifying, isn't it! (This is what keeps DBA's up at night! "Don't forget the WHERE clause!!" you'll hear them scream as they wake up from their nightmare, sweating and shaking uncontrollably.)

There are probably other options. Here's a solution that worked for me.

I'm using a Microsoft SQL Server database hosted on an Azure server. So, I can take advantage of some slightly non-ISO standard SQL syntax. (you could easily modify this slightly to work with whatever DB platform you’re running)

My solution uses a cursor.

Now, I know. I could hear you gasp just then and click your tongue at me. But rest assured, this is probably one of only, . . . well honestly, I can’t remember any other time I've ever been forced to use a cursor when I could do anything otherwise. (Full disclosure, I have actually approved the code review of someone else who was forced to use a cursor, and I've also been forced the indignity of maintaining someone else's code base that included some cursors for whatever reason. Don't judge me!)

The basic overview is that we need to declare some variables to hold some values we can use for finding and matching the duplicates. Then we set up the cursor, preferably with FORWARD_ONLY specified so we keep things lite on the server. Next, we begin a loop that first finds one "good" record per dupe-set, and then deletes all the other matching records except that good one. Finally, don't forget to close and deallocate the cursor so you can pretend you never used one and feign ignorance.

Now for the good stuff.

(Variable, table, and column names obfuscated below to protect the innocent)

-- Set up the variables
DECLARE 
  @countOfDupes int, 
  @transactionDate datetime2(7), 
  @customerId int, 
  @invoiceId nvarchar(13), 
  @transactionType nvarchar(25)

-- Prepare the cursor we'll use
DECLARE logDupes CURSOR FORWARD_ONLY 
FOR
SELECT
  CountOfDupes = count(Id),
  TransactionDate,
  CustomerId,
  InvoiceId,
  TransactionType
FROM TransactionLogs
GROUP BY TransactionDate, CustomerId, InvoiceId, TransactionType
HAVING count(Id) > 1 -- only the ones that have duplicates

OPEN logDupes

FETCH NEXT FROM logDupes   
INTO @countOfDupes, @transactionDate, @customerId, @invoiceId, @transactionType

-- Now loop through each set that has duplicates
WHILE @@FETCH_STATUS = 0
BEGIN
    PRINT concat('Handling ', @countOfDupes, ' duplicates for customer: ', @customerId, ' on ''', @transactionDate, '''')

    -- First, get the @firstMatchingId for just the top 1 matching result
    DECLARE @firstMatchingId int

    SELECT 
      TOP 1 
      @firstMatchingId = Id
    FROM TransactionLogs
    WHERE CustomerId = @customerId
    AND TransactionDate = @transactionDate
    AND InvoiceId = @invoiceId
    AND TransactionType = @transactionType

    -- Now use that @firstMatchingId to delete all the matching results EXCEPT FOR the top 1
    DELETE FROM
    TransactionLogs
    WHERE Id NOT IN (@firstMatchingId)
    AND CustomerId = @customerId
    AND TransactionDate = @transactionDate
    AND InvoiceId = @invoiceId
    AND TransactionType = @transactionType

    -- Continue the loop
    FETCH NEXT FROM logDupes   
    INTO @countOfDupes, @transactionDate, @customerId, @invoiceId, @transactionType
END

-- Dont forget to close and deallocate the cursor!
CLOSE logDupes  
DEALLOCATE logDupes

See Microsoft's documentation for specific guidance on using cursors in SQL Server.

If you've found a better way to delete a bunch of duplicate records from your db, I'd love to hear your story!

Hope you find this amusing, or possibly helpful.

Combining two datasets into one

Jake McLelland — Sat, 20 Aug 2022 18:42:38 +0000

The other day I had a client request that we add square pegs to a round hole. We needed to return two, very different objects into a single collection. This happens all the time in this industry, of course. And it's obviously not a big deal to add a new object that can represent the good bits from both objects as one conjoined unit.

But, one of the more interesting challenges that resulted was that I needed a search method that:

Definitely returns objects from both distinct data sets
Still honors an overall take limiter from the client application.

In other words, if the client app request only 10 records, but there are some of both data sets, how do you limit the final results so that there are definitely some of both (if possible) and yet the overall return stops at the requested limit?

If there are no results in the first dataset, but some in the other, then clearly you can just use the requested take count.

It gets tricky, though, when there are a few in both, especially when there are a bunch in one but only one or two in the other.

Let's say the client app requested 10 records, one dataset returns 9, and the other 1. As a human, I read that and it's a no brainer. We can take all of both, it's less then 10, all good. But what if there are 6 of one and 42 of the other? Or thousands in both?

I'm sure there's probably a more sophisticated way to handle this, either mathmatically, using AI, or something else more clever. But this is what I came up with.

👇 Run this in dotnetfiddle

public static (int leftTakeCount, int rightTakeCount) GetTakeCountsFromTwoSourcesToMeetOneTotalQuota(int take, int leftCount, int rightCount)
{
    int halfTake = take / 2; // since it's an int here, the decimal will just truncate
    int totalCount = leftCount + rightCount;

    bool totalCountAboveTake = totalCount > take;

    bool leftAboveHalfTake = leftCount > halfTake;
    bool shouldReduceLeft = totalCountAboveTake && leftAboveHalfTake;

    bool rightAboveHalfTake = rightCount > halfTake;
    bool shouldReduceRight = totalCountAboveTake && rightAboveHalfTake;

    // When both counts are above the requested take count and also above the halfTake, then we can just chop both down to the half count
    bool canReduceBothToHalftake = totalCountAboveTake & leftAboveHalfTake & rightAboveHalfTake;
    int leftReductionToHalfTake = canReduceBothToHalftake ? leftCount - halfTake : 0;
    int rightReductionToHalfTake = canReduceBothToHalftake ? rightCount - halfTake : 0;

    // When one of the counts is below halfTake, we need to calculate the difference so that we'll end up with some of both
    int leftReductionToDifference = (shouldReduceLeft & !canReduceBothToHalftake) ? leftCount - (take - rightCount) : 0;
    int rightReductionToDifference = (shouldReduceRight & !canReduceBothToHalftake) ? rightCount - (take - leftCount) : 0;

    // Since we used booleans above, one of these will end up as 0. So get the other one
    int maxLeftReduction = Math.Max(leftReductionToHalfTake, leftReductionToDifference);
    int maxRightReduction = Math.Max(rightReductionToHalfTake, rightReductionToDifference);

    int finalLeftReduction = shouldReduceLeft ? maxLeftReduction : 0;
    int finalRightReduction = shouldReduceRight ? maxRightReduction : 0;

    int leftTakeCount = leftCount - finalLeftReduction;
    int rightTakeCount = rightCount - finalRightReduction;

    return (leftTakeCount, rightTakeCount);
}

Here, I assume that if the sum of both counts is less than or equal to the requested take amount, then we can just use all of both. But if the sum is more than that, we need to intelligently reduce the larger side to leave room for the smaller side. And if there's just a bunch in both sets, we can just cut the requested take value in half and return that many of both values.

The result is a tuple that gives me the take value of the first or 'left' dataset separately from the second or 'right' dataset. That allows me to limit my database query for both sets so that the total number of records is whatever the client requested.

One obvious issue that I don't have time to address here is that since I'm using an int as the halfTake value and therefore disposing of the remainder decimal values, if you request an uneven number like 25, then the halfTake will end up one rounding up to the nearest int, and you'll end up with one extra record.

But, since I control the client app, . . . I'm not going to do that, and just not worry about that for right now. Besides, my consuming service method actually has to sort these values later, so I can just lop off the extras with another .Take(request.Take) statement in the service before returning it to the client.