Rohit Jha

What I Lose When AI Writes the Code

Fri, 14 Aug 2026 00:00:00 +0000

I recently realized that I don’t enjoy using AI coding agents to implement substantial changes at work. They can shorten the path from an idea to working code. I am trying to understand why that productivity often makes the work less satisfying for me.

My current explanation is that coding is part of how I think. The design continues to change as I implement it. A type that looked natural on paper becomes awkward at its call sites. An error path forces a decision about which layer owns recovery. A performance assumption sends me to a profile or generated assembly.

Property-Based Testing in Go: Testing Invariants with Generated Inputs

Tue, 28 Jul 2026 00:00:00 +0000

I once ran into a Go type that could be serialized and deserialized without an error, but the value that came back was different from the original. The tests passed because they only covered the inputs I had written down.

Property-based testing (PBT) helps with this kind of gap. Instead of listing more examples, I describe the invariant and use generated values to test it. When a test fails, the library shrinks the input to a smaller counterexample. I still keep example-based tests for cases worth naming and documenting.

Microservices in Go (Part 1)

Sun, 28 Feb 2021 00:00:00 +0000

0. Setting up your environment

Installing Go

You can find the instructions for installing Go on your OS here.

Once you have installed Go you can run the following command to verify that the installation succeeded:

$ go version
go version go1.16 darwin/amd64

Editor/IDE

For programming in Go, I use Visual Studio Code as my IDE with the Go extension and I highly recommend using it.

1. Boilerplate

Let’s create a new directory, and set up the boilerplate code.

Energy-Efficient Programming

Sat, 05 Sep 2020 00:00:00 +0000

In my first blog post Towards Leaner Software, I wrote about the importance of runtime performance in terms of CPU and memory efficiency. After reading the paper “Energy Efficiency across Programming Languages”, I realized I hadn’t given much thought to energy consumption of programs and had assumed (incorrectly) that faster execution corresponded to better energy efficiency. If engineers choose languages, data structures and design patterns that result in the least energy consumption, it will help software run better on mobile devices and cloud data centers, two areas where computing is growing the fastest.

Systems Programming

Thu, 27 Aug 2020 07:24:51 -0700

Having worked as an application developer for over 5 years now, I’ve noticed how, generally, there’s a lack of motivation and incentive to build robust, correct, secure and fast application software. While I’m fortunate that my team at GoDaddy does focus on these aspects, right from the design phase, it’s doesn’t apply to all. Furthermore, the higher a developer works in the application stack, the smaller the chance that they invest their time and effort into imbibing these characteristics into their code.

Minimizing Docker Image Sizes

Fri, 21 Aug 2020 22:30:51 -0700

With the rise in popularity of microservices, Docker has gained popularity and has become the standard for containerization. Its ease of use in software delivery using containers has put it ahead of other containerization technologies such as rkt, which has since been archived, and LXD.

I’ve lost count of the times I’ve come across popular official Docker images that were bloated and riddled with bugs and known vulnerabilities. This causes many developers to shun them in favor of building their own alternate images, causing duplication of effort, developer time and storage space and costs. And even though these alternate images are better, they’re not as popular as the official ones, which leads to a lower adoption of good-quality images. Meanwhile, I’m sure a large percentage of the developer community still relies on the inferior images.

Towards Leaner Software

Wed, 12 Aug 2020 23:21:51 -0700

In his 1995 article “A Plea for Lean Software”, Niklaus Wirth wrote:

Software expands to fill the available memory

Software is getting slower more rapidly than hardware becomes faster

Wirth explained that the two causes for bloating of software are the rapid growth in hardware performance and customers’ ignorance of features that are essential vs nice to have. 25 years on, Wirth’s Law still holds true. At a time when a software product’s power is measured based on the number of features, the rampant incorporation of all possible features that users may want messes up the software design and causes quality and performance to take a backseat.

Morse Code

Mon, 18 Jun 2012 21:38:54 +0000

According to Wikipedia, Morse code is a method of transmitting text information as a series of on-off tones, lights, or clicks that can be directly understood by a skilled listener. It was developed in 1844 and is credited to Samuel F.B. Morse. As a child, the Morse code had caught my attention and I couldn’t stop but learning it.

The essentials of Morse code can be summarized easily. The code consists of only two symbols, a dot ‘.’ and a dash ‘-‘. A combination of these symbols results in a rudimentary representation of the Latin alphabets and decimal numbers. Each character is represented by a unique sequence of dots and dashes, which are also referred to as ‘dit’ and ‘dah’. The duration of a dash is 3 times that of a dot. Additionally, a gap equivalent to the duration of transmission of a dot is put between each symbol of the code. This duration is called one unit. Two letters are separated by a gap of 3 units and two words are separated by a gap of 7 units. The rate of transmission is measured in terms of words per minute (wpm) or characters per minute(cpm).

Prime Factorization

Sun, 26 Feb 2012 20:56:01 +0000

In the post “Sieve of Eratosthenes“, I had posted a Java program for the prime sieve. Translating it to Python, I have:


from math import sqrt

def prime_sieve(limit) :
 crosslimit = int(sqrt(limit))
 sieve = [False]*limit

 for n in range(4, limit, 2) :
 sieve[n] = True
 for n in range(3, crosslimit+1, 2) :
 if not sieve[n]:
 for m in range(n*n, limit, 2*n) :
 sieve[m] = True

 num_primes = 0
 primes = []
 for n in range(2, limit) :
 if not sieve[n]:
 num_primes += 1

 for n in range(2, limit) :
 if not sieve[n]:
 primes.append(n)

 return primes

The list of primes generated by this sieve could then be used for factorizing a given number. For calculating the factors, I use the Trial Division algorithm, which isn’t the fastest, but easily implemented and not probabilistic. The algorithm basically tests if a given number (integer) n is divisible by any integer between 1 and n. Since only the prime factors of n are needed, we can use the list of primes generated from the sieve as a base set for the calculation, instead of the set of integers. Furthermore, the trial factors need go no further than because, if n is divisible by some number p, then n = p×q and if q were smaller than p, n would have earlier been detected as being divisible by q or a prime factor of q.

Fibonacci sequence – Part 2

Tue, 03 Jan 2012 18:50:27 +0000

In this post we’ll compare the various methods of generating Fibonacci sequence terms and implementing the code to recognize Fibonacci terms and to determine index of these terms. These have been discussed mathematically in the previous post.

Generating Fibonacci Terms

Method 1 – Iterative method

Using the basic concept of the Fibonacci sequence, that each term is the sum of the previous two terms, the following function in Python generates the nth term:

Fibonacci sequence

Mon, 21 Nov 2011 19:06:33 +0000

The Fibonacci sequence in mathematics is the following sequence of numbers:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233 …

Representation

By definition, the first two terms are 0 and 1, and each of the terms following them are the sum of two previous terms. So, if we say Fn is the nth term in the Fibonacci sequence, then we can express the sequence recursively as:

Searching Algorithms – Part 3

Fri, 18 Nov 2011 18:14:55 +0000

Uniform Binary Search

I came across the uniform binary search algorithm in The Art Of Computer Programming – Volume 3: Sorting and Searching as an optimization of the binary search, invented by the author, Donald Knuth. It works quite well for architectures on which a table lookup is generally faster than an addition and a shift, and also when many searches will be performed on the same array, or on several arrays of the same length.

Searching Algorithms – Part 2

Thu, 17 Nov 2011 16:10:43 +0000

Binary Search

The binary search algorithm, a variation of the Dichotomic search, finds the position of a specified “key” within a sorted list/array using the divide and conquer approach.

At each stage, the algorithm compares the input key value with the key value of the middle element of the array. If the keys match, then a matching element has been found so its index, or position, is returned. Otherwise, if the sought key is less than the middle element’s key, then the algorithm repeats its action on the sub-array to the left of the middle element or, if the input key is greater, on the sub-array to the right. If the remaining array to be searched is reduced to zero, then the key cannot be found in the array and a special indication is returned, saying that the key was not found.

Searching Algorithms – Part 1

Thu, 10 Nov 2011 08:21:00 +0000

This is the first part of some searching algorithms that I’m implementing. The algorithms are:

Linear Search
Binary Search
Uniform Binary Search
Fibonacci Search
Jump Search
Interpolation Search
Ternary Search

In this part, Linear Search is discussed.

Linear Search

The linear/sequential search technique is the simplest of all searching algorithms and it involves checking every element, one at a time in sequence, until the desired one is found. This type of search is easy to implement, but practical when the list has few elements or the list is unsorted. The best case is when the first element is the one to be found. The worst case is when the element is not found even after searching through the entire list. Thus, both the worst-case and expected cost is asymptotically O(n). Below are some variations of the Linear Search algorithm:

Project Euler 011

Wed, 09 Nov 2011 13:07:59 +0000

Problem:

In the 20 x 20 grid below, four numbers along a diagonal line have been marked.

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

Project Euler 010

Wed, 02 Nov 2011 12:08:12 +0000

Problem:

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

Find the sum of all the primes below two million.

Solution:

1. Brute-force approach:


class PE010_brute
{
 static boolean isPrime(long n)
 {
 if(n == 2 || n == 3) return true;
	if(n < 2 || (n % 2 == 0)) return false;
 if(n < 9) return true;
 if(n % 3 == 0) return false;

 int r = (int)Math.sqrt(n), f = 5;

 while(f <= r) {
 if ((n % f == 0) || (n % (f + 2) == 0))
 return false;
 f += 6;
 }
 return true;
 }
}

2. Efficient approach (using the Sieve of Eratosthenes) :

Sieve of Eratosthenes

Tue, 01 Nov 2011 20:19:54 +0000

The Sieve of Eratosthenes, named after the Greek mathematician Eratosthenes, is one of many known prime number sieves. The algorithm is a fairly good one for finding prime numbers from a list of numbers, say, less than 10 million.

Suppose we need to find all prime numbers below a natural number n > 1. Then, the algorithm is given as:

Create a list of consecutive integers from 2 to n: (2, 3, 4, …, n).
Initially, let p equal 2, the first prime number.
Starting from p, count up in increments of p, as long as the value is less than √n and mark each of these numbers greater than p itself in the list. These numbers will be 2p, 3p, 4p, etc.; note that some of them may have already been marked.
Find the first number greater than p in the list that is not marked; let p now equal this number (which is the next prime).
If there were no more unmarked numbers in the list, stop. Otherwise, repeat from step 3.

When, the above algorithm terminates, all unmarked numbers are prime.

Project Euler 009

Tue, 01 Nov 2011 12:57:54 +0000

Problem:

A Pythagorean triplet is a set of three natural numbers, a < b < c, for which, a2 + b2 = c2

For example, 32 + 42 = 9 + 16 = 25 = 52.

There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.

Solution:

1. Brute-force approach:


s = 1000
for a in range(3, s) :
 for b in range(a+1, s) :
 c = s-a-b
 if c**2 == a**2 + b**2:
 print a*b*c
 exit

2. Efficient approach:

Project Euler 008

Mon, 31 Oct 2011 23:01:41 +0000

Problem:

Find the greatest product of five consecutive digits in the 1000-digit number.

73167176531330624919225119674426574742355349194934 96983520312774506326239578318016984801869478851843 85861560789112949495459501737958331952853208805511 12540698747158523863050715693290963295227443043557 66896648950445244523161731856403098711121722383113 62229893423380308135336276614282806444486645238749 30358907296290491560440772390713810515859307960866 70172427121883998797908792274921901699720888093776 65727333001053367881220235421809751254540594752243 52584907711670556013604839586446706324415722155397 53697817977846174064955149290862569321978468622482 83972241375657056057490261407972968652414535100474 82166370484403199890008895243450658541227588666881 16427171479924442928230863465674813919123162824586 17866458359124566529476545682848912883142607690042 24219022671055626321111109370544217506941658960408 07198403850962455444362981230987879927244284909188 84580156166097919133875499200524063689912560717606 05886116467109405077541002256983155200055935729725 71636269561882670428252483600823257530420752963450

Solution:


s = \
"73167176531330624919225119674426574742355349194934\
96983520312774506326239578318016984801869478851843\
85861560789112949495459501737958331952853208805511\
12540698747158523863050715693290963295227443043557\
66896648950445244523161731856403098711121722383113\
62229893423380308135336276614282806444486645238749\
30358907296290491560440772390713810515859307960866\
70172427121883998797908792274921901699720888093776\
65727333001053367881220235421809751254540594752243\
52584907711670556013604839586446706324415722155397\
53697817977846174064955149290862569321978468622482\
83972241375657056057490261407972968652414535100474\
82166370484403199890008895243450658541227588666881\
16427171479924442928230863465674813919123162824586\
17866458359124566529476545682848912883142607690042\
24219022671055626321111109370544217506941658960408\
07198403850962455444362981230987879927244284909188\
84580156166097919133875499200524063689912560717606\
05886116467109405077541002256983155200055935729725\
71636269561882670428252483600823257530420752963450"

max = 0
for i in range(0, len(s) - 4) :
 p = 1
 for j in range(i, i+5) :
 p *= int(s[j])
 if p > max:
 max = p

print max

Analysis:

The 1000-digit number is stored as a string in variable s. The backslash ‘\’ at the end of a line implies that the following physical line is actually in the same logical line of code.

Project Euler 007

Mon, 31 Oct 2011 19:31:18 +0000

Problem:

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.

What is the 10,001st prime number?

Solution:

1. Brute-force approach:


from math import sqrt
def is_prime(n) :
 for i in range(2, int(sqrt(n)+1)) :
 if n % i == 0:
 return False
 return True

limit, count, num = 10001, 1, 1
while count < limit:
 num += 2
 if is_prime(num) : count += 1
print num

2. Efficient approach:


from math import sqrt
def is_prime(n) :
 if n == 2 or n == 3: return True
 if n < 2 or n % 2 == 0: return False
 if n % 3 == 0: return False
 if n < 9: return True

 r, f = int(sqrt(n)), 5
 while f <= r:
 if n % f == 0 or n % (f + 2) == 0: return False
 f += 6
 return True

limit, count, num = 10001, 1, 1
while count < limit:
 num += 2
 if is_prime(num) : count += 1
print num

Analysis: