mborch

"However, neither Mallick et al. nor Malaspinas et al. exclude the possibility of multiple out-of-Africa dispersals." (from the commentary).

How is that one wave?

Terrible user experience. There's no reason to use this kind of interaction when it's not adding to the experience.

If you live in a country where you can't trust your ISP then there is a very real MITM risk.

It's already public record since it's a law suit.

Are you saying that the only programmer who's able to avoid bloat is a not-smart programmer? The truth is that it's a balancing act and it's not always clear when bringing in yet another externally maintained library is the right thing to do.

Very true. It's like a cooking competition where you take over from someone else after being blind-folded. Unless you're from the same schooling chances are the result will lack direction. The equivalent in software is bloat. Note that sometimes that "someone" is your former self and you forgot what the idea was.

You're right and actually the CEO reached out and clarified this. I have updated my post to try and better reflect the problem.

I did after about 18 minutes which did limit the import to just the most recent emails. Phew!

No it doesn't.

I think most people would be surprised to find the package's contained module in the root of the repository because it's not one-to-one with what will end up being "installed".

Also, a package can install multiple modules.

You can use a CASE-statement for each possible filter and apply it only if the filter value(s) are non-trivial.

    -- Parameter :filter
    --
    AND CASE WHEN :filter IS NOT NULL THEN
        table.column = :filter
    ELSE TRUE END

This has zero cost in the case where :filter is unset.

Escape using zero-width space character to break up the ligatures ...

different compressions being talked about here.

Just add these to your .gitignore/.hgignore/.agignore file.

Yes.

This is required due to Python's semantics. You can't optimize that away unless the code is written to explicitly turn a global into a local.

"On our production frontend machines, SSL/TLS accounts for less than 1% of the CPU load, less than 10 KB of memory per connection and less than 2% of network overhead. Many people believe that SSL/TLS takes a lot of CPU time and we hope the preceding numbers will help to dispel that." - Adam Langley, Google.

Dart uses the following sugar for a "simple" constructor:

    Color(this.rgba);

That is, it directly assigns the argument to the slot (which must be defined at class-level.)

Of course, it's still repeating the class name but that's solvable.

Just put HAProxy in front of your server. You'll want that anyway most likely.

The article states the opposite: that it's write-heavy.

The difficulty in managing time series data is that you need to do roll-ups and generally avoid doing the same work twice - that is, read the same rows over and over again.

If you're doing the same work over and over, it's always going to be slow. Don't do that! InfluxDB could presumably be built on top of PostgreSQL. It just manages the data lifecycle. But that would be a polyglot mashup project then and not something you could sell to VCs.

Just require query string to be sorted. In Python:

  urllib.urlencode(sorted(params.items()))

PostgreSQL can be schemaless if you want it to be. It obviously does joins, so that leaves only the awesome query language.

Maybe just watch me on Github.

Interestingly, only Github manages to syntax highlight the diff.

Fair enough, but for the record it's at least 10 MB (try starting up Python and import your list of modules).

The environment variable handling and other stuff could perhaps be handled in a separate bash-script (or Python), such that the scope of the actual reaper is sufficiently small (to use a lower-level language).

It's trivial to write this program in C and it is a waste of memory to load up 50 MB of Python just to accomplish this simple task.

How is allocating and populating a Python list order to do a simple for loop in a tight inner loop not problematic? Neither CPython nor PyPy can optimize that out.

As I said, this is assuming we're on Python 2.x.

Assuming this is Python 2.x (doesn't seem to be specified in the benchmark results), then the use of "range" is problematic (should be "xrange").

Run the program without starting a shell?