X years needed2become effective java GTD guy

Update — It would be good to have some measurable yardsticks for GTD competence. Right now the g_GTD_zbs tag includes at least 50 blogs.

XR, (letter sent in July 2010)

Here the goal is not getting the job but keeping the job. You said there’s a difference between a knowledgeable java student and an experienced java developer.

I said I only did java for 3 years.. well maybe 4. I think much of that time I was doing repetitive work, not learning. About half the time (1-2 years) I was learning, by experimenting, reading, discussing, debugging… (I actually learned a lot of java from our long phone conversations.)

I feel if a bright young guy is given a good training project, then in 6 – 24 months he might be able to reach my level of java proficiency.

I also said a lot of young coders could become faster than me with a specific java task after a few months of java learning. Well … an apprentice carpenter could become faster than his master at sawing along a line, but can’t replace the master completely. I feel the hundreds of decisions made each week by an experienced java developer are often based on more experience.

C# is probably same thing – 6 to 24 months to become effective. A very experienced c# friend told me “3 months”. I spent about 6 serious months and another 12 repetitive months on c#…

Venkat, one of the fastest-learning developers I have worked with, said (in Lau Pa Sa) “To get really competent with a new language (like java, c#, python) honestly you need at least one year.” Venkat had the strongest C++ skill I know. I witnessed how he picked up c#. He later struggled a bit with java.

The 64 million dollar question is, what are the really effective learning strategies. I don’t have good answers. Guo Qiao was an advocate of programmer online learning. Some people even suggest taking part in open source projects, to learn from practicing master programmers… I’d love to hear your input.

Thanks.

private gz posts – which blog

Background — I have a few dozen “private and confidential” blog posts about work experiences and plans.

Choice: recrec blog, private view
Choice: 1330152open blog
(Discarded choice: private blog in blogger)

–advantages of recrec:

  • well-designed categories. I often rely on them for my own review
  • the posts in this blog are higher quality and valuable insight
  • I can easily switch on/off the privacy protection, without moving the post

–advantages of the 1330152 blog:

  • the recrec blog was not designed for self review purpose, though it is used that way nowadays

–Conclusion: use quality as criteria. Keep low qualities in 1330152.

JVM = a bytecode interpreter + JIT compiler

I used to think the JVM is a layer on top hardware and executes platform-independent bytecode against the hardware. The hardware components include

  • filesystems
  • network ports
  • CPU and memory
  • kernel threads
  • user input devices + screen

Consider assembly code. I guess assembly code deals directly with the same hardware components, with possible exception of threads.

(Not sure where the operating system kernel comes into play. See https://bintanvictor.wordpress.com/2011/09/08/what-is-kernel-space-vs-userland/)

Now I think JVM includes a JIT compiler that converts bytecode into assembly. See https://bintanvictor.wordpress.com/2016/02/09/javac-jit-2-compilers/

 

##high complexity high market value specializations

Opening example 1: Quartz — High complexity. Zero market value as the deep insight gained is decidedly local and won’t make you a stronger developer on another team.

Opening example 2: IDE, Maven, git, Unix + shell scripting — modest complexity; Makes me stronger developer in real projects, but no premium on the labor market.

My best experiences on Wall St — tech skills with high market value + complexity high enough that few developers could master it. On a project involving these I get better lifestyle, lower stress… Examples:

  • threading
  • java collections
  • SQL complex queries + stored proc. Declining demand in high-end jobs?
  • SQL tuning
  • MOM-based, high volume system implementation — reasonable complexity and market value, but not mainstream. Mostly used in trading only 😦
  • pricing math — high market value but more specialized 😦
  • trading algorithms, price distribution, … Specialized 😦

Let’s look at a few other tech skills:

  • c++ build automation — modest complexity; low value
  • c++ low latency — high value;  complexity too high for me — need suitable contexx and instrumentation.
  • java reflection, serialization — high complexity high practical value, but market value is questionable.
  • .NET — some part can be high complexity, but demand is a bit lower than 2011.
  • Java tuning — high complexity; not high value practically
  • python — modest complexity, modest market value
  • PHP — lower complexity and lower market value than py, IMHO

in-depth^cursory study@advanced programm`topics

I have seen both, and tried both.

AA) A minority of developers spend the time studying and understanding the important details of threading, generics, templates … before writing code.

BB) 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
https://bintanvictor.wordpress.com/2016/10/31/strength-gtd-with-non-trivial-researchinnovation/ https://bintanvictor.wordpress.com/2016/03/30/theoretical-complexity-strength/
https://bintanvictor.wordpress.com/2016/03/03/tech-specializations-no-such-luxury-in-singapore/

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.

## 5common list operations defined concisely

See also https://bintanvictor.wordpress.com/2012/05/06/functional-lang-basic-list-operations-python-stl-linq/

Among the languages (STL, Linq, java stream, javascript, perl), I feel python has a simple and clean set of list operations, but in this post I will use generic names for generic operations.

I believe all these operations treat original list as immutable, and produce a new “copy” as return value. STL has a few algorithms in this category.

Every operation is able to take a lambda as input. Alternatives to lambda — function references, functors, function pointers…. Collectively these are known as FirstClassFunctions. See https://bintanvictor.wordpress.com/2012/01/04/functional-programming-personal-observations-fmd/

Operation Filter — like grep, selects a subset of the original. Each item in the selected subset is unchanged.
** Operation FindAll — is a synonym of Filter.
** Operation Find — returns first item of the subset.

The above Filter-family operations are the simplest operations.

Operation Reduce — (as in MapReduce) is an _aggregation/accumulation_ operation, starting with an optional initial value. It aggregates a list into a single value.
** Operation Fold — is similar but without initial value

Operation Map (as in MapReduce) — creates a different (unlike Filter) object from each list item. Output list is same length as input list, unlike Filter. I also call this “decorator”

—–also-ran operations I wouldn’t rank as most common Functional programming operations:

Operation ForEach

Basic objects/services hosted in a java server

For a basic web server, the resources (on disk) and objects (in memory) hosted in the server are mostly static files.

For a php/perl/python powered web server, the objects hosted would be the scripts to print html. There are almost always some resources beneath those scripts.

Simpler example — for an ftp server, the resources managed are the files.

Another simple example — time server. The resource beneath the server is the host OS.

For a database server, the resources managed by the server are the tables. The server performs heavy-duty CRUD operations on the tables. The most trivial operation — a simple select — is comparable to apache serving a static page.

For a CORBA or RMI server, there are actual “remote” objects and corresponding “skeleton” objects hosted in the server’s memory.

How about a regular java server? Resources — disk files, and databse and other servers on the network. More important are the objects hosted in the java server. They all live in JVM.
* domain entity objects are well-defined, such as
** (Hibernate) entity objects from data sources,
** message objects, and
** objects created from user input
** more generally, objects from external data brought into java via some interface are usually domain entity objects.
* temporary objects — can lead to memory leak if not reclaimed systematically. * infrastructure objects, such as spring beans and MOM system objects. I think 3rd party java packages often introduce many infrastructure objects.

why employers prefers younger workers, a revisit

My neighbour Julius (of Indonesia) said

* younger employees mean lower cost
* more energy
* can map out a 10Y career plan for him

Below are my own observations and reading.

The younger guys often have more spare time available. Granted, many choose to spend it outside work, but a small percentage (30%?) of the ambitious, dedicated or hard-working individuals would *regularly* and voluntarily spend some of that at work.

For managerial roles, I feel a 30-something can be very effective. The relative short experience may not mean a lot.

For technical roles, the long experience of a 40-something is even less valuable. My own experience is most convincing. At 25 I was more formidable than many of my older colleagues. I was sharp,
fast-learning, self-driven, knowledgeable, possibly more experienced than them in a given technology.

relative funding advantage paradox by Jeff

(Adapted from Jeff’s lecture notes. [[hull]] P156 example is similar.)
Primary Market Financing available to borrowers AA and BB are
AA
BB
fixed rate
7%
7.5%
<= AA’s real advantage
floating rate
Libor + 1%
Libor 1.24%
needs to borrow
floating
fixed
Note BB has lower credit rating and therefore higher fixed/floating interest costs. AA’s real, bigger advantage is “fixed”, BUT prefers floating. This mismatch is the key and presents a golden opportunity.
Paradoxically, regardless of L being 5% or 10% or whatever, AA and BB can both save cost by entering an IRS.
To make things concrete, suppose each needs to borrow $100K for 12M. AA prefers a to break it into 4 x 3M loans. We forecast L in the near future around  6 ~ 6.5%.
— The strategy –
BB to pay 6.15% to, and receive Libor from, AA. So in this IRS, AA is floating payer.
Meanwhile, AA to borrow from Market fixed 7% (i.e. $7k interest) <= AA's advantage
Meanwhile, BB  to borrow from market L + 1.24% (i.e. L+1.25K) <= BB's advantage
——-
To see the rationale, it’s more natural to add up the net INflow —
AA: -L+6.15  -7 = -L-0.85. This is a saving of 15bps
BB:   L -6.15  -L-1.24 = -7.39. This is a saving of 11bps
Net net, AA pays floating (L+0.85%) and BB pays fixed (7.39%) as desired.
Notice in both markets AA enjoys preferential treatment, but the 2 “gaps” are different by 26 bps i.e. 50 (fixed) ~ 24 (floating). AA and BB Combined savings = 26 bps is exactly the difference between the gaps. This 26 bps combined saving is now shared between AA and BB.
———————————————————————————————-
Fake [1] Modified example
AA
BB
fixed rate
7%
7.5%
floating rate
Libor + 1%
Libor 1.74%
<= AA’s real advantage
needs to borrow
fixed
floating
— The strategy –
AA to pay 5.85% to and receive Libor from BB.
Meanwhile, BB  to borrow fixed 7.5% 
Meanwhile, AA to borrow L + 1% <= AA's advantage
Net inflow:
AA:  L -5.85 -L-1 = -6.85, saving 15 bps
BB: -L+5.85-7.5 = -L-1.65, saving 9 bps

[1] [[Hull]] P156 points out that the credit spread (AA – BB) reflects more in the fixed rate than the floating rate, so usually, AA’s advantage is in fixed. Therefore this modified example is fake.

———————————————————————————————-
The pattern? Re-frame the funding challenge — “2 companies must have different funding needs and gang up to borrow $100K fixed and $100k floating total, but only one half of it using AA’s preferential rates. The other half must use BB’s inferior rates.
In the 2nd example, since AA’s advantage lies _more_ in floating market, AA’s floating rate is utilized. BB’s smaller disadvantage in fixed is accepted.
It matter less who prefers fixed since it’s “internal” between AA and BB like 2 sisters. In this case, since AA prefers something (fixed) other than its real advantage (float), AA swaps them “in the family”. If AA were to prefer floating i.e. matching her real advantage, then no swap needed.
Q: Why does AA need BB?
A: only if AA needs something other than its real advantage. Without BB, AA must borrow at its lower advantage (in “fixed” rate market), wasting its real advantage in floating market.