rusanu

We're in the middle of the (minor) Orion Arm right now: https://en.wikipedia.org/wiki/Orion_Arm

Apparently they're rather static: https://en.wikipedia.org/wiki/Density_wave_theory

They were implementing HTTP Digest[0]. This leaves no room to choose something other than MD5. And I'm not sure what other HTTP authentication scheme they could had chose for firmware (ie. cannot take dependency on anything in infrastructure, like PKI or Kerb)

[0] https://en.wikipedia.org/wiki/Digest_access_authentication

> such as would be produced by a black hole of about one solar mass

How do such low mass black holes form?

BK edits Wiki entry on the Whopper to say is "America's favorite burger", then launches ad that reads from Wikipedia on Home Smart devices. What could go wrong? Wiki entry is edited to read "worst hamburger product" and ad campaign happily reads the new description...

I love how they close the stores on Black Friday[1] and invite members to spend the day outdoors.

https://www.rei.com/black-friday

He is the son of Maurice Jarre [1], and I heard before how this helped him financially quite a bit.

[1] https://en.wikipedia.org/wiki/Maurice_Jarre

I guess otherwise no GitHub employee could ever use GitHub for a personal project, could they?

This is probably the most hot topic for database service providers. Operating hundreds of thousands and millions of databases yields a valuable collateral: operational data (what users are doing, metadata, table shapes, query patterns, application behavior, reasons for blocking, IO patterns, memory patterns, everything). Take the tuning wizards of 5 years ago, add machine learning on vast amounts of operational data, add 'shadow' A/B testing (run a secondary instance shadowing the same workload, on a copy of the database, but, say, apply an index recommendation to the shadow instance and measure the impact). When I left Microsoft one year ago, this whole area was seen as a gold mine and there was massive investment into it. You can already see such offerings as Azure SQL Database Advisor[1]. I'm convinced Amazon is doing its own research in this space, specially for Aurora.

We're talking much more than just index optimizations. Think automatic OLTP vs. OLAP pattern detection and migration of data into columnstores or in-memory tables. Automatic detection of cold vs. hot data and migration to-from expensive fast near storage (SSD) vs. cheap remote storage (S3 like). Automatic resizing of instance size. Materialized views. On-the-fly query rewrite. The field is wide open. And you have the best experts in the field looking at your database.

By contrast, the traditional on-premise auto-tuning did not made much progress over the past 10-15 years. There are reasons for this: small operational dataset (one site only), high risk of regression (difficult to do A/B testing), scarcity of experts. The best avenue for on-premise I predict will be the trickle-down effect of migrating service know-how and technologies to on-premise offerings. We're also going to see a push up the stack of the know-how and experience from operating the service making its way into the app stack (think EntityFramework v. 2018?) and helping developers avoid the common pitfalls.

BTW, only 3 days ago Adrian Coyler's morning paper discussion was Self-driving database management systems [2]

[1] https://docs.microsoft.com/en-us/azure/sql-database/sql-data... [2] https://blog.acolyer.org/2017/01/17/self-driving-database-ma...

I have a blog article that covers a bit more details: http://rusanu.com/2013/08/01/understanding-how-sql-server-ex...

Being Hawaii though, I don't think he will get a private beach, though :)

http://seagrant.soest.hawaii.edu/coastal-access-hawaii

http://dlnr.hawaii.gov/occl/beach-access/

Writing high performance applications on Windows has been an 'open secret' for long time. Good free presentation I know of are Rick Vicik ones:

  - https://blogs.technet.microsoft.com/winserverperformance/2008/04/25/designing-applications-for-high-performance-part-1/  

  - https://blogs.technet.microsoft.com/winserverperformance/2008/05/20/designing-applications-for-high-performance-part-ii/  

  - https://blogs.technet.microsoft.com/winserverperformance/2008/06/25/designing-applications-for-high-performance-part-iii-2/

A simplified explanation is that for good throughput one creates a completion port and binds a thread pool to it with as many threads as CPUs. Then all IO is done via the completion port. If the system is partitioned (NUMA) then one should create a completion port per node and partition the thread pool. I skip the details, read the links for a better explanation. The gist of it that the code written this way has no procedural flow when you read it. Instead of a sequence of function calls (read socket -> parse -> read file -> write socket), it must be a state machine which always reacts to some IO completion, modifies the state, posts some more IO and then returns the thread back to the pool (post socket read, socket read callback -> parse -> post file read, file read callback -> post socket write, write socket callback). Writing it as FSM makes it lot easier to understand.

C# async/await is like a DSL that generates the FSM while you write fluent sequential code, easy to write and easy to read.

Looking now at how Windows handles console application arguments, it sure looks broken. But you have to put your mindset in cca. 1990 and think what Windows applications looked like back then, and what was the model Microsoft was betting on. Arguments were passed via DDE[0], and then later all the bets were on OLE[1] and finally COM[2]. System components were all the time accessed via in-process DLLs communicating with services over LRPC[3]. In this world, the command line, the pipe philosophy and the 'less is more' mindset were not only not welcome, they were the adversary.

Even when finally it was aknowledged that the command shell needs some love too, the answer was PowerShell, which yet again defined an object interface between cmdlets[4].

[0] https://en.wikipedia.org/wiki/Dynamic_Data_Exchange [1] https://en.wikipedia.org/wiki/Object_Linking_and_Embedding [2] https://en.wikipedia.org/wiki/Component_Object_Model [3] https://en.wikipedia.org/wiki/Local_Procedure_Call [4] https://en.wikipedia.org/wiki/PowerShell#Pipeline

ESA article: http://www.esa.int/Our_Activities/Observing_the_Earth/Swarm/...

Even ignoring this, I doubt that the sum of all US caused casualties can approach WWII USSR losses caused by German forces.

TL/DR: Email sent to 840k addresses wrecks havock on email servers. For context why I find this particularly funny, here is the famous I Survived Bedlam 3 DL story: https://blogs.technet.microsoft.com/exchange/2004/04/08/me-t...

The HN discussion of the article being retorted: https://news.ycombinator.com/item?id=12872304

The article addresses this:

> Meteorites can churn up the lunar surface in several ways. Along with the fresh craters, Speyerer's team found more than 47,000 ‘splotches’, formed when material gets kicked up by the main impact and rains down — sometimes tens of kilometres away.

> And that means a bigger risk for any future lunar habitats, says Stephanie Werner, a planetary geologist at the University of Oslo. The chances of a lunar base being nailed by a direct meteorite hit are relatively small, but the splattered material could pose a hazard.

My understanding of the article is that the answer is: No.

"found that 10 times as many galaxies were packed into a given volume of space in the early universe than found today. Most of these galaxies were relatively small and faint, with masses similar to those of the satellite galaxies surrounding the Milky Way. As they merged to form larger galaxies the population density of galaxies in space dwindled. This means that galaxies are not evenly distributed throughout the universe's history,"

I read this as they did not find new visible matter, but they discovered that the visible matter was distributed in many more small galaxies compared with today. I could be wrong though, I'm by no means an expert in this field.

But the infrastructure cost of $200M can go down drastically on subsequent iterations, think how the cost of solar evolved past 5 years.

I'm thinking at this as proof of concept. If it works, there are many rich areas of the globe where fertile soil is at a premium and cannot grow much. Basically, transform oil dollars into local grown food.

The 'strange' part is clarified better in the Wikipedia page [0]:

> The forelimb of Drepanosaurus is highly modified compared to other vertebrates and very robust. Its ulna was altered from being a forearm bone into an odd crescent shaped site for muscle attachment. The role played by the ulna in most tetrapods is replaced by an elongated carpal bone. Additional musculature would be attached to the high withers that characterized Drepanosaurus and its close relatives.

What fascinates me and triggered me to submit here is how similar (in spirit) this adaptation is to the famous Panda's Thumb [1].

- [0] https://en.wikipedia.org/wiki/Drepanosaurus

- [1] https://en.wikipedia.org/wiki/The_Panda%27s_Thumb_(book)

I take you seriously, so the law must be true.

On the topic of ETW is worth mentioning UIforETW [0] and in general Bruce Dawson's blog [1].

[0] https://github.com/google/UIforETW

[1] https://randomascii.wordpress.com/

Interesting that you miss checked exceptions. Is one of the most criticized feature of the language, see Does Java need Checked Exceptions? [0]. Also in this discussion between Anders Hejlsberg and Bruce Eckel they are discussing why C# did not adopt them: The Trouble with Checked Exceptions [1]. Also Java theory and practice: The exceptions debate [2] discusses the more on the topic.

[0] http://www.mindview.net/Etc/Discussions/CheckedExceptions/

[1] http://www.artima.com/intv/handcuffs.html

[2] https://www.ibm.com/developerworks/library/j-jtp05254/

But then you need small disks (eg. 2TB). My point is that huge capacity drives are not appropriate in compute environments, as Hadoop is. They're more for cold storage.

60TB at 500Mb/s transfer will take +1 day to read the data. This is the problem of drinking the ocean through a straw. Even with SSD transfer rates, is still a problem at scale. Clusters give you no only capacity, but also multiplication factor for transfer rates.

I'm speculating and have no evidence, but my thinking is that offering money with no strings attached is a threat to those that offer money (or other help) with strings attached. Spreading rumors would be a defense strategy to protect those interests.

Thanks for the feedback. Entering more into performance monitoring dimension is something I hear often. Corroborate observed perf changes with logged configuration changes is something I do not see well covered in the traditional perf monitoring toolset in this space (SQL Server tools), so is definitely an opportunity I'm considering. It's just not a trivial change and will take some time to get it out.

Thanks for feedback. I hear the same from some potential customers, and my response is that I'm not opposed to an on-premise deployment (technically the code is prepared for this, eg. how the configuration wizard finds the 'service' endpoint address and so on), but that would be a completely different ball game (deployment, maintenace, servicing, branding etc and ultimately a very different price point).

Original paper: Rapid emergence of life shown by discovery of 3,700-million-year-old microbial structures [0]

[0] http://www.nature.com/articles/doi:10.1038/nature19355