I tend to forget these title exists!
No need to review content … can review frequently because usually light-weight, light absorbency, less of a chore.
For a static STL container, the iterator objects can be safely stored and reused.
The dreaded iterator invalidation is a risk only under structural changes.
Many coding interview questions allow me save those iterators and store them in a vector, a hash table … Once we retrieve the iterator, we can visit the next/previous nodes.
I have grown from a sysAdmin to a dev
I have grown from web and scripting pro into a java pro then c++ pro !
Next, I hope to grow my competence with large codebase.
I feel large codebase is the #1 diffentiator separating the wheat from the chaff — “casual” vs hardcore coders.
With a large codebase, I tend to focus on the parts I don’t understand, regardless that’s 20% or 80% of the code I need to read. I can learn to live with that ambiguity. I guess Rahul was good at that.
In a few cases, within 3M I was able to “take up” a sizable brown field codebase and become somewhat productive. As I told Kyle, I don’t need bottom-up in-depth knowledge to be competent.
In terms of count of successes taking up sizable brown-field codebase, I am a seasoned contractor, so I would score more points than a typical VP or an average old timer in a given system.
Overloading is a common design tool in java and other languages, but more controversial in c++. As interviewer, I once asked “justification for using overload as a design tool”. I kinda prefer printInt/printStr/printPtr… rather than overloading on print(). I like explicit type differentiation, similar to [[safe c++]] advice on asEnum()/asString() conversion function.
Beside the key features listed below, the most common j4 is convenience | readability….. a on-technical justification!
— ADL — is a key c++ feature to support smart overload resolution
— TMP — often relies heavily on function overloading
— optional parameter and default arguments — unsupported in java so overloading is the alternative.
— visitor pattern — uses overloading. See https://wordpress.com/post/bintanvictor.wordpress.com/2115
— ctor and operator overloading — no choice. Unable to use differentiated function names
— C language — doesn’t support overloading. In a sense, overloading is non-essential.
Name mangling is a key ABI bridge from c++ to C
–high churn high expectation is worst but I have no experience
–low churn high expectation
–high churn low expectation (low caliber)
–low churn low expectation is ideal
Q: what things can derail my work-till-75 plan. Let’s be open and include realistic and theoretical factors.
Did localSys effort save me? See my rather surgical tabulation analysis of past PIP + survivals
— Macq? I now feel my localSys at Macq was deeper than at Quest or RTS
However, I feel the expectation was too high so in the end I got PIP and felt like damaged good.
I need to challenge that negative impression of the entire episode.
As I get older I believe my brain needs more frequent mini-breaks, but I think sometimes my breaks become distractions. The more treacherous “breaks” tend to be
— sense of urgency — When taking these breaks, A sense of urgency is what I need, but I favor a relaxed sense of urgency.
— focus — frequent mini-breaks should not affect my focus at work. I might need to avoid chitchats.
I think it’s possible to maintain or enhance my focus by taking breaks.
— stay late — Frequent breaks often require longer hours. I should prefer coming early, but in reality I often stay late.
— I also want to avoid long sit-down sessions. The breaks give relief to my eyes, neck, back, shoulder etc.
This ranking was originally compiled for “in-flight edutainment”. Warning — If high churn, low accu, low traction, or short shelf life then the precious absorbency effort is wasted
See also the pastTechBet.xlsx listing 20+ tech topics and comparing their mkt-depth, demand-trend, churn-resistance … My conclusion from that analysis is — any non-trivial effort is either on a niche or a non-growing tech skill, with notable exceptions of coreJava+threading. All mainstream and churn-resistant skills need only trivial effort.
Q: name the most strategic trySomethingNew domains that I have since abandoned, given up, quit. How about the new plan to take on coding drills as a lifelong hobby?
Don’t spend too much time, because the answers are nothing new even though this is a decent question.
—-
BA, project mgr, even mid-level managers in some companies can earn the same 160k salary of a typical “developer” role. For a manager in a finance IT, salary is often higher, but for a statistically meaningful comparison I will use a 160k benchmark. Note in finance IT or tech firms, 160k is not high but on main street many developer positions pay below 160k.
As stated in other blogposts, at the same salary, developers enjoy higher mobility, more choices, higher career security…
In this post we compare c++, python, javascript, c#
[1] https://stackify.com/popular-programming-languages-2018/ explains Java’s popularity
See also body-building impact{c++jobs#^self-xx
IV knowledge Critical mass (eg: in core java self-study) is one of the most effective strategies against technology churn in tech interviews. Once I accumulate the critical mass, I don’t need a full time job to sustain it.
I have reached critical mass with core java IV, core c++ IV, swing IV (no churn) and probably c# IV.
The acid test is job interviews over a number of years.
Q: how strongly is it (i.e. critical mass) related to accumulation?
A: not much AFTER you accumulate the critical mass. With core java I did it through enough interviews and reading.
Q: how strongly is it related to leverage?
A: not much though Critical mass enhances leverage.
Q: why some domains offer no critical mass?
A: some (jxee) interviews topics have limited depth
A: some (TMP, py) interview topics have No pattern I could identify from interview questions.
I ought to admire my peers’ [1] efforts and knowledge (not their STATUS) on :
Even though some of my peers are not the most /accomplished/ , they make a commendable effort. That attitude is admirable.
[1] Many people crossing my path are … not really my peers, esp. those managers in China. Critical thinking required.
I don’t have a more descriptive title..
Comparison with “peers” is really hard to rationalize away.
Now my habit is 80% compare-up; and only 20% of the time we feel fortunate comparing to the wider population.
It’s better to become 20% compare-up.
Reason – Those up-comparisons are usually impractical, irrational and with wrong groups i.e. managers.
Q: given 2 cells in a binary matrix (1=black, 0=white=blocked), check the pair are connected and if yes return the shortest path. There exists a path of length 1 between any 2 cells IFF both are side by side or stack atop.
count paths between 2 bTree nodes #PimcoQ9 Ashish is arguably harder than this problem, but this problem allows moving in four directions.
binary-matrix island count #DeepakM technique is more applicable. A BFT path should work.
https://github.com/tiger40490/repo1/blob/py1/py/grid/classic_connectedPair.py is the implementation, briefly tested.
Popularity — 1000+ likes on Leetcode … possibly popular
Q(Leetcode #128): Given an unsorted array of integers, find the longest consecutive element sequence, in O(N) time. Eg: given [100, 4, 200, 1, 3, 2] return [1,2,3,4]
I call this the zebra problem because every consecutive sequence of int is a black stripe and the gaps between them are white stripes. We want the widest black stripe. Obviously, each stripe has minimum size 1.
https://github.com/tiger40490/repo1/blob/py1/py/array/zebra.py is my O(N) solution, not tested on Leetcode.
========
What’s UnionFind? A reusable technique?
Like inserting interval #merging #80% done, I feel this is a data structure problem,
To keep things simple, i will first run one iteration to remove all duplicate items.
I will use hashtable where key a known item. The value is a pointer to a “segment” object.
A segment stores the min and max values. All integers within [min, max] of the segment are always known-items during my scan of input array.
When a new item is either min-1 or max+1, we expand the segment by adjusting the extremes…
The trick is joining two segments, without link pointers. After joining, we don’t really adjust the min/max fields. We only update the max-length global variable if needed.
To keep the hashtable small, I can optionally delete from it but we don’t want to do a range delete within the loop — O(NN)
http://www.nmsl.cs.ucsb.edu/MulticastSocketsBook/ has zipped sample code showing
mc_addr.sin_port = thePort;
bind(sock, (struct sockaddr *) &mc_addr, sizeof(mc_addr) ) // set the group port, not local port!
—-
mc_req.imr_multiaddr.s_addr = inet_addr(“224.1.2.3”);
setsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP,
(void*) &mc_req, sizeof(mc_req) // set the IP by sending a IGMP join-request
Note setsocopt() actually sends a request!
====That’s for multicast receivers. Multicast senders use a simpler procedure —
mc_addr.sin_addr.s_addr = inet_addr(“224.1.2.3”);
mc_addr.sin_port = htons(thePort);
sendto(sock, send_str, send_len, 0, (struct sockaddr *) &mc_addr, …
## past vindicative specializations is more comprehensive, but in this blogpost I want to start on a clean slate and answer the question —
Q: I have explored far and wide… for new domains, new challenges, so are there any unexpected successes of try-something-new?
| skill | discovered | proven over | %%strength 1-5 | val 4 GTD | val4IV | ||||
| unix shell + unix admin | 2000 Catcha | 2Y | 3 | 4 | 1 | ||||
| ! perl | 2000 Catcha | 3Y | 4 #many years ago | 2 | 1 | ||||
| LAMP+js | 2000 | 1Y | 2 | 0 | 0 | ||||
| ! python #popularity | no surprise | 1Y | 2 #xp@Mac | 2 | 3 | ||||
| ! socket #and tools | 2017 | never | 1 #lowLevel | 3 if relevant | 2 | ||||
| !! threading concept+java impl | 2010 | 4Y | 5 #theoretical | 0 | 5 | ||||
| ! x-lang collections | 2010 | 5Y | 4 #lowLevel+theoretical | 1 | 5 | ||||
| ! x-lang OO | 2010 | NA | 4 #lowLevel | 0 | 4 | ||||
| white board coding [1] | 2011 | 2Y | 2 @WallSt | 0 | 3 | ||||
| c++instrumentation/build tools | |||||||||
| ! bond math | 2010 Citi | 1Y | 2 | 1 if relevant | 2 | ||||
| option math | 2011 Barc | 1Y | 3 | 2 if relevant | 1 | ||||
| fin jargon | 2010 | 4Y #mvea | 3 #know what’s relevant | 2 | 2 | ||||
| finSys arch #abstract | 2010 | 2Y | 2 | 3 | 3 | ||||
[1] Am more comfortable on whiteboard than other candidates.
Explanation marks means Surprise
Let’s not try to look like a HFT pro, citing your low-speed algo trading xp…. You could look desperate and clueless.
My list experiences don’t guarantee success, because devil is in the details (Just look at all the details in xtap retransmission…) However, I should feel more confident than an outsider.
However I feel these experiences are seen by hiring managers as insufficient. What are the gaps you see between my experience and the essential skills?
? limited OMS experience
? latency optimization
? network optimization
In NYSE market data lingo, we say “multicast channel”.
“Multicast connectivity” is barely tolerable but not “connection”. A multicast end system joins or subscribes to a group. You can’t really “connect” to a group as there could be zero or a million different peer systems without a “ring leader” or a representative.
Even for unicast UDP, “connect” is the wrong word as UDP is connectionless.
Saying a nonsense like “multicast connection” is an immediate giveaway that the speaker isn’t familiar with UDP or multicast.
Sg is much harder, so … I better focus my CV effort on the Sg/HK/China market.
OK U.S. job market is not easy, but statistically, my CV had a reasonable hit rate (like 20% at least) because
I guess you could simulate broadcast using TCP. You may need to maintain 5 sockets to 5 clients…
I think this is highly inefficient.
–c++:
use a (possibly nested) namespace to group related free functions. See google style guide.
c# has static classes. C++ offers something similar — P120 effC++. It’s a struct containing static fields. You are free to create multiple instances of this struct, but there’s just one copy for each field object. Kind of alternative design for a singleton.
This simulates a namespace.
–java:
In [[DougLea]] P86, this foremost OO expert briefly noted that it can be best practice to replace a java singleton with an all-static class
–c# is the most avant-garde on this front
Constructor starts the kernel thread running.
Object dtor could trigger terminate() if the kernel thread is still alive but not “detached” from the object.
#include <iostream>
/* determines if the there is a subarray of arr[] with sum equal to 'sum'
Nice and simple algorithm. Works for exact match only.
*/
void subArraySum(int const arr[], int const n, int const sum)
{
int curr_sum = arr[0], le = 0, ri;
/* Add elements one by one to curr_sum and if the curr_sum exceeds
the sum, then remove starting element */
for (ri = 0; ri <= n-1; ri++) {
/* If curr_sum exceeds the sum and sub-array isn't single,
then remove the starting elements*/
while (curr_sum > sum && le < ri) {
printf("curr_sum = %d too high. le = %d; ri = %d\n", curr_sum, le, ri);
curr_sum = curr_sum - arr[le];
le++;
}
if (curr_sum == sum) {
printf("Sum found between indexes %d and %d\n", le, ri);
return;
}
// now curr_sum is too small or sub-array is single
curr_sum = curr_sum + arr[ri+1];
}
printf("No subarray found\n");
}
int main()
{
int const arr[] = { 11,24, 2, 4, 8, 7 };
int const n = sizeof(arr) / sizeof(arr[0]);
int const sum = 7;
subArraySum(arr, n, sum);
}
Cancellation is required when you decide a target thread should be told to give up halfway. Cancellation is a practical technique, too advanced for most IV.
Note in both java and c#, cancellation is cooperative. The requester (on it’s own thread) can’t force the target thread to stop.
C# has comprehensive support for thread cancellation (CancellationToken etc). Pthreads also offer cancellation feature. Java uses a numbers of simpler constructs, described concisely in [[thinking in java]]. Doug Lea discussed cancellation in his book.
* interrupt
* loop polling – the preferred method if your design permits.
* thread pool shutdown, which calls thread1.interrupt(), thread2.interrupt() …
* Future — myFuture.cancel(true) can call underlyingThread.interrupt()
Some blocking conditions are clearly interruptible — indicated by the compulsory try block surrounding the wait() and sleep(). Other blocking conditions are immune to interrupt.
NIO is interruptible but the traditional I/O isn’t.
The new Lock objects supports lockInterruptibly(), but the traditional synchronized() lock grab is immune to interrupt.
https://databricks.com/blog/2015/05/28/tuning-java-garbage-collection-for-spark-applications.html is a 2015 Intel blog.
Before the G1 algo, Java applications typically use one of two garbage collection strategies: Concurrent Mark Sweep (CMS) garbage collection and ParallelOld GC (similar to parallelGC, the java8 default).
The former aims at lower latency, while the latter is targeted for higher throughput. Both strategies have performance bottlenecks: CMS GC does not do compaction, while Parallel GC performs only whole-heap compaction, which results in considerable pause times.
https://blog.codecentric.de/en/2013/01/useful-jvm-flags-part-6-throughput-collector/ (2013) has an intro on Throughput vs. pause times
Update — Google style guide is strict on MI, but has a special exception on Windows.
MI can be safe and clean —
#1) avoid the diamond. Diamond is such a mess. I’d say don’t assume virtual base class is a vaccine
#2) make base classes imitate java interface … This is one proven way to use MI. Rememer Barcalys FI team. All pure virtual methods, No field, No big4 except empty virtual dtor.
#2a) Deviation: java8 added default methods to interfaces
#2b) Deviation: c++ private inheritance from one concrete base class , suggested in [[effC++]]
#3) simple, minimal, low-interference base classes. Say the 2 base classes are completely unrelated, and each has only 1 virtual method. Any real use case? I can’t think of any but when this situation arises i feel we should use MI with confidence and caution. Similarly “goto” could be put to good use once in a blue moon.
Thread — lockfree becomes relevant in latency-sensitive contexts
Thread — create opportunity for parallelism, and exploit multi-core
Thread — avoid locks including concurrent data structures and database. Be creative.
Data structures — STL is known to be fairly efficient but can affect performance
Data structures — minimize footprint
Data structures — favor primitive arrays because allocations are fewer and footprint is smallerAlgo — favor iterative over recursive
DB tuning — avoid hitting DB? Often impractical IMO
Serialize — favor primitives over java autoboxing
Serialize — favor in-process transfers, and bypass serialization
Mem — avoid vtbl for large volume of small objects
Mem — reuse objects, and avoid instantiation? Often impractical IMO
Mem — mem virtualization (like gemfire) as alternative to DB. A large topic.Mem — Xms == Xmx, to avoid dynamic heap expansionMem — control size of large caches.Mem — consider weak referenceMOM — multicast is the clear favorite to cope with current market data volumeMOM — shrink payload. FIX is a primary example.GC — avoid forced GC, by allocating large enough heap
Socket — dedicate a thread to a single connection and avoid context switchingSocket — UDP can be faster than TCP
Socket — non-blocking can beat blocking if there are too many low-volume connections. See post on select()
Jargon warning: yield is best written in bps/year, like 545bps/year. If you say 5.45% it gets ambiguous in some contexts such as modified duration. “1% rise in yield” could mean 2 things
– 5.45% —-> 6.45%,
– 5.45% –x-> 5.50% is a misunderstanding
This is not academic; this is real. Portfolio sensitivity to yield fluctuations is a key concern of banks on Wall St or Main St. It’s all about x bps change in yield. (From now on, always use bps to describe yield; avoid percentage.)
DV01 is dollar value of a “basis point”, free of any ambiguity.
DV01 and modified duration are 2 of the most widely used bond math numbers. Both are derived from bond cash flow.
Mac duration — definition — weighted average of wait time for the cash flows.
Mac duration — usage — not much in real world trading
Modified duration — definition — Mac duration modified “slightly”, by a tiny factor. REDUCED by (1+r)
Modified duration — usage — more useful than Mac duration. It measures price sensitivity to a yield shift, on a given bond.
For a simple example of a bond with modified duration of 5 years. 100 bps yield change results in a 5% dollar price change.
Key Rate Duration is an natural (and intuitive) extension of the duration concept, useful in MBS etc.
