Coding is the hardest thing in the world, or rather, that's what we'll tell you as coders, if you're not initiated. It requires extensive knowledge of complex mathematical formulae, impeccable memory of syntax and semantics, and of course the reasoning abilities of an Ancient Greek philosopher. The reality however, is that whilst this might be true sometimes, it definitely isn't true most of the time! Like the magic circle exposés, I'm going to share with you 5 dirty little secrets that we coders probably don't want you to know. Any coder who claims not to do the below at least sometimes is either lying or hasn't graduated yet; be wary of both.
1. We don't solve all problems through advanced logic with our superior intellects.
Once upon a time, before the Internet, when a coder encountered a difficult problem they could turn to their colleagues and if they were lucky someone had encountered the problem before, but most likely they'd be stuck traipsing through programming manuals and debug logs trying to find a solution. Thus a programmer over a life-time, would develop a super-superior problem solving ability.
Nowadays however, when we come across a problem, we usually just type it into Google and 99% of the time, someone else has had the same problem, posted it on stack overflow and the solution is now documented online. So good is the online knowledge bank that it is generally the most efficient use of our time, and our overwhelming sense of reason repels us from spending 20 minutes solving a problem when we can get the answers in 5 from the Internet.
2. We're not really fluent in all those Programming Languages.
Ok, so somewhere out there in the wild, there still exist some coders who are truly fluent in a programming language. They know the syntax and semantics off by heart, the performance of each operator, the memory footprint of each variable and the best use cases for every design patterns. They are, however, a dying breed. Heck, not even the coders who attend hackathons may know their game 100%. These days, most developers (myself included), do not go so deep because we drift from language to language based on the needs of the current project or just a simple whim to learn the latest craze.
3. We rarely write 1000s of lines of code.
Programmers love keyboard shortcuts, they are quick and you can get stuff done quicker than with a mouse. The most important of these is Cmd-C, Cmd-V, you may know it as Copy and Paste. I honestly don't write code if I can avoid it. I tend to copy and paste from stuff I've previously written. I don't even like to rewrite the names of variables as I know if I copy and paste it from where it is defined then chance of misspelling is zero.
Us C&P Coders thus become quicker the larger our code base is, because we have loads of existing code samples, we can copy and paste different sections and solutions from each, coding to plug the gaps and weld them together. The very organised among us, will structure this frequent code into reusable modules, boilerplate code or libraries but truthfully most of the time we're too lazy (read busy) to do even that.
4. We plagiarise, a lot!
When I was at university, I wrote everything from scratch, I would not even copy a single line of code from a tutorial. I made sure I understood the underlying logic and I wrote my own implementations. This is textbook 'proper' programming and the benefit of it is that it made me a better coder and gave me a strong understanding of what I was developing but in the short term it also made me slow.
Fast forward ten years and I simply don't have the time to be that slow, the time to completely understand EVERYTHING. In the fast pace world of start-ups, digital agencies and indie-games studios, speed is everything. Modern coding is often more about piecing together stuff that other people have written and only doing something from scratch if you have to. It is technically not plagiarism as it is either open source libraries or examples on blogs and stack overflow, but most applications from tech start-ups would probably fail a CS examiner's critique for lack of original content.
5. We don't like working with others' code.
In a confusing contradiction to the previous point, we don't actually like working with other people's code. We would if time were no option, prefer to write everything ourselves.
In the ideal world, all code is preceded by intricate UML diagrams and proceeded with detailed documentation. In reality, sadly, we often just keep most of this in our head. We have ideas of what we're trying to do and how we're going about doing it, combined with a number of undocumented (temporary) hacks that only we understand, we are able to create fast functional code. The problem arises when we disappear and someone else inherits our code. That's why you should be careful when hiring inexperienced freelancers or when outsourcing your work.
Trying to understand someone else's code is more akin to psychiatry than reading - what on earth were they possibly thinking when they did that that way! It follows that, most developers dislike others developers' code, so when we say someone else's code is good what we most often mean is that they think and code in a style similar to our own.
These are a few insights into the secret lives of coders. There are plenty of other dirty secrets to be told but as all good coders do, I like to do things in iterations. If this post proves popular, I'll do a part 2, so do share your favourite dirty little secrets with me for inclusion.