5 ms·
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
by orangethirty 14y ago
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.
- boyter 14y agoI feel I am in the same boat as you. I belive myself to be a very average (possibly less so) developer. Even believing that I cannot understand the amount of crap I have been forced to rewrite because it simply does not work. Just recently a expensive contractor was brought in to write a series of simple CRUD screens using .NET MVC and KendoUI. It appeared to work, but if you even scratched the surface you quickly discovered it was almost totally broken. Further down it consisted of one big class as a service layer, raw SQL rather then LINQ, and a jumble of interdependent hell. I spat the dummy after 5 days of fixing bugs (trying to avoid changing too much) and scrubbed each page one after the over and ended up with something modular which I could actually support. It took me 2 weeks to scrub (80% of the codebase was touched or rewitten) what took this contractor 3 months to write. I am with you. If that's normal (its not the first time this has happened to me) then what sort of dev am I if I know I am not a rockstar?
- orangethirty 14y agoAbsolutely. The parts that really bugs me is when I take on bi challenges. My biggest challenge so far has been building Nuuton. It took me months of thinking and reasoning the data flow and structures. On top of that, I had to pick which language fit the problem, rather which problem fit the language. My original choice was Lisp, because it allowed me to create DSLs. Something that would have really helped in building each individual sub-system. But at the same time, Lisp is not as simple to pick as it should. It has libraries, and an amazing amount of data ready to be researched. Yet, it does not seem (to me) as complete, in terms of libraries and community, as Python. Which was my second choice. Python has all of the libraries I needed. Sure, I had to play by Python's rules, but libraries and frameworks like Django really do save development time. Them, I had to research the options available within Python that would allow for the architecture I had designed. Every sub-system is simply a black box that reads/returns data in a standard format. From the crawlers, to the data store, to the actual web app, everything is simply an API. Ultimately, I chose the Django rest-framework, because it had a lot of features built into it. Thing like authentication, a permissions system, throttling, and so on. Those were things I did not have to write. A simple set of Models/Views and I was off. With Lisp, I would have had to write that, and end up with a code base that would not have been as good as that one. Nuuton is huge, in terms of sub-systems. But small at the same time. Everything is divided neatly, and is very simple to follow. The queue sub-system that handles requests/responses from the crawlers is very simple to follow. Plus you can actually see how the data is collected, cleaned, formatted, analyzed, stored, served, and modified. But I'm not a rockstar, cowboy, or even great. I'm average.But worse is that I have this inherent thought that I will never become any better. Even though years ago I was writing Visual Basic apps (you know the type). This due to how much I struggle. Every day I have to research some class, or some method. Can it do that? What's parameters does it take? Does it fit the design? And sometimes I just write the damn thing and end up throwing it out because I realize it is too complicated. I also understand that I will always struggle. But I will never quit. Do rockstars struggle? Do the people that graduate MIT and go on to work on Google struggle? I don't know. Maybe if they do, they dont struggle as much as me. Guess thats the difference. Average struggles a lot, rockstars not so much. Yet I know thats bullshit. Who am I to question my own insecurities?