isaachier

It doesn't. But trying to convince them to abandon Christian literalism would require an alternative that satisfies this need for purpose.

A simple way is to use output files to indicate if a command has been run.

Example:

git-setup.out: touch $@

For Hebrew, you can try using some of the data here: https://github.com/Sefaria/Sefaria-Export.

Usually the combination of names for the theory means that researchers recognize both versions as largely equivalent (e.g. Newton-Leibnitz axiom).

The contention that the combined theories must be the definition of computability should be true about each theory in isolation. If a Turing machine cannot calculate any computable problem, then why bother defining a Turing machine? What is the purpose of the definition if not to prove that any computable problem can be solved using the device? The same goes for lambda calculus.

Sounds like monopsychism (https://en.wikipedia.org/wiki/Monopsychism).

What you are describing sounds like non-deterministic behavior of a thread-safe primitive, e.g. non-deterministic ordering in a synchronized queue. On the other hand, a true race condition in the queue could mean messages overwriting each other.

From what I gather, it's an issue of floating point precision. See more here: https://medium.com/@bellmar/is-cobol-holding-you-hostage-wit....

Having recently listened to John McWhorter's lectures on the history of human language, I was surprised to find out that there is no reliable evidence for the Sapir-Whorf hypothesis (that language affects thought). The Wikipedia article on linguistic relativism states:

The strongest form of the theory is linguistic determinism, which holds that language entirely determines the range of cognitive processes. The hypothesis of linguistic determinism is now generally agreed to be false.

The Pragmatic Programmer is pretty zealous about DRY. For instance, the authors describe how they inserted sample code snippets into the book using specialized scripts developed for that purpose. A simple copy paste wasn't good enough (see p. 100-101). Granted, they had wanted to make sure the code snippets were tested and updated as needed, but repeating code anywhere seems to be a bad practice according this definition.

Having worked there, I believe the answer is yes, assuming you aren't living in a country that has an economic sanction against it, etc.

When you say non-language, do you mean unrelated to OCaml specifically or any language? Facebook implemented its infer linter for C, C++, Java, and Objective-C in OCaml: https://github.com/facebook/infer. When I worked at Bloomberg, they released BuckleScript for JS development. Not sure if that caught on though.

Here's an example of the distinct nature of Smalltalk's message passing:

Control structures

Control structures do not have special syntax in Smalltalk. They are instead implemented as messages sent to objects. For example, conditional execution is implemented by sending the message ifTrue: to a Boolean object, passing as an argument the block of code to be executed if and only if the Boolean receiver is true.

The following code demonstrates this:

result := a > b ifTrue:[ 'greater' ] ifFalse:[ 'less or equal' ]

https://en.wikipedia.org/wiki/Smalltalk

Never mind, missed your point about not being parallel.

Your tool looks nice, but it doesn't seem to parallelize the work in any way.

Google style guide has me sort of leaning to always using ++i:

https://google.github.io/styleguide/cppguide.html#Preincreme...

Once you do that, you more or less recreate C++. IMO C vs. C++ is fundamentally an issue of RAII and arguably templates. This proposal would add RAII to C.

LMDB is a storage engine whereas SQLite is a small database. There is even a version of SQLite that used LMDB as the underlying storage engine: https://github.com/LMDB/sqlightning.

Google started the trend of LSM with its release of leveldb. But leveldb hasn't been updated in a long time. Facebook forked leveldb and renamed it to rocksdb. Those are the only two LSM databases I know of, and IMO they are really the same thing. Meanwhile, lmdb vs. rocksdb/leveldb is a frequently asked question that seems to have no clear answer. Test on your hardware to find the best solution for your use case.

I just don't understand how this is possible. The only way to implement Dijkstra's algorithm in less than O(|V|^2) time is using a min-heap. In practice it might be rare to use heaps over ordered sets but it is one of the first tree structures I was taught in my data structures course.

I imagine this is about tgmath.h. I've found the use of the word generic a bit misleading there.

OK I see your point. Worst case scenario, you force the caller to pass a destructor as an additional argument (e.g. ArrayList(T, fn(*T))) C++11 allows for this in the smart pointer classes.

Having used Zig a bit, and C++ for years, I personally believe that this sort of scenario is pretty rare. You can always add a no-op dealloc method to your type if you want a generic function to handle it correctly. Moreover, Zig has awesome metaprogramming support so you can probably think of a way to check the type parameter for a dealloc method and only generate the dealloc call for those types.

I usually agree, but at least Zig has something new to bring to the table (allocation safety).

I used to be a bit interested in astrophysics, so I can't vouch 100% for this being accurate, but it's my understanding:

The universe isn't the penny, it's the balloon. Physicists believe we are living on the surface of a hypersphere. One important consequence of this idea is that the big bang didn't occur at a specific point in our 3D space, but at the center of the sphere.

Furthermore, the concept of a balloon expanding vs. deflating is a bit of a misconception. The argument used to be that whether or not the balloon is expanding, depending on the rate of the expansion, gravity could eventually win out and cause the matter to collapse back together (big crunch scenario). The problem with that theory is that we now know that galaxies are speeding away from us at a growing speed that (not sure the exact details, probably based on red shift in light from nearby galaxies). So the idea of gravity winning out was not based on evidence, just one of a number of possibilities, but the evidence proved it wrong beyond a doubt.

Shameless plug: why not use H3 (https://github.com/uber/h3)?

I work on Jaeger at Uber. In short, OC is not a standard, OT is a standard. It's like asking what is the difference between HTML5 and a web browser. HTML5 is a standard for developers to use when developing web pages, allowing rendering on a number of different web browsers, whereas a single browser constitutes a single implementation. At the moment, OpenCensus is like a web browser not accepting HTML5 and demanding web developers adopt a custom markup language. If they would adopt the OpenTracing API, developers could instrument an application once, and switch between Jaeger and OpenCensus with no changes in the code. Clearly, I am biased against this approach as I have spent considerable time working with the OpenTracing project to make it the de-facto tracing API and OpenCensus is kind of breaking that.

About OpenCensus, "Open" seems to mean open source and census was the original name internally at Google (there is evidence for this in gRPC git history where it was just census). Anyway, we are waiting on OC to adopt OT, but they don't seem to be interested at the moment.

My guess of how this evolved: LMDB => LemonDB.

I am not referring to the lack of null check. Just the fact that it uses `malloc(sizeof(*x))` instead of using `malloc(sizeof(Type))`.

I understand the question, but as @AndyKelley taught me (https://github.com/ziglang/zig/pull/993#commitcomment-289183...), it is actually worse to zero a value unnecessarily if you can use Valgrind/sanitizers to check for uninitialized values. Initializing the value as zero will prevent the detection of a bad value.

To be fair, the way malloc is used is actually the preferred way. If you change the type of the pointer variable, the malloc is still valid.