eyegor

This looks pretty good. Here's another one to check out if you want something thinner (more terminal space).

https://mplusfonts.github.io/#mpluscode

Could mean a long time, or could not. There have been new bacteria/fungi discovered around chernobyl which subsist on gamma radiation. It's not like evolution of new processes are guaranteed to happen slowly, it just seems unlikely to happen quickly.

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

Depending on how far in you are, starlite/litestar has good documentation and offers another "batteries included" framework. Performance wise it's about the same and the stack is about the same. Fastapi suffers from the "one solo dev in Nebraska" paradigm (check out open prs and old tickets). For me the main draw of litestar is the batteries + better docs + more active development with multiple developers vs most other python web frameworks.

Does the zig compiler have many fancy bits? I was under the impression the c support was a "nothing special" compiler that punted to llvm for optimizations.

Hmm I don't remember if we did dom manipulation in there. It was definitely used for video streaming though. There's a good chance we only used it for mjpeg and canvas shenanigans.

I can tell you that it still works in chrome, this method was used by one of my coworkers as a quick and dirty hack until we had time to implement a real solution for data streaming. It worked fine in all major browsers ~2 weeks ago.

I wish sqlite was performance focused. Perf is pretty much always worse than a db server, even after tuning the pragmas (the way it locks tends to limit single threaded perf and concurrency). Main benefit of sqlite is just its portability since you can easily embed it. It's nice for slapping a db backend on a client installed app, where trying to spin up a db server would be problematic.

There's probably an extension for permissions in sqlite but out of the box the db files are plaintext (you need an extension for that).

Good starting point for extensions: https://antonz.org/sqlean/

Sorting is pretty common in the numerics world because a lot of algorithms or techniques can be optimized heavily with sorted inputs. You either get to skip steps or bisect the dataset. Sort of like how most fast fft implementations will run 10-20% faster if you pad vectors to reach a power of 2 length. A typical "preprocess pipeline" would involve splitting vectors into power of 2 sizes or padding them to maximize cache lines, normalizing (and often mapping to an integer domain), and sorting.

Unfortunately this is not true in numerics. Lots of stupid heavy cfd/fea type workloads parellize well but aren't gpu accelerated. The reasons aren't clear to me, but a lot of the popular solvers are cpu only and involve mostly fp calcs. There are a few solvers that use gpus but they tend to be less accurate in exchange.

Just self host the community edition of gitlab. It's miles better than gitea. It's got ci pipelines, it's got a pretty robust issue tracker, it's got wiki pages, it'll integrate with ldap/ad for authentication, it's got a package repository for self hosting libraries, it's got releases, it's got a service desk to make email -> ticket pipelines, etc.

You might be surprised to learn that dell "hpc engineers" (or maybe HPE?) have attempted to sell me hardware using that exact logic to compare servers.

People should really avoid the hype in most cases, mojo is basically its own language right now despite its "python superset" marketing bs. It's vaguely like python except for: no classes, no list/dict comprehensions, no lamba functions, tuples are messed up, no global variables, variable capturing scopes are not what you'd expect, no yield/generators, no async for/async with, etc. There's a long list of common python features it doesn't support. In addition, it's closed source and "sign up for access". This thing is the next V in my opinion.

https://docs.modular.com/mojo/roadmap.html

Although that's garbage for factual tasks, the creative writing behavior is a perfect fit for fleshing out dnd characters for example. On the other hand, Google is a search/ad company... I'd think they'd be the most interested in integrating search/facts into an llm. Hallucinating details about your customers is a good way to cause problems (some lawsuits already filed).

Requirements feels like a dirty hack but it does work fine. It has ==, ~=, and >= for version numbers, as well as allowing you to flag dependencies for different target os, etc. And then you can add setup.py if you need custom steps. But yes, it feels dirty to maintain requirements.txt, requirements-dev.txt, etc.

Poetry is the most common solution that I've seen in the wild. You spec everything using pyproject.toml and then "poetry install" and it will manage a venv of its own. But you still need to tell people to "pip install poetry" as step 0 which is annoying.

If you don't care about deploying python files, and rather just the final product, I'd recommend either nuitka or pyinstaller. These are for bundling your project into an executable without a python runtime needed (--onefile type of options for single file output). Neither supports cross compilation though.

How are the spice integrations for kicad now? I haven't used it in probably 10 years so I'm not sure where it's at anymore. I also had trouble using it for laying out traces where length/resistance was critical (high frequency signaling). Altium has been the only thing I've touched recently, but I also rarely do circuit design now, so a "friendly" interface is nice. That's why I prefer using fusion 360 to solidworks or nx.

CUDA had a lot of inertia and opencl brought half baked docs and half baked support out of the gate. If they had focused on simplifying their api to be more user friendly for the 80% use case it could've been a success. Opencl always looked nice on the surface but a few hours in and you've exhausted the docs trying to figure out what to do and there's no good example code around. Of course if they really wanted it to succeed they would've built a Cuda to opencl transpiler for the c api or at least a comprehensive migration guide. I'm not convinced anyone involved was trying to make it popular.

Yes, the sqlite defaults are quite terrible out of the box. I'm not sure why they never changed them, it will start choking at 5k inserts where other dbs can do 100x that (and so will sqlite in wal and a few other settings). Getting it to perform well in high traffic scenarios would be a lot of effort. I struggle to get it to be vaguely performant in embedded use cases and often roll my own poor man's version unless I really care about data integrity (which is rare).

Unfortunately I don't control all of the clients and I'm using self signed certs now. It's just a hassle having to explain to non cs folks how to click past the unsafe prompt which looks to them like an error.

Meanwhile I can hack together a poor man's webrtc by sending raw packets over websockets and playback works just fine. I just lose all the real benefits of webrtc (robustness, udp vs tcp, etc.). It feels like it should be possible to work around "secure context" nonsense since I don't access anything on the clients, they just play back a stream from the devices. But chrome/ff tends to block the ice handshake in http mode.

The service/webserver is running on the device, and clients connect via let's say a cell phone to the devices wifi network. The client talks to the webserver via a wifi network from the device. I don't think there's any way to trick the client into thinking the device is localhost? Maybe some HSTS shenanigans?

Since you seem familiar with it, do you think it's possible to run a webrtc connection over http in a modern browser? I tried for a while to make this work but I gave up because it seemed like in js land it tries to use the getUserMedia apis which aren't allowed in an insecure context. The reason why I was trying was to stream audio + data locally from a device that emits its own wifi network (fully offline due to environment restrictions). It seems dumb to have to serve invalid self signed certs just to set up a webrtc ice handshake.

Yeah but google also became wildly successful to the point that they blow money on ventures with no real businesses plan and give up two years later when they can't turn a profit. They effectively have a blank check at all times. They're more like a businessman who's addicted to making money at the expense of all their personal relationships.

$10k is kind of a crime for individuals. For businesses, absolutely, high prices for critical tools with support contracts is a no brainer. I just about coughed up a lung when I heard how much my company pays for 2 floating licenses of specialized engineering software (six figures per year). But in terms of ROI, it's easy to justify.

Your robot could easily sell at 20-30k. If you add some kind of calibration/support service to guarantee whatever operating parameters, you could charge a subscription on top of that. Test equipment is normally fairly expensive and specialized, and no one who runs tests in a commercial environment wants to be in a situation where they are their own checks/balances. So even though they could easily build/maintain test equipment themselves, companies will avoid it if possible. It's why businesses will buy the $5k name brand multimeters, test probes, etc instead of the $200 no name one with the same specs.

Depending on your needs, there are a lot of alternatives now. Orange pi or rock boards are fairly similar but much more powerful than the rpi. However they don't compete in the pi zero class, they compete with the higher spec pi boards (4b). If you want a pi zero competitor, I'd suggest the esp32-s3 based boards such as the lilygo t display s3. There are a lot of other options, these are just some that I've used.

So why would someone choose observable plot over other libraries, for example chartjs? I don't see any comparisons or arguments in the docs [0] that acknowledge the other big js charting libraries.

If you want specifics, I tend to use chartjs for real time data visualization. I often find it tedious to add markup graphics in real time (for example, to draw attention to or highlight anomalies).

[0] https://observablehq.com/plot/why-plot

Not sure, I think I've only used the version they distribute on pip. Which can be a bit obnoxious if you have to build the python cryptography package for your target os/platform but if you don't it's a fairly minor install.

There are quite a few other options besides certbot, I was just suggesting it as a "install + one liner" for adding auto renewing ssl certs to a server.

https://letsencrypt.org/docs/client-options/

Certbot is practically a one liner in a cron job once you fill out the config.

Ruff [0] is the best linter around for performance but I'm not sure how well it fills the static analysis role. It has a vscode extension which updates the linting with no noticeable lag but it isn't a full fledged type checker. Their suggestion is to run ruff through the vscode extension and then manually run mypy or whatever type checker on occasion (maybe as a pre commit hook?).

[0] https://github.com/charliermarsh/ruff

Deluge still works the best in my opinion, and it's open source. Not super popular though, most people use the *torrent named clients.

You're protecting your inputs and outputs. If you have a model that's designed to run with sensitive data but you want to don't have the compute power to run it locally, what do you do? Putting the model on a cloud provider means their system would see your sensitive data, which may be unacceptable for contractual or legal reasons. This lets you send the inputs encrypted, receive the outputs encrypted, then you can decrypt the outputs in your weak but trusted environment.

Despite ~60 years of updates, the fortran language still isn't case sensitive.