The true, actual, measurable productivity comes not from utilizing some advanced tools, but, like everything else in life, from seeing things as they really are and therefore doing the right thing at each level (of abstraction).
Tools give some additional 20%, perhaps, but the main productivity gains are from not wasting time and efforts and just doing the right thing (which is what distinguishes experts and masters).
For CS it means understanding all the deep, underlying principles behind the concepts and abstractions.
For data structures, for example, it is important to understand the shapes (linear sequences, tree-like structures, graphs, table-like, and then vectors, matrices, etc).
At a type-level the generalized notions of sum-, product- and fucntion-types helps, along with the realization that everything can be reduced to merely nesting of these.
Deep learning, which “learns a representation” even more eliminates the imaginary conceptual barrier between the code and the data.
A complex data-structure (a computation graph, similar or an AST) can be “the code”, and it can be “learned” (by successive updates of the parametes by a pack propagation).
The notion of a lexical closure is still at the core of all CS.
So, where is my productivity from knowing all this?
Well, it is, like I said above, in “going straight to the point” and in “doing just the right thing”, which is what a MIT-educated expert programmer would do.
The difference in efficiency, measured in time and money, would be of an order of magnitude, and this is a common sense in The Valley.
Now, the real question is: how do I achieve something similar?
The answer is: this is what so-called classic education (the MIT tradition) is all about. It makes you really, truly and measurably productive by doing the right thing.
There is a quote from Barbara Liskov’s book:
What makes a good programmer? It is a matter of efficiency over the entire production of a program. The key is to reduce wasted effort at each stage. Things that can help include thinking through your implementation before you start coding, coding in a way that eliminates errors before you test, doing rigorous testing so that errors are found early, and paying careful attention to modularity so that when errors are discovered, they can be corrected with minimal impact on the program as a whole.
This is a description of productivity. Notice that the tools are implied and are, indeed, necessary, but by no means sufficient.
So, the longer answer to the “how do I” question is this: “try to climb on the shoulders of the titans by reading nothing but the best books and the best code”. Avoid social media, avoid the “experts” and moderns commercial crappy books, which only optimized for sales.
There is a hack for you. Almost everything published by the Prentice Hall before 2000s, especially the C.A.R Hoare series are the only stuff worth reading. The early MIT Press has the same quality of selection. Then comes the O’Reilly Media which began as a publisher of technical books for nerds.
Why these books are good and will make you productive? Because the very best ones are about explaining the underlying principles behind irrelevant particulars, which is the essence of the MIT tradition (along with extracting of these principles form biology).
So, Knowledge Is Power. And the real, actual, true driver of productivity.
It also gives one the ability to call bullshit (and to prune the whole trees of it) and to backtrack to sanity among other things.
Example.
The deep insight into the universal principles which underlie whole CS is that using names (symbolic references) makes an implicit actual ordering irrelevant.
This “works” not just in selecting individual fields instead of SELECT * FROM, which will fuck you up once a new column would be added, but everywhere.
A C struct is usually accessed by references together with a symbol of a slot, all the members of a C++ class are accessed “by name”, etc, etc.
The principle is this: “Once we have a discipline of accessing the elements of /any structured value “by name”, the actual implicit ordering of the elements in a representation becomes immaterial”. Ok, now what?
This implies that we can build up any kind of a structure partially, in a series of steps, without even wasting our time thinking about what the final result will look like.
Adding a “user_name” and the logic (code and the tests) related to it does not affect any other code and tests, or even the other slots.
This is the orthogonality principle, which have all the kind of immediate consequences.
Knowing and practicing this one could proceed way faster, without sacrificing quality of the code.
This, of course, applies to a structured documents as well.
This principle is so universal (it can be traced to the foundation of the Set Theory) that it applies to any Algebraic Data Type, either a “sum” (|) or a “product” (,).
The a-ha moment
It is just partitioning – every , has an implicit | within the whole.