2,153 karma · joined August 4, 2009
I just downloaded the latest node.js sources and v8 still has a call to CollectAllAvailableGarbage in a loop of 2-7 passes. It does this if a much cheaper mark-and-sweep fails. Under production loads, that would occasionally happen. This led to pause-the-world-gc of 3600+ms with v8, which was terrible for our p99 latency.
The fix still feels weird -- we just commented out the fallback strategy and saw much tighter response time variance with no increased memory footprint (RSS).
I never submitted a patch though because although it was successful for our workload, I wasn't sure it was generally appropriate (exposed as a runtime flag) and I left the job before I could do a better job of running it all down.
We've seen video of an officer shooting someone and then going back to his squad car and appearing to remove a gun from his bag and plant it on the victim. Carrying around a "burner" gun (in case you might need it) seems premeditated to me, but IANAL.
Even has Scott La Rock up front...
Linus' personality is remarkably intact, 24 years later.
More background: https://en.wikipedia.org/wiki/Tanenbaum%E2%80%93Torvalds_deb...
Favorite new trivia bit:
"C++ has an even more extreme version of this problem since type/variable disambiguation could require arbitrary amounts of template instantiation, and therefore just parsing C++ is technically undecidable (!!)"
I've found reductionist social Darwinism lacks explanatory for these phenomena.
1. Most (all?) written languages are linear -- they are processed sequentially by the brain and then deeper meanings are extracted (particularly wrt metaphors and allegory, but also viz. complex sentence structure). Emoji are not unique on this count.
2. Paper and pen (the surfer example) also have technological constraints. It's a "2D" surface, width of line, etc.
3. The input difficulties of emoji today seems temporary. For example, a gesture interface to get you to the correct emoji.
4. What about non-alphabetic written languages?
These seem like obvious first-order responses to the article, so I suspect I'm missing something (besides my first cup of coffee).
Retrospective meetings (where the topic is how the work is getting done, not what is getting done) are a standard and useful way to do this (assuming the results lead to actionable change). The frequency of the retros themselves should be part of your discussion (pick something to start with ("every 2 weeks") and periodically decide if that's the right cadence). Length of sprints, styles of coding, amount of pairing, etc. -- all of these are variable based on the experience of the team and the problem being tackled. Pick reasonable defaults to start with and regularly ask yourselves if those defaults make sense given your experiences.
I could say more, but the above is the base minimum I've found for success across different teams, different problems, different companies. Cheers.
I'm not taking a position on that question, as I haven't studied it sufficiently (though acupuncture, for example, seems more compelling that reiki).
Because satellite is one-way, the cheapest option for sky is to pay for enforcers. There must be quite a spread between commercial and home licenses.
I suspect you could generalize this to many similar language construct and tool warnings/anti-patterns.
Except csh. It's always harmful.
Of course, teams need the authority to solve the pain if they also have the responsibility for it.
I'm a big fan of developers being on call for their application. It puts the pain where it belongs--with those building the systems (modulo lower-level errors--such as power failures or network outages--those should go to the appropriate place).
However, that pain should only rest with the development team if they also have the freedom and will to spend time dealing with it. They will have spend time (either a constant tax, or more likely, with occasional sprints) to reduce operational pain. They are in the best position to reason about the tradeoffs and pragmatically reason about priorities.
In my experience, this produces the highest code quality and the highest team morale. I also like the rule -- if you're paged during the night, sleep in the next day.
It would be useful to have some insight into the underlying data, it's freshness, and an easy way to report inaccuracy (I've sent support emails but they've gone unanswered -- I assume the support load is enormous for a small team).
Assuming 15GB plan:
Month 1 (15, 0 avail): Use 10 GB, roll forward 5
Month 2 (15, 5 avail): Use 8, roll 7, lose the previously rolled 5
Month 3 (15, 7 avail): Use 20, roll nothing (lose the unused 2)
Month 4 (15, 0 avail), etc. etc.
So this saves you if you have one outlier month, but it's still not as good as rolling what I've nominally paid for.
Bookmarklets, referer spoofing and other improvements left as exercise for the reader.
Seems like the show relies on the kindness of strangers and that still exists, even in a smartphone world.
The part about the criticism of the positivity ratio was particularly interesting because a co-author wrote the brilliant parody of post-modernism published in one of its seminal journals, Social Text (http://en.m.wikipedia.org/wiki/Sokal_affair).
A critique by Sokal is prima facie intriguing.
I need to go read the original article but the Wikipedia summary is fascinating (http://en.m.wikipedia.org/wiki/Critical_positivity_ratio) in specific, Fredrickson and Losada appear to have chosen functional parameters that yield good results, not ones based on evidence.