collision | 💥 Collision is a beautiful error reporting tool | Command Line Interface library

Do you really need to store your desired symbols in an environment? It seems if you are just storing symbols/expressions then you can more easily do that in a container like exprs and then can use the with_bindings function to replace some values. So if you have

Extending the Object prototype is a dangerous practice.

You have obviously done some research and found that the community of javascript developers overwhelmingly considers it to be a very bad practice.

If you're working on a personal project all by yourself, and you think the rest of us are all cowards for being unwilling to take the risk, then by all means: go ahead and modify your Object prototype! Nobody can stop you. It's up to you whether you will be guided by our advice. Sometimes the conventional wisdom is wrong. (Spoiler: in this case, the conventional wisdom is right.)

But if you are working in a shared repository, especially in any kind of professional setting, do not modify the Object prototype. Whatever you want to accomplish by this technique, there will be alternative approaches that avoid the dangers of modifying the base prototypes.

The number one job of code is to be understood by other developers (including yourself in the future), not just to work. Even if you manage to make this work, it is counterintuitive, and nobody who comes after you will expect to find this. That makes it unacceptable by definition, because what matters here is reasonable expectations, NOT what the language supports. Any person who fails to recognize that professional software development is a team effort has no place writing software professionally.

You are not going to find a technical limitation to extending the Object prototype. Javascript is a very flexible language -- it will give you plenty of rope with which to hang yourself. That does not mean it's a good idea to place your head in the noose.

TL;DR: np.fromfile and np.frombuffer are not optimized to read many small buffers. You can load the whole file in a big buffer and then decode it very efficiently using Numba.

The main issue is that the benchmark measure overheads. Indeed, it perform a lot of system/C calls that are very inefficient. For example, on the 24 MiB file, the while loops calls 601_214 times np.fromfile and np.frombuffer. The timing on my machine are 10.5s for read_binary_npfromfile and 1.2s for read_binary_npfrombuffer. This means respectively 17.4 us and 2.0 us per call for the two function. Such timing per call are relatively reasonable considering Numpy is not designed to efficiently operate on very small arrays (it needs to perform many checks, call some functions, wrap/unwrap CPython types, allocate some objects, etc.). The overhead of these functions can change from one version to another and unless it becomes huge, this is not a bug. The addition of new features to Numpy and CPython often impact overheads and this appear to be the case here (eg. buffering interface). The point is that it is not really a problem because there is a way to use a different approach that is much much faster (as it does not pay huge overheads).

The main solution to write a fast implementation is to read the whole file once in a big byte buffer and then decode it using np.view. That being said, this is a bit tricky because of data alignment and the fact that nearly all Numpy function needs to be prohibited in the while loop due to their overhead. Here is an example:

Discussed here: NPM: ENOENT: no such file or directory, rename

Possible reason, some node process is running. Check the running processes.

Easiest fix, delete package-lock.json and then reinstall packages. If this does not work, refer the given link for other possible resolutions and explanations.

The problem is this line:

You don't see a list of Haskell built-in operators for the same reason you don't see a list of all built-in functions. They're everywhere. Some are in Prelude, some are in Control.Monad, etc., etc. Operators aren't special in Haskell; they're ordinary functions with neat syntax. And Haskellers are generally pretty operator-happy in general. Spend any time inside your favorite lens library and you'll find plenty of amusing-looking operators.

In terms of (#), it might be best to avoid. I don't know of any built-in operators called that, but # can be a bit special when it comes to parsing. Specifically, a compiler extension enables # at the end of ordinary identifiers, and GHC defines a lot of built-in (primitive) types following this practice. For instance, Int is the usual (boxed) integer type, whereas Int# is a primitive integer. Most people don't need to interface with this directly, but it is a use that # has in Haskell that would be confused slightly by the addition of your operator.

Your (#) operator is called (>>>) in Haskell, and it works on all Category instances, including functions. Its companion is (<<<), the generalization of (.) to all Category instances. If three characters is too long for you, I've seen it called (|>) in some other languages, but Haskell already uses that operator for something else. If you're not using Data.Sequence, you could use that operator. But personally, I'd just go with (>>>). Any Haskeller will recognize it pretty quickly.

The Java memory model is sequential consistency in the absence of data races (which your program doesn't have). This is very strong; it says that all reads and writes in your program form a total order, which is consistent with program order. So you can imagine that reads and writes from different threads simply get interleaved, or shuffled together, in some fashion - without changing the relative ordering of actions made from the same thread as each other.

But for this purpose, every action is a separate element in this order. So just by the mere fact that aBoolean.get() and aBoolean.compareAndSet() are two actions and not one action, it is possible for any number of other actions by other threads to take place in between them.

It doesn't matter whether those actions are part of a single statement, or different statements; or what kind of expression they appear in; or what operators (if any) are between them; or what computations the thread itself may or may not be doing around them. There is no way in which two actions can be "so close together" that nothing else can happen in between, short of replacing them by a single action defined to be atomic by the language.

At the level of the machine, a very simple way this can happen is that, since aBoolean.get() and aBoolean.compareAndSet() are almost certainly two different machine instructions, an interrupt may arrive in between them. This interrupt could cause the thread to be delayed for any amount of time, during which other threads could do anything they wish. So it is entirely possible that threads #1 and #2 are both interrupted in between their get() and compareAndSet(), and that thread #3 executes its set in the meantime.

Caution: Reasoning about how a particular machine might work is often useful for understanding why undesired behavior is possible, as in the previous paragraph. But it is not a substitute for reasoning about the formal memory model, and should not be used to try to argue that a program must have its desired behavior. Even if a particular machine you have in mind would do the right thing for your code, or you can't think of a way in which a plausible machine would fail, that does not prove that your program is correct.

So trying to say "oh, the machine will do a lock cmpxchg and so blah blah blah and everything works" isn't wise; some other machine you haven't thought of might work in a totally different fashion, that still complies with the abstract Java memory model but otherwise violates your x86-based expectations. In fact, x86 is a particularly poor example for this: for historical reasons, it provides a rather strong set of instruction-level memory ordering guarantees that many other "weakly ordered" architectures do not, and so there may be many things that Java abstractly allows but that x86 in practice won't do.

One way is to generate a lock in your target database. Here's an example for MSSQL.

I chose a on-run-start: hook. This hook attempts to grab a lock for dbt that lasts for the duration of the DB session.

dbt_project.yml

Granted you do not care about abbreviations, you can match either a char other than ?, ! and ., or a link-like substring any zero or more times before and after a specific filter string: