mathiasgredal

Not exactly related to Ruby on Rails, but why doesn’t there exist a way to run a Python TKinter app in the browser using WASM?

I have a medium sized dependency-free TKinter program written in Python, and AFAIK there is no way to run it in the browser.

In a society where the abuse of human labour was factored into the cost of the product, the 8-inch fab line would have been shut down, since the cost of the 8-inch wafers would now be prohibitive and not be competitive with the wafers from the 12-inch line. This in-turn would mean that customers would have to switch over to the 12-inch wafers.

We are not supposed to compete on who can abuse their workers the most to improve efficiency and to cut costs. Thankfully, knowledge work does not seem to scale the same way as manual labour, meaning that more abuse of the workers does not mean more output over the long-term.

We have a replacement for CUDA, it is called C++17 parallel algorithms. It has vendor support for running on the GPU by Intel, AMD and NVIDIA and will also run on all your cores on the CPU. It uses the GPU vendors compiler to convert your C++ to something that can natively run on the GPU. With unified memory support, it becomes very fast to run computations on heap allocated memory using the GPU, but implementations also support non-unified memory

Vendor support:

- https://www.intel.com/content/www/us/en/developer/articles/g...

- https://rocm.blogs.amd.com/software-tools-optimization/hipst...

- https://docs.nvidia.com/hpc-sdk/archive/20.7/pdf/hpc207c++_p...

Having looked briefly at the code I still think C++17 parallel algorithms are more ergonomic compared to OpenMP: https://rocm.blogs.amd.com/software-tools-optimization/hipst...

GPGPU programming seems to be in a really good spot with the widespread adoption of C++17 parallel algorithms by GPU vendors.

Now, I can just program against this API using standard C++ code, that interacts with CPU heap allocated memory, and get really performant computation on it using standard map-filter-reduce semantics.

Which begs the question, if attractiveness is such a big predictor of success, why hasn’t everyone evolved to become very attractive? The evolutionary pressure for increased attractiveness should be very high, since it affects so many areas of your life, from career success, to getting partners etc.

Is it that the speed at which we evolve to become more attractive is superseeded by our ability to become better at discriminating for attractiveness?

That was why OP suggested to have 2 motors on each joint, going in opposite direction. The problem with this is that you now have twice the amount of motors.

Just use bsdtar, which will convert a tar archive to cpio: https://unix.stackexchange.com/a/581014

I have used it to convert docker images to Linux bootable initramfs archives for Rpi4.

If you are already using gRPC in your codebase, then you can define your enums with Protobuf, which does much of the same as the tool shown in this article.

Looks like great changes overall. Sadly they haven’t added columns to Dolphin, which is my only complaint from switching to KDE from macOS.

You can get an S2 mini dev board for a $1 including shipping[1, 2]

[1] https://imgur.com/HUt2qLY [2]: https://www.aliexpress.us/item/3256804697715980.html?

Not possible, unless you want to do it using an emulator and external memory. The lowest you can go for Linux is probably an ESP32:

https://web.archive.org/web/20230515075935/http://wiki.osll....

https://github.com/jcmvbkbc/linux-xtensa/commits/xtensa-6.4-...

Well, if I found an unpatchable zero-click RCE exploit on an iPhone, then that would have a major effect on the stockprice when the news is announced. It definitely seems like it would be insider trading if i used that knowledge to do options trading.

Yeah, but regular package binaries get nuked pretty quickly to make space for new ones, especially on mirrors.

Sure, but how useful is that when you can’t install any packages, since the package repositories only host packages for supported versions.

When a distro goes EOL, the package repositories typically move to the next supported version and delete all of the old packages.

Could someone enlighten me on how one goes about testing whether a particular crypto implementation is vulnerable to side-channel attacks?

In high school I implemented a basic ECDH key exchange algorithm, which I compiled to WASM, and it can be tested at the bottom of my blog: https://gredal.dev/projects/elliptic-curves

Using only the WASM blob, without looking at the source code for exploits, how would Alice find Bobs private key?

Just because a compiler cannot prove whether or not a given set of C/C++ is safe, doesn’t mean that an expert in the language can’t write safe C++ and prove that it is actually safe.

Why not just tax stock buybacks the same or higher than regular profits? This would force companies to either increase R&D/CAPEX spending or lower prices.

Will C++17 parallel algorithms be supported?

https://on-demand.gputechconf.com/supercomputing/2019/pdf/sc...

Edit: Nevermind, I think I have misunderstood the purpose of this project. I thought it was a CUDA competitor, but it seems like it is just a shading language compiler for graphics.

I know, but the fact that people can’t even tolerate the inconvenience of an EV gives little hope for public transport, car sharing, bicycles etc.

Yeah, people here don’t seem to realize that burning fossil fuels is the primary driver(~90% of CO2 emission) of global warming: https://www.un.org/en/climatechange/science/causes-effects-c...

Still they can’t be inconvenienced the slightest by driving an EV, even though they have a much lower carbon footprint: https://lutpub.lut.fi/bitstream/handle/10024/163938/Kandidaa... (see figure 4)

I reality we could do much better than EV’s, since their production still has a large impact on the environment, and we should instead be focusing on cycling or using public transport, instead of driving everywhere.

I don’t have much hope for this, given what I see here.

What prevents Apple from just integrating MacFUSE(or a reimplementation) into the their kernel, and then shipping it with the next release?

I have done this, but for some reason Android SDK has to be weird, so you have to download the SDK seperately and then create a properties file in to root of the project with the path to the Android SDK. Everyone then also has to have their own version of this file, since the path is likely different. You also have to make sure that everyone downloads the same version of the SDK. (also the path to the SDK cannot have any spaces)

Why can it not be like other Gradle dependencies, where Gradle will just download the files automatically?

Unless you want functioning airbags: https://www.euronews.com/business/2023/12/21/toyota-calls-ba...

Why is this better than an arena style allocator?

I get that there is a tradeoff with code density, although if you could have an encoding scheme or extended register mode to alleviate this. I was just thinking that if you have e.g a loop where you run out of registers, since you only have 16, then the compiler will swap the values to memory and reuse that register which creates an instruction dependency that doesnt really have to exist.

If the compiler could use the hidden registers, then the cpu would know that it could run this instruction ahead of time.

It is probably not worth it, since it adds a lot of complexity to an already complex system, which is why it isn’t done.

Sure, but wouldn’t it make sense to extend the instruction set to allow the compiler to use these registers instead of reserving them for speculative / out-of-order execution? It was just a thought i had after watching a talk by a compiler guy: https://youtu.be/2EWejmkKlxs?feature=shared&t=2409

I thought modern speculative cpu’s had way more registers than you can normally access. Why does it reserve these registers for speculative execution instead of exposing them to the program if it needs them?

Does anyone know if there exists a tool that can convert tarballs to filesystems and back. I know you can make a loopback device, but it can be pretty hard/impossible to do inside a container, and often requires special flags and privileges.

I have always been bothered with the multinomial layer that picks the next token. It seems like you should be able to stick a classifier in there to detect if the probabilities align with a satisfactory answer and whether the model is unsure of the response. If that is the case, then it should branch out to a bigger model which would compute that single token that it is unsure about, and from that the rest of the response is obvious for the smaller model.

This way you could combine e.g. a 7B parameter model with a 70B parameter model, and get the quality of the larger model while most of the time you are only running the small model.

Edit: You could also store the full probabilities for each token, and then the classifier could detect if it had gone down a bad path, and then unwind the tokens and pick a different path.