electrum

Although sometimes the food is limited to Carl's Jr.

No. The file system implementation uses the AWS S3 client, which will automatically use virtual-host style when possible (if the bucket name supports it).

Windows NT development started in 1989. It was lead by Dave Cutler, who also lead VMS which started in 1975.

Facebook does use it. They design their own hardware, but they are do not manufacture it themselves, they aren't in the hardware manufacturing business. They parter with companies like Quanta to do that.

Here's an older article that explains the relationship: https://venturebeat.com/2014/01/29/facebook-quanta/

Here's the code from FreeBSD: https://github.com/freebsd/freebsd/blob/master/sys/sys/queue...

If you buy at Costco, you can return them at any time in the future without a receipt. The return desk will lookup past purchases using your membership card.

> Not to mention that "uncovered later" is pretty damn worthless.

It is not worthless as a deterrent to the CA. Proof of a fraudulently issued certificate are grounds to permanently distrust the CA. So, yes, they can do it, but hopefully only once.

IntelliJ completion takes into account both type and name. For example, if you have two string variables, it will suggest the one that matches or is similar to the method parameter name.

In general, IntelliJ has a lot of features that feel like magic (likely a pile of smart heuristics that have been added over the years).

Presto is not an Apache project (although it is open source under the Apache License).

The commit that dual-licensed under BSD and GPLv2 also "removed PATENTS clause":

https://github.com/facebook/zstd/commit/4f73b3b55d83b082aad1...

It's more about the memory layout than where the objects live. For example, consider a Point class with (x, y) members.

If you have an array of these, each element in the array will be a reference/pointer to a separately allocated Point instance which can be anywhere in the heap. Accessing the array is expensive due to lack of locality (arbitrary memory access). Additionally, each instance has substantial object overhead (typically 8 or 16 bytes).

There are various ways to deal with this. One way is to have separate arrays for x and y. Another way is to use a byte array and use Unsafe to read/write the integers. This is terrible from a developer standpoint and is only acceptable if it is a small part of your application.

Value types solve this by giving you an efficient memory layout while still allowing you to code against them as normal. The slogan is "codes like a class, works like an int".

Java has essentially the same behavior with threads. If an error occurs in a thread, it will throw an exception that will terminate the thread if uncaught. Other threads are not directly affected. This is typically what you want as threads are usually independent of each other, often processing an isolated request, which may encounter a bug due to bad data or other conditions. Contrast this to languages like C++, where the usual behavior is to segfault and crash the process.

Special care must be taken if threads are manipulating shared data structures, especially inside a "critical section" where the data structure invariants must be maintained. This is why automatically terminating the JVM when OutOfMemoryError occurs is a best practice, as code is often not paranoid enough to handle it.

Are you sure about "most RDBMSs"? With the exception of SQLite and older versions of MySQL, all the databases that I've used are strict and fail the query immediately on error, will generally prevent silently dropping or truncating data, etc.

I'm one of the original authors of Presto, a distributed SQL engine for analytics on big data. From the beginning, we've been careful to follow the SQL standard and do everything possible to either return the correct answer or fail the query. For example, an addition or sum aggregation on an integer will fail on overflow rather than silently wrapping.

Returning an incorrect answer or silently corrupting your data is the worst thing a database can do.

The JVM could do this, but there is a lot of other overhead for JNI calls (by virtue of the JNI API specification). Project Panama is working on improving native interoperability: http://openjdk.java.net/projects/panama/

John Carmack was also successful at a relatively young age. He released Doom at age 23.

These gradual type checking frameworks allow migrating massive code bases incrementally. Doing a complete big-bang rewrite into a different language isn't feasible (for the obvious software engineering and business reasons).

You could add Folly as Facebook's backend C++ framework (it's somewhat analogous to Google's Guava for Java).

Deployment at Facebook: https://code.facebook.com/posts/270314900139291/rapid-releas...

You can see an open source version of "big iron" networking gear, both hardware [1] and software [2]. They also use ASICs for most of the work and run Linux on the host CPU (so they can be managed like normal servers).

[1] https://code.facebook.com/posts/843620439027582/facebook-ope... [2] https://github.com/facebook/fboss

This also directly contradicts one Steve Jobs' management principles:

> "Somewhere between the janitor and the CEO, reasons stop mattering," says Jobs, adding, that Rubicon is "crossed when you become a VP."

> In other words, you have no excuse for failure. You are now responsible for any mistakes that happen, and it doesn't matter what you say.

http://www.businessinsider.com/steve-jobs-on-the-difference-...

> RocksDB - Facebook just outsourced the engine to the community, where is the service which adds replication, clustering and network interface on top of it?

https://myrocks.io/

Access to the current row was improved in the SQL:2011 standard. See section "8.2 Navigation within a window" in this paper: https://sigmodrecord.org/publications/sigmodRecord/1203/pdfs...

Presto generates Java bytecode which is then turned into machine code by the JVM JIT.

Ticket to Ride has randomness in the train card deck. You can effectively gamble by drawing off the deck rather than choosing one of the face up cards.

You can write multiple arguments in a nice way:

  ./script \
    192.168.1.1 \
    192.168.1.2 \
    192.168.1.3 \
    ...

Comparing a bug bounty to a jackpot seems reasonable. Researches are paid when they find something. They might work for many hours and find nothing. So when they do find a bug, the payout has to be worthwhile.

I believe that is saying that MySQL transactions across two storage engines are not transactional, as that would require two-phase-commit (2PC) or similar. It might also have implications for replication.

MyRocks itself definitely has transactions. As the wiki explains, it uses snapshots (MVCC) for transaction isolation.

The "how to hash passwords" discussion should be easy: use PBKDF2, which is an IETF standard specified in RFC 8018 (originally specified in 2898 from the year 2000).

Presto has connectors for various types of non-SQL databases including Redis: https://prestodb.io/docs/current/connector/redis.html

Presto is a distributed SQL query engine for big data, so basically the complete opposite of SQLite, though it often gets used in federation scenarios, as does SQLite.

An interesting anecdote is that the team working on what would become osquery (https://osquery.io/) asked if they could reuse the SQL parser from Presto. We get that question a lot, and after explaining that the parser is the easy part (semantic analysis and execution is the real work), I determined that what they really wanted were SQLite virtual tables: https://sqlite.org/vtab.html (and those worked out great for them)

Or Kotlin: https://kotlinlang.org/docs/reference/js-overview.html