electrum

Netezza, a data warehouse appliance which was built on PostgreSQL, uses FPGAs as the first step to process data as it is read from disk.

Facebook uses it for some open source projects: https://reviews.facebook.net/

A number of states, including California, require accrued vacation to be paid out in the final paycheck: http://www.nolo.com/legal-encyclopedia/layoffs-plant-closing...

Unemployment is covered by taxes paid by the employer. You should absolutely collect it if legally allowed: https://www.irs.gov/Individuals/International-Taxpayers/Fede...

Additionally, California has additional protections for workers, such as requiring immediate payment for all wages, including accrued vacation, upon termination: http://www.dir.ca.gov/dlse/faq_paydays.htm

Also, extracting an interface is often 100% automated using the refactoring capabilities of your IDE, so doing it up front has little benefit (except in certain cases like being a public API in a library).

According to the article, the affected products are firewalls, not switches, but for switches, Facebook has open sourced the hardware and software for the switches used in production: https://code.facebook.com/posts/843620439027582/facebook-ope...

The Kansas City area has channel 4 (WDAF) and channel 5 (KCTV).

How do these compare to xxHash, which is 5x faster than CityHash? http://cyan4973.github.io/xxHash/

SMR drives are designed to be used in low-write environments such as archival, so bad performance for small random writes is to be expected.

That is exactly how we use Optional.

There is a standard tool, ssh-copy-id, that does the job of sshpair.

No, features are configurable at runtime. This allows A/B testing or slowly rolling out a new feature. Depending on the type of change, you might test it on 1% of users, 1% of servers, etc.

Just add the Maven dependency and see their own tests for an example:

https://github.com/airlift/testing-postgresql-server/blob/ma...

https://github.com/airlift/testing-mysql-server/blob/master/...

Though you want to use @BeforeClass / @AfterClass or similar rather than creating one for each test.

Unfortunately, limiting yourself to only what is available in standard SQL is not practical. For example, doing idempotent inserts, insert-or-update, sequences, transactional behavior for DDL, data types, date/time manipulation, etc.

To paraphrase Tom Kyte from Oracle (Ask Tom): "Your company paid good money for Oracle and all of its features. Use them instead of wasting money reimplementing them poorly yourself."

There are many ways to achieve portability across databases, but limiting yourself to standard SQL is not the best way (at least for everything). And I say this as someone who develops an analytic database (Presto) that tries to follow standard SQL for everything.

For Java, see my other comment for how to run real PostgreSQL or MySQL from unit tests: https://news.ycombinator.com/item?id=10003789

Aside from a few seconds to spin up a new PostgreSQL instance, it should not be any slower than SQLite. We have a wrapper [1] (forked from [2]) that starts a new PostgreSQL instance from Java unit tests. We have the same for MySQL [3]. This allows every developer to automatically run tests against the target database without needing to set anything up.

(The common alternative in Java is to use H2 or Derby, which are similar in concept to SQLite)

1. https://github.com/airlift/testing-postgresql-server

2. https://github.com/opentable/otj-pg-embedded

3. https://github.com/airlift/testing-mysql-server

The idea of "checking in ASTs" becomes a lot more compelling when you think about representing a diff of an automated refactoring. For example, a simple rename refactoring, performed by an IDE for a statically typed language, is completely safe, yet it could generate a 1000 line diff. This is hard to review, causes merge conflicts, does not rebase correctly, etc.

Instead, if you could somehow check in the refactoring action, all those problems would go away. You could rebase the code by undoing and redoing the rename, taking into account new usages of the renamed item, etc.

You can do that like this: GROUP BY date_trunc('minute', time)

Refactoring is often done in order to implement a new feature, but that doesn't mean they need to be done in the same commit. A common workflow is to be implementing something, realize a refactor is needed, "git stash", refactor, commit, "git stash pop", continue feature work.

Swift uses annotations (reflection) and generates bytecode on the fly. This fits much better with modern Java development practices and tooling than source code generation. Is such a thing feasible C++, especially in an idiomatic way? Or perhaps I am misunderstanding your question.

To my knowledge, our C++ Thrift code is here: https://github.com/facebook/fbthrift

(I work on Presto and occasionally Swift at Facebook, but am not at all familiar with modern C++)

Installing GPG Tools on Mac sets up gpg-agent automatically and has Mac Keychain support. I use the agent support all the time for signing Maven artifacts (which requires password-less entry due to the way the release plugin works).

The 8x improvement is somewhat misleading as it is based on a single TPC-H query. The other queries from the benchmark seem to show a ~3x improvement: http://vitessedata.com/technology

Given that their query engine uses an LLVM JIT compared to the standard PostgreSQL interpreter, these results are very reasonable. This is similar to comparing an interpreter vs a JIT for a programming language.

Even with the best intentions, benchmarking a database is notoriously difficult. I work on Presto, a distributed analytic SQL database, and we are often asked how it compares to other systems, or how it will perform for a given workload. The answer is always "try it and see", both because how it performs for your configuration and workload is the only thing that matters, and because there are so many variables that factor into the result.

He tested PostgreSQL: https://aphyr.com/posts/282-call-me-maybe-postgres

The latter of which is very common in corporate environments where employee's machines are provisioned by the IT department and contain the company's private CA (which is useful for non-nefarious purposes such as signing certificates for internal services).

What stops the browser from automatically trusting a self-signed cert for PayPal or your bank?

According to the Cassandra home page: "One of the largest production deployments is Apple's, with over 75,000 nodes storing over 10 PB of data."

Have you tried IntelliJ IDEA?

"There are several options. One option is to work around the hardware limitations in software, displaying something like

          |
   /\/ /\ |   /^ /\ /\ /\
   \/\ \/ | * \_ \/ | | |

Another, much more popular, option is to move your email reading, web browsing, etc. from your 1970s-vintage VT100 to a graphics terminal. Have you considered the VT340, for example? Or an IBM PC, model 5150?"

They mention the over harvest problem in the FAQ:

"Do I need to leave some honey in the hive for the bees?

Yes, this applies to all beekeeping. Your bees need honey to get them through the times when there is no nectar available. The number of frames of honey that you leave depends on your climate. You should consult local beekeepers as to how much they leave in their colonies over the winter.

The Flow frames make it a lot easier to see how much honey is in your frames at any time, so you can learn to manage how much honey to harvest and how much to leave for the bees.

Watching the honey level change every day is quite fascinating and I personally feel more in touch with the bees and can’t help but look on a daily basis. You can also take just a small amount of honey if you choose, by draining one frame or part of a frame."

Same here. "GitHub had an IPO???"