* STL data structures
* inheritance, overriding
* big 4
* pointers and references
java GC is an example of “low-complexity domain”. Isolated knowledge pearls. (Complexity would be high if you delve into the implementation.)
- FIX? slightly more complex when you need to debug source code. java GC has no “source code” for us.
- tibrv set-up
- socket programming? relatively small number of variations and combinations.
- stateless feed parser against an exchange spec. Can become more complex when the code size increases.
With a transparent language, I am very likely (high correlation) to have higher GTD/productivity/KPI.
Bootstrap — with a transparent language, I’m confident to download an open source project and hack it (Moodle …). With an opaque language like C++, I can download, make and run it fine, but to make changes I often face the opacity challenge. Other developers are often more competent at this juncture.
Learning — The opaque parts of a language requires longer and more “tough” learning, but sometimes low market value or low market depth.
Competitiveness — I usually score higher percentiles in IV, and lower percentiles in GTD. The “
percentile spread” is wider and worse with opaque languages. Therefore, I feel 滥竽充数 more often
In this context, transparency is defined as the extent to which you can use __instrumentation__ (like debugger or print) to understand what’s going on.
- The larger systems tend to use the advanced language features, which are less transparent.
- The more low-level, the less transparent.
–Most of the items below are “languages” capable of expressing some complexity:
- [T] stored proc unless complex ones, which are uncommon
- [T] java threading is transparent to me, but not other developers
- [S] java reflection-based big systems
- [T] regular c++, c# and java apps
- [O]… but consider java dynamic proxy, which is used in virtually every non-trivial package
- [T] most python scripts
- [S] … but look at python import and other hacks. Import is required in large python systems.
- [O] quartz
- [S] Spring underlying code base. I initially thought it was transparent. Transparent to Piroz
- [O] Swing visual components
- [O] C# WCF, remoting
- [T] VBA in Excel
- —-below are not “languages” even in the generalized sense
- [S] git .. semi-transparency became stressor cos KPI!
- [O] java GC … but NO STRESS cos so far this is not a KPI
- [O] MOM low level interface
- [S] memory leak detectors in java, c#, c++
- [O] protobuf. I think the java binding uses proxies
- [T] XML + simple SAX/DOM
- [S =semi-transparent]
- [O =opaque]
This topic is Rather important to my stress level, my available time for learning, my available time for family….
For example, with Quartz, I must ask around and experiment (millions of times). Slow to build a coherent understanding. Slow ramp-up. (In contrast, with Python I could do that by reading good articles online.) So my productivity lag/gap remains even after a few years.
Other Negative examples – Tibrv, Autosys, Accurev, Less-known boost libraries,..
MSVS? Most of the search results are about c#, so it’s somewhat harder to solve problems.
Eclipse CDT? Most of the search results are about Eclipse java.
Positive examples – vbscript, DOS batch,
Background: the constant need to economize on my learning hours. Have to attempt to pick the survivors
FIX as a tech skill is an example of unexpected resilience. (However, this is in a specialized domain, so competition is arguably lower.)
- SQL, in the face of noSQL challengers.
- XML, in the face of light-weight serialization protocols – json, protobuf
- Bourne shell, in the face of python, perl…
- php, mysql, in the face of newer challengers
- STL, invented in the 80’s (??) with many limitations, challenged repeatedly
- tibrv, challenged by 29west, solace,
I have a bias towards older technologies. They have
stood the test of time.
- std::string (more useful than cStr)
- vector (more useful than array) sorted data structure (i.e. stl map), unordered_map
- Node class used in a linked graph
- dtor, copier, op=
- ref only as function I/O
- iterator – basic usage
- double pointer
- stack, queue
- pointer arithmetic
- local static
stl algo? Only Citadel array-shrink
no pointer to function
no (very, very seldom) threading in coding Q
adv: circular buffer
These java features are powerful and practical at work, but seldom asked in IV, so ROTI is lower during job hunting.
annotations for code generation
I have seen both, and tried both.
minority of developers spend the time studying and understanding the important details of threading, generics, templates … before writing code.
Majority of developers don’t have the time, vision or patience, and only learn the minimum to get the (sloppy) job done. They copy-paste sample code and rely on testing, but the test cases are limited to realistic UAT test cases and will not cover edge cases that have yet to occur. For concurrency designs, such tests are not good enough.
AA is often seen as unnecessary except:
* Interviewers often go in-depth
* In a product vendor rather than an in-house application team
* If requirement is unusual (eg: B2BTradingEngine), then BB won’t even pass basic developer self-tests. Sample code may not be available — see my post http://wp.me/p74oew-1oI. So developers must bite the bullet and take AA approach. This is my sweet spot. See
On Wall St projects, I learned to abandon AA and adopt BB.
On Wall St interviews, I still adopt AA.
On West Coast, I think AA is more needed.
#1 java — the ecosystem
#2 c/c++ — not yet my chosen direction
#3 dotnet including c#, WCF, remoting, windows debugging …
#4 py — purely automation in most places(easy instrumentation); advanced py systems in a few places
# unix power user tools – including scripting, instrumentation… More widespread but depth is seldom required compared to SQL and python. More well-defined as a tech skill than windows dev.
# SQL/stored proc — losing pole position in low latency and big data environments, still dominant in traditional apps
# Excel add-in and automation