It's because distances and time durations contract the faster you travel. The passangers don't experience faster than light speeds, just shorter distances.
This is how the twin paradox gets solved. The twin that leaves earth sees the trip as if it was shorter in both directions, so from their perspective it makes sense that they aged less than the twin that remained on earth.
Also, if you had infinite energy and you could travel at the speed of light you wouldn't feel any movement or time passing during your trip, it would feel like instantly teleporting from one place to another. Photons wouldn't feel their existence if they could. From their perspective they are produced in one place and instantly absorbed in another place.
I get what components are supposed to do, but how does wasm currently talk with the browser and javascript code? Can it manipulate the DOM and execute asynchronously (like promises) or is it just a black box that receives some data and returns other data synchronously?
Yes, I tried to make video accel work but didn't succeed. There's a vaapi driver for vdpau, but it crashes when I try using it. In some firefox issue there was someone mentioning that video accel needs dmabuf, which needs gbm, so the 490 driver might solve the issue.
Now that you mention, I did have an issue after a suspend. All text was missing inside firefox, restarting it resolved the issue. But I keep my laptop plugged in and open 99% of the time with presentation mode enabled, so this is extremely rare for me.
I already force-enabled EGL in firefox 93 on Arch Linux with the 470.74 nvidia driver, and the performance is stellar compared with what it used to be. Before EGL all desktop applications (including firefox) would stutter when a video was playing in firefox.
In ML you often need to stream data from the training set because you can't hold it all in memory. Many times I noticed that my GPU would sit idle because python was busy loading more training examples. With proper multi threading you can have one or multiple threads loading data into a queue feeds the GPU thread. This is something extremely simple to do in any programming language that has doesn't have a GIL. And you can't just use a library for this, loading and preprocesding data is very specific to your application, and writing just this part in C completely defeats the purpose of choosing python in the first place.
What if this is just an artifact of the DNA sequence assembly. They soil they collect probably contains DNA from many organisms. The sequence assembly algorithms are likely looking for patterns in noise [1].
A pattern that I like to use in toy projects is to have an events endpoint and just send the newest event cursor through a notification channel (e.g. webhooks) when a new event occurs. You get new event quickly, you don't have to keep connections open for long-polling, and you can keep polling with a low period in case the event channel stops working for some reason.
Why have it 2 strokes away when it can be 0 strokes away? I don't mean this for every definition, just for top-level definitions and class members and methods. I'm a fan of type inference and clean code too, but I also want the code to be documented and human-readable.
>Grain is strongly typed (with a typechecker from OCaml)
I tried working on a complex OCaml project where the author had written as little type annotations as possible. It was a horrendous experience because it was impossible to determine the type of most variables by reading the code. I had to use a language server to obtain type information and I had to consult it very often. I hope they don't proliferate this nonsense and instead require type annotations for top-level definitions like Haskell does.
First time I've seen this, looks like its brand new (python 3.8). The problem now is that you have to serialize/deserialize your data and modify your numpy/pytorch code to use the shared memory. It's an improvement in performance, true, but not as fast and easy as just sharing variables between threads.
Well the core of those libraries is already written in C or C++, so it's a matter of writing bindings to interface with the core. I think tensorflow and pytorch today have some C/C++ bindings, but I don't know how good they are.
I wish machine learning would have become mainstream on a language with more competent multithreading capabilities than python. During my machine learning course I knew I could squeeze more performance out of my code by parallelising data preprocessing and training (pytorch), but python cannot do proper multithreading. The multiprocessing module requires you to move data between processes, which is slow.
A similar tool that I really like is meld (https://meldmerge.org/). It has a GUI, really nice visual indicators, allows you to view the entire file and directory trees and you can jump between diff chunks using alt + arrow up/down.
>When internet commentators see odd behavior that they don't understand, why do they assume that the most parsimonious explanation is that management must be a bunch of drooling morons?
I don't think most internet commentators have the patience or even the interest of painting an accurate picture. Most of them are shitposting.
My main issue was when making code modifications. If I wanted to add an argument to a function I would have to find and fix tens of calls to that function in order to convince the compiler to infer the type that I wanted so I could use its error messages to find and fix the rest of the calls. In hindsight, I should've written annotations by hand for functions I had to modify.
Pretty great until you come across a project with thousands of lines of code and 0 type signatures. At least Haskell warns you about top-level declarations without type signatures. This is the error of the developer, true, but I think compilers should steer people away from doing such things.