Software development is not coding

Software developers who wish to stay relevant must learn how to use so-called artificial intelligence, “A.I.” Or even if they learn how to use A.I. they might get replaced anyway. That’s how the thinking goes. So there’s the risk that human software developers are going to get replaced even though A.I. is actually not all that good at developing software. And it’s already happening with junior-level developers.

I think this misconception that A.I. can do software development got started in part because of misleading terminology. The term “coding” to mean software development has quickly become entrenched. This has far more serious consequences than other misleading terms. I doubt anyone will lose a job over how angled horns are called English horns, for example.

Actual coding is simply the conversion of a symbol to another symbol. The letter S, for example, is a symbol. To convert it to Morse code, you convert it to the symbol of three dots. The symbols can be very arbitrary, as a comparison of the original Morse code to modern Morse code will show.

Computers are very good at coding, and with advances in telecommunications, e-mail has put telegraph operators out of work.

If you want to, you can have one computer convert all of the Shakespeare sonnets to some encoding, send that to another computer and have that other computer decode the sonnets and print them out.

But to ask either of those computers to write even just one new sonnet is a very different proposition.

Writing a new program is more like writing a new sonnet than it is like encoding and decoding existing sonnets. If the program already exists, a computer can encode it or decode it faster than any man can. But if the program doesn’t already exist, a computer can only create it by trying to piece it together from existing programs.

In software development, there is something called an “operation code,” or opcode for short. An opcode tells a computer chip, physical or virtual, to carry out one very small action. These actions are very tiny.

If you have never tried to program a chip directly, you probably have no idea how tiny I’m talking about. The person who came up with the idiotic thought exercise “tell a robot how to make your favorite pizza” certainly doesn’t have a clue.

Here’s one that you might actually have to solve in a real computer programming course: How do you tell a computer to pick out the prime numbers between 1 and 100? Sounds easy enough, but programming it for a chip directly is not straightforward. With a programming language like Python or Scala, you can write something simple like

(1 to 100).filter(isPrime)

which a special program called a compiler can turn into the dozens of tiny instructions needed for your computer to actually perform this task.

This is provided of course that the Boolean function for the filter is defined in the standard library, in an imported library or somewhere in the project (I have a Scastie snippet to illustrate). Maybe you don’t know how to write that, but as a person who speaks and writes English, you should recognize the Scala line shown here as a program to filter a range of integers according to each integer being a prime number or not.

We could also do something like

val primesList = java.util.ArrayList[Int]
for (n ← 1 to 100) if (isPrime(n)) primesList add n

but we don’t get any points for efficiency or elegance (plus the Scala compiler would have a couple of issues with this, as this other Scastie snippet shows). But even that inefficient version saves you from having to figure out the hundreds of tiny actions a computer would have to take to actually execute this program.

Thus far I have not shown you any opcodes. And in the Scala excerpt I didn’t even use any of Scala’s reserved words. Consider something even simpler: How do you directly tell a computer to count from 1 to 100? No filtering, just count 1, 2, 3, 4, 5, …, 99, 100.

That will depend on which kind of computer we’re talking about. In the case of a computer with the Intel 8086 processor, that might go something like this:

1. Push 100 into register BX
2. Push 1 into register AX
3. If registers AX and BX are equal, jump to line 6
4. Increment register AX by 1
5. Jump to line 3
6. Exit subroutine

Using opcode mnemonics, it might go something like this:

1: push bx, 100
2: push ax, 1
3: jcmp ax, bx, 6
4: inc ax
5: goto 3
6: return

I don’t know what the opcode is to push a number into register BX. Probably not the same as the opcode to push a number into register AX. But thanks to opcode mnemonics, I don’t have to know the opcodes. There’s a special program that will map these opcode mnemonics to the appropriate opcodes, provided I have correctly used the opcode mnemonics it recognizes.

This is not how a human mind goes about counting from 1 to 100. Nor is it how you’d go about programming it for the Motorola 68000, but it is very similar. The Java Virtual Machine (JVM) doesn’t have registers, but the concept of the program would still be more similar to the Intel 8086 program than it is to how a person would do it.

Since there’s no output to this program, you just have to take my word for it that it runs correctly. Just to make this program output the number in the AX register to the console at each iteration would greatly complicate it. And also it would make it a lot more dependent on the hardware and the operating system.

With programming languages like Java, we don’t have to worry about such details. So I will now use Java to demonstrate a count from 1 to 100 program that “prints” out the numbers as it counts.

Java gets a lot of flak for being verbose, but the count 1 to 100 program in Java is still much more concise than it would be in opcode mnemonics for the JVM. And a lot easier for a human to understand.

public class Count1To100 {

   public static void main(String[] args) {
       for (int i = 1; i < 101; i++) {
           System.out.println(i);
       }
   }

}

I hand it over to the Java compiler, it compiles and I verify it produces the desired output.

C:\Users\AL\Documents\Temp>java Count1To100
1
2
3
4
5
6
7

and so on and so forth. 

Look at the count 1 to 100 program compiled for the JVM.

����␀␀␀A␀␜␊␀␂␀␃␇␀␄␌␀␅␀␆␁␀␐java/lang/Object␁␀␆␁␀␃()V␉␀␈␀␉␇␀␊␌␀␋␀␌␁␀␐java/lang/System␁␀␃out␁␀␕Ljava/io/PrintStream;␊␀␎␀␏␇␀␐␌␀␑␀␒␁␀␓java/io/PrintStream␁␀␇println␁␀␄(I)V␇␀␔␁␀␋Count1To100␁␀␄Code␁␀␏LineNumberTable␁␀␄main␁␀␖([Ljava/lang/String;)V␁␀␍StackMapTable␁␀␊SourceFile␁␀␐Count1To100.java␀!␀␓␀␂␀␀␀␀␀␂␀␁␀␅␀␆␀␁␀␕␀␀␀␝␀␁␀␁␀␀␀␅*�␀␁�␀␀␀␁␀␖␀␀␀␆␀␁␀␀␀␁␀␉␀␗␀␘␀␁␀␕␀␀␀I␀␂␀␂␀␀␀␖␄<␛␐e�␀␐�␀␇␛�␀␍�␁␁���␀␀␀␂␀␖␀␀␀␒␀␄␀␀␀␄␀␈␀␅␀␏␀␄␀␕␀␇␀␙␀␀␀␉␀␂�␀␂␁�␀␒␀␁␀␚␀␀␀␂␀␛

Aside from a few words in English, it’s incomprehensible gibberish to you and me. The Java Development Kit provides a tool that allows us to look at this program in a more comprehensible manner, using JVM opcode mnemonics.

Compiled from "Count1To100.java"

public class Count1To100 {

 public Count1To100();
   Code:
      0: aload_0
      1: invokespecial #1 // Method java/lang/Object."":()V
      4: return

 public static void main(java.lang.String[]);
   Code:
      0: iconst_1
      1: istore_1
      2: iload_1
      3: bipush        101
      5: if_icmpge     21
      8: getstatic     #7 // Field java/lang/System.out:Ljava/io/PrintStream;
     11: iload_1
     12: invokevirtual #13 // Method java/io/PrintStream.println:(I)V
     15: iinc          1, 1
     18: goto          2
     21: return

}

Let’s try an easier one, the classic Hello World in Java.

public class HelloWorld {

   public static void main(String[] args) {
       System.out.println("Hello, world!");
   }

}

It should compile to

����␀␀␀A␀␝␊␀␂␀␃␇␀␄␌␀␅␀␆␁␀␐java/lang/Object␁␀␆␁␀␃()V␉␀␈␀␉␇␀␊␌␀␋␀␌␁␀␐java/lang/System␁␀␃out␁␀␕Ljava/io/PrintStream;␈␀␎␁␀␍Hello, world!␊␀␐␀␑␇␀␒␌␀␓␀␔␁␀␓java/io/PrintStream␁␀␇println␁␀␕(Ljava/lang/String;)V␇␀␖␁␀␊HelloWorld␁␀␄Code␁␀␏LineNumberTable␁␀␄main␁␀␖([Ljava/lang/String;)V␁␀␊SourceFile␁␀␏HelloWorld.java␀!␀␕␀␂␀␀␀␀␀␂␀␁␀␅␀␆␀␁␀␗␀␀␀␝␀␁␀␁␀␀␀␅*�␀␁�␀␀␀␁␀␘␀␀␀␆␀␁␀␀␀␁␀␉␀␙␀␚␀␁␀␗␀␀␀%␀␂␀␁␀␀␀␉�␀␇␒␍�␀␏�␀␀␀␁␀␘␀␀␀␊␀␂␀␀␀␄␀␈␀␅␀␁␀␛␀␀␀␂␀␜

Recognize anything from the previous one? Recognize anything unique to Hello World?

I suppose it is theoretically possible for me to compile my own Java program. I just need to carefully consult Chapter 6 of the JVM manual for each opcode. Might take me a few weeks.

As long as I write a valid Java program, the Java compiler can convert it to the appropriate JVM bytecode way faster than I ever could. The compiler does the coding. I do the programming.

ChatGPT can certainly write simple Java programs for you like Hello World and count 1 to 100. It can even do more sophisticated programs like Tic-Tac-Toe and maybe even checkers. If ChatGPT screws  that up, it doesn’t hurt anyone.

But something that thousands of people are going to rely on? Like, for example, the back end of the content management system for a politics blog? I don’t think Markos Moulitsas would trust ChatGPT to do that.