There are no 10x developers, but there are 1/10 ones

Indeed. I settle for nothing less than the 0x10x programmers.

I can believe 10x. Though, when people start throwing around numbers like, "A great developer is literally 1,000x more productive than an average developer!" I raise an eyebrow.

I'm not a 10x programmer. Probably will never be. I do know of programmers who not only are slower in shipping, but are very bad at designing coherent programs and data structures. That's my main observation. It's not that I'm X times better, its that they are X times slower and make poor design choices. Why? My experience has shown that this tends to happen with people who stop keeping up to date and stop learning.

Let's take my current job, for example. I'm working with a Python program designed to interact with 2 other programs. It is a middleman. The input comes in as text files, and the output goes out as text from a SQL query. The two programmers who built the system I'm working with (one from IBM, another from NASA, believe or not) had never heard of XML, or JSON. Every data structure inside the system is handled by reading and slicing around the contents of the text files. Slow, error prone, and tedious. My first step was to clean this up. I now have a small script that takes the input data text file and turns it into JSON. Since this data comes from an outside vendor, I don't get to pick the format (though I'm developing an API to handle this). After cleaning the data and saving it as JSON, I then simply load up the JSON file into memory and go through the program flow without issues. I removed the size of the program to about 25% of its original size. Plus its way, way faster. I also removed a bunch of database queries that simply did nothing. Was even able to add logging to the program.

Anyhow, the crazy part about it is that the actual code was worse. For those who know Python, using global variables for everything is considered pretty bad form. Here is an example that mimics the code base I inherited:

    #they called lists arrays
    an_array = []
    def foo(array):
    global bar, global hello, global hi
    if bar  1:
        print "something"
        array[0] = hi

Yeah. But wait, there's more. There is a web app written in (what else) flat PHP. It handles very critical information, and is plagued with:

    $foo = $_GET['foo'];
    sql = "INSERT INTO TABLE.NAME VALUE($foo)"; //not actual SQL 

They never clean, or sanitize the data. They don't even check if the GET array is empty.

It is obvious these two programmers stopped learning. They simply fell into what I call a learning slump. Where all new data simply goes out the moment it goes in.

    #Like so
    def new_data(data):
        return data

    #Instead of
    def new_data(data):
        #process data
        #insert data into database
        

Yet, I don't want to call myself better, because most people here are better than me. Yet this leaves me with quite a strange view of everything. I'm not a great programmer, but I'm not as bad as those guys who worked at some big name place. Where does that leave me? Who knows.

All the articles about "10x" developers, "1/10" developers, or "super" developers have not taught me anything about how to improve my skills, or a team's skills. Even the articles that promote the "10,000 hours" or "Just F'ing Do It" mantra feel like proselytizing without practical, or proven, methodologies.

My wife worked with a guy who closed a ticket about closing tickets. If you're measured purely on the basis of number of tickets closed, you can game the system. Replaced users mouse, ticket closed. Or, upgraded network software on 300 machines, ticket closed. If someone is doing twice as many tickets as the next guy, I'd assume he is doing a lot of BS work, not that he's twice as fast.