What programming skills have provided you the best return on investment? [closed]

Question

What are the things that took you only a little time to learn, but had a big payoff? And how long did it take to learn enough before the they began to pay off?

For instance, I’m not a master of regular expressions, but it probably took a couple of hours to understand the basics enough for to start using them and they come in handy on a regular basis.

Answer 1

The Discipline of Finishing. Like many software engineers, I have a tendency to accumulate projects until I am contributing so little to each one that none of them makes meaningful progress. Couple that with a classic ENTP personality type, and you get a busy, interested and ultimately unproductive programmer.

Over the years, I have learned and practiced The Discipline of Finishing. It allows me to subjugate my tendency to move from one thing to another, from the brand new and cool language to the latest hot web framework, from this shiny bauble to that shiny bauble into actually meeting my commitments, finishing my projects and shipping them.

And oh is it a great feeling to ship.

Answer 2

For me it would be the art of googling. You can find an answer to almost any issue provided you properly word your queries. And yes, asking a community without having even tried to search the web first is a strategy from the Jurassic period.

Answer 3

Just in case this gets left out...

UNIX tools such as bash, grep, find, tail, awk, sed, ..., curl, ssh, ... ok you get the idea.

You can learn them as you need them. You can do incredible things with them when you plug them together. You can automate a lot of repetitive work with these. You can save a LOT of time. Loads of tools, freely available, maintained by people who really care, easy to install.

I'm still learning. Just now I needed to convert some gif files to png: sudo apt-get install gif2png ; gif2png -O *

Answer 4

For me, it has been by far Functional Programming.

Once you learn what it is and how to do it, you see it eveywhere. The function style, when used appropriately, can leads to much simpler solutions than imperative counter parts and can be an excellent tool in your tool belt when stuck.

Learning functional programming is probably a bit trickier than say, Regular Expressions, because functional programming isn't about a programming language it is about a mindset. Particularly, avoiding mutation, emphasis on data transformation, etc. However, you can pick it up pretty easily if you use it consistently. I would recommend starting at Project Euler

Also, shameless plug here, learning functional programming doesn't just mean that you have to learn a language that won't benefit your day job. If you are a .NET developer, F# provides an excellent way to get started with functional programming.

Answer 5

Reading and understanding others code. It didn't take small time though, but it was one of the best time investments.

Answer 6

Not directly a programming skill (but then nor are many of the others in the list) but decent communication skills.

While they come more easily to some than others they are absolutely something you can learn and do so in a relatively short space of time (start with presentation skills which are straight forward and the principals are applicable to far more than just formal situations, and assertiveness which I was interested to find out isn't just about shouting and being forceful, it's closer to the opposite).

I'm not the most knowledgeable, I'm not the smartest, but I can explain what I think and why I think it's right and important in a way which non-programmers can understand.

Financially that's been worth more to me than any specific technical skill (and thinking about it has probably resulted in a greater overall level of happiness / satisfaction as if you can clearly express yourself you're far more likely to get your own way, or at least be content that if you're not getting your own way it's not because you were misunderstood).

Answer 7

KEYBOARD SHORTCUTS

You spend all day in your IDE/Text Editor. Memorizing the keyboard shortcuts takes an hour, getting used to them takes a day, and they can save you HUGE amounts of time, a little bit at a time, for the rest of the life of that IDE/Editor.

Answer 8

Test-driven development.

What a great thing for refactoring, performance optimization, diagnosis, debugging.

The best is this.

Write some tests. This can be hard, depending on the overall requirements. But it's far easier than writing the final application.

Hack code until the tests pass. This can be so much easier when there's a focus of just a bunch of tests which are failing. When other "clever" or "good" ideas arise, they can be set aside in "TODO" comments while the main deliverable functionality gets completed.

A review of the TODO's may reveal some things which should have been in the tests to begin with. Things which were overlooked when creating the initial test cases.

Write more tests and repeat the loop of coding until the tests pass.

And the cleanup/simplification/refactoring pass is so much more fun when there is a set of tests that proves that the removed code really was useless.

Answer 9

Design Patterns

Hands down, I came relatively late into design patterns a few years ago but it's been one of the most major influences on my programming. Design Patterns starts to "re-train" your brain to see what different design patterns can be applied to a problem. The more fluent you become in them the easier it gets. It's a real paradigm shift and design patterns is one of the few subjects I think should be mandatory in any programmer's education.

It's equally important to know anti-patterns. Knowing and recognizing them is important to eliminate common mistakes and redudancies in your code and projects

Answer 10

Regular Expressions

Comes in handy in so many places.

Answer 11

Mastering a text editor. How curious nobody told that…

Answer 12

Proper (and Verbose) Naming Conventions

It is so much easier to write and return to code when you follow a a strict naming convention. This not only references CamelCase vs delimited_convention, but is also many other things.

ie:

$is_valid = true
$valid = true;

In this case, one might have no clue what $valid contains later in the code. Is it a boolean? An array of valid strings? Who knows

$is_valid is better as it denotes that this is likely a boolean expression. An even better convention is denoting your variable type and scope in their name.

ie:

$fb_valid = true;

Where f denotes a function scope variable, and b denotes a boolean type.

Admittedly this is overkill, but it makes code so much easier to read and understand no matter where you jump into it. You do not have to find the variable declaration to see if you are using it correctly.

Answer 13

Saying no.

We programmers tend to get excited when faced with potential fun challenges. In fact, there are more of them than we could ever possibly get to.

If we try to tackle all of them, we'll finish none of them.

Answer 14

Good knowledge of the version control software you are using can save a lot of time and effort.

Answer 15

Analysis of algorithms.

It's pretty safe to say I'd probably never finish learning all of it, but whatever I have learnt in the last 4 years has helped me develop software that actually works.

Answer 16

Liberal use of asserts and using an alwaysAssert() function to leave the ones that have negligible impact on performance on in release mode. This massively improved my productivity because:

1. I now have sanity checks that run every time my code runs, with real inputs, not just the cases I thought to test.

2. If anything is amiss, my code fails fast, close to the root of the bug, not slowly, due to the secondary or tertiary effects of the bug.

3. Let's face it, some code is just hard to unit test, and the tests never get written. If you don't have tests per se, sanity checks are the next best thing.

4. Asserts can be written as you go along, without disrupting your mental flow, rather than having to be added as a separate step.

5. Using asserts adds compiler/interpreter checked documentation of assumptions that would otherwise be implicit.

I can't really say how long it took me to learn to use asserts. I gradually came to like them by reading Walter Bright's code. Walter Bright loves asserts and made assert ultra-powerful in D, and D has since become my favorite language.

Answer 17

Adapting a good and consistent coding style

Without it it'd be impossible to code anything larger than a few hundred lines of code.

Answer 18

1. Understanding the problem on paper before realizing its solution in code.
2. Discussing the problem (and its potential solution) with other human beings before realizing its solution in code.

(Yes, these are programming skills.)

Answer 19

As far as purely programming skills go, jQuery has been very kind to me and opened its helping doors to me in a matter of minutes.

Answer 20

These aren't very rock'n'roll and a bit boring and traditional, but: truth tables, design by contract and highest on the list, YAGNI.

Answer 21

What programming skills have provided you the best ROI?

The same ones that are hardest to share with my teammates.

Random-pausing as a performance tuning technique. It is extremely easy to learn. The first time I remember using it is around 1978, when I was debugging some communication software in ASM for a "mini-computer". It just seemed like the natural thing to do. The computer's "halt" button was right on the front panel, asking to be pressed. I can't understand why it is not better known. What we have instead is a whole mythology.

Dynamic Dialogs as a desktop-UI coding technique. I stumbled on this around 1985, and it took about a year to work the bugs out. It allows complex dynamically changing dialogs to be coded, and even simple ones can be done in about an order of magnitude less code. It does it by taking off the programmer's hands the job of incrementally changing the display.

Answer 22

The Big O [e.g. O(lg(n))] notation.

Really helps you figure out which data structures you have to use.

Answer 23

Two things:

1. Learn to type. And learn hotkeys while you're at it. Unplug the darn mouse and learn to completely drive a computer with a keyboard. You'll be WAY faster in time.

2. Psuedo-coding before real-coding. Here's how it works. Let's say I'm going to write a function. The first thing I do is write out the pseudo code:

.

def someFunc(x, y):
   # Verify that x and y are correct
   # Transform x
   # Notify master service of transformation
   # Apply transform to y
   # Send message to user
   # Return new value

Then, I flesh out the implementation. And, most importantly, I preserve the pseudo code. The result is a well-documented function!

def someFunc(x, y):
   # Verify that x and y are correct
   ...

   # Transform x
   ...

   # Notify master service of transformation
   ...

   # Apply transform to y
   ...

   # Send message to user
   ...

   # Return new value
   ...

Answer 24

Java 5 Executors. Took me couple of days to learn but helped in lot of scenarios

Answer 25

Refactoring without fear, including "coding-in-reverse", where your net daily LOC is negative. Fewer lines, but well structured ones improve maintainability, velocity and longevity for the software and help you and your team meet the ever-changing needs of the business.

TDD, version control repositories, and responsive rollback (if needed) serve to reduce this fear.

Answer 26

Design Patterns

I just started work and they've been invaluable to me since they allow you to specify high-level constructs and be reasonably confident that you can fill in the blanks when going to implement without having to re-architect the entire app for each bug fix.

Answer 27

Design Skills

People respond to good design, even if objectively they know better. You might have a good product. If your good product also looks and feels nice, you have a great product.

Answer 28

The most recent one that I can recall is LINQ. Spent about a week studying it, can't say that I know enough now, but it really boosted my productivity. A pity I didn't learn it earlier.

Answer 29

Approach salary negotiations like a programming problem.

Answer 30

I agree with regular expressions.

Some of you are going to hate this, but SQL is another one. You can do some nifty things with it. It may not always be the best answer, but when you are using a relational database, strong SQL skills can help you 1) write better SQL, and 2) give you more options in partitioning logic. I'm not saying to put gnarled SQL in place everywhere, but there are times when a grouping, aggregation, built-in analysis functions, or common table expressions can save you time and energy in getting data set up so the client can use it more efficiently.

Finally, business analysis. Although some would not consider this a programming skill, it goes hand-in-hand with problem solving which is a programming skill. Several times in my career, asking the right questions in the analysis phase saves needless complication and coding. Less code is better.