[)roi(];18504414 said:
I'm not sure if you read the Functional Programming articles I've started posting -- more specifically the part where I mention the distinction between Easy and Simple. Basically Theory or Programming is NOT Simple, but it certainly (over time) becomes easy; exactly as you implied with acquiring another language.
However whilst we may consider this an easy task (re our experience) -- if you think back the move from language 1 to language 2 was probably one of the first difficult hurdles that we had to overcome as an intermediate programmer. Similarly learning algorithms, paradigms, advanced type theory, ... yet even these overtime, similar to learning another language...becomes a lot easier to acquire, like the next language. I think that's the sentiment that Russ tried to convey in his blog post with:
The point being that these are not inherent traits; they can be easily taught and / or acquired when needed.
You and Russ seem to have a fairly simplistic perception of this "theory". Someone who is good at this isn't simply someone who can be taught something like an AVL tree algorithm, it is someone who can create such an algorithm on their own.
The very real scenarios that people at this level encounter on a daily basis, are things like: I need an algorithm/datastructure with an O(logn) search and O(logn) insert and delete, however:
- searches are far more common than insertions or deletions,
Or
- the the probability that a search key will be used increases if it was used recently
Or
- the the probability that a search key will be used decreases if it was used recently
Or
- the tree needs to be accessible to hardware, so is in uncached memory
Or
- the tree can be altered by another thread
How would I alter the algorithm to exploit the above knowledge and improve efficiency?
Or the question could be:
- how do I efficiently compute a distributed covariance matrix from a multi-petabyte design matrix on heterogenous hardware?
Or:
- how do I efficiently sort the transparent fragments of 3D model during render in order to get correct transparency?
Or:
- how do I quickly determine if one 3D model is roughly a translation, scale and/or rotation of another (or any combination thereof)
Or:
- how do I compute the 3D mesh resulting from the intersection of two meshes? What if it's a tetrahedral volume mesh?
Point being, these aren't things that you rote learn from textbooks or get Russ to teach you. If you're lucky you may be able to find a paper on something similar, however, case specific variations in the problem tend to provide a massive opportunity to develop a custom algorithm that just works much better. People who have this ability are who we look to hire.