ysleepy

I just use a French Press.

A chip inside a USB-C cable isn't that special, high-end thunderbolt cables have (active) signal shaping chips in both ends.

Example tear down of an Apple thunderbolt 4 cable: https://youtu.be/LBWnb0ZIlEA?t=276

Some computers ship with an implementation of this using inductor coils which whine depending on the load :D

Does Cython run on the GPU?

I used TF, Torch and Jax to implement a monte carlo sampling thingy and Jax was by far the most readable and performant.

I think the Cython use-case is kinda subsumed by the pypy jit right?

While I hate Spring, it is much easier to deploy than django/python projects.

Spring is a single-file deployment and apt install openjdk, while django needs a venv or a whole container, dependency installs on the host etc. it's not even a contest.

Same for me, but MacBook Air M1 and T7 Shield. But it doesn't always seem to be the cable. One of Samsung's was definitely broken and they replaced it, but it keeps happening with other cables too.

This is incredibly cool.

I love how good the tooling is in the java/jvm ecosystem. Last time I was this blown away was with jitwatch ( https://github.com/AdoptOpenJDK/jitwatch )

FlowTracker reminds me a little of taint analysis, which is used for tracking unvalidated user inputs or secrets through a program, making sure it is not leaked or used without validation.

search keywords are "dynamic taint tracking/analysis"

https://github.com/gmu-swe/phosphor

https://github.com/soot-oss/SootUp

https://github.com/feliam/klee-taint

They only guess the performance difference is because of GC, generating code on the fly and compiling it to classes in your hot path is also probably not cheap.

Memory allocation/deallocation overhead is always present, just look at different allocators, fragmentation issues and so on. Using a GC is not intrinsically much different performance wise.

I mean, the 9950X has around 2x the single core perf of the 3950X and 2.5x multi core in geekbench 6. This is pretty great my my eyes. Even Apple isn't doing yearly architecture refreshes anymore.

So, very, very similar to the 9950X score (100.x%).

https://browser.geekbench.com/v6/cpu/compare/7375555?baselin...

But without AVX512 and possibly much higher power consumption.

It is kinda exhilarating to see how much competition is going on with AMD, Intel, Apple and Qualcomm.

The (discontinued) microsoft 4k wireless display adapter works pretty well for me in combination with Windows. much more responsive than chromecast or airplay.

I wonder why ZFS is marked as not having de-dupe (deduplication).

AFAIK ZFS has had deduplication support for a very long time (2009) and now even does opportunistic block cloning with much less overhead.

It appears disabling trust roots is possible on my samsung Android at least.

Nuclear fusion is similarly easy, you just have to apply enough pressure and heat to easily acquired hydrogen isotopes.

The same way that it's fine to use `eval()` to parse JSON I assume.

Shelve uses pickle, which executes untrusted code without asking.

These types of serialisation are a technical debt from day one. There are countless stories of ecosystems doing a very painful migration to get away from it. See java, or recently the ML model files trying to go to safetensors etc.

I'm not logged in on macOS, works pretty well.

Looks really nice.

Not sure people will pay for "just" a nice (java)doc renderer/ui.

Maybe some sort of API diff for migrations or a maintained collection of OpenRewrite migrations could be a good value add, however that's a lot more complicated to provide.

For the record, can you confirm that the telementry does not contain any sort of installation or system ID and the telemetry endpoint never at any point records the IP address?

A lot of companies claim gdpr compliance while blatantly disregarding it.

I think forcing telemetry on free users, after the AI debacle and recently having moved the headquarters out of moscow for trust reasons, leaves a bad taste.

I assume the telemetry data contains some sort of installation identifier and without hard evidence I will assume the IP address as well.

I don't think that can be GDPR compliant, personal data cannot be used as a form of or alternative to payment afaik.

That was a rather wholesome read, focused on providing insight while being respectful.

I assume it's apfs copy-on-write file clones not technically hard links. Hard links have the same inode and changes would be reflected by either path.

https://eclecticlight.co/2020/04/14/copy-move-and-clone-file...

I simply bought 4x32GB ddr4 memory (~200 bucks) for a normal desktop mainboard and a high-thread-count cpu.

You can experiment with a lot of models, it's just going to be slow.

With ddr5 you can even go higher with 48GB modules.

Otherwise I got a 3060 12G, which can be had for 200€ used.

Its a very affordable setup.

ROCm or HIP? Does it start out with porting a lot from CUDA etc. or starting fresh on top of the AMD APIs?

How much of the project time is spent on that compute API stuff in comparison to "payload" work?

Redundancy is handled at a higher layer. They are probably using ceph on top.

wow, that is a great hack

Reminds me of the "The Architecture of Open Source Applications" series.

It has some interesting insights.

https://aosabook.org/en/

The premise of migrating away from an SPA framework might make it seem weird, but I don't think that's the common adoption path.

There are a lot of server side templated web facing applications out there, and htmx provides a simple and gradual UX improvement with very litte investment.

It depends on what you deem "internal tooling" but a lot of b2b software isn't built to be flashy.

I appreciate the premise, aria is a powerful tool.

However I immediately have two concerns:

1. Why would the author use a screenshot obviously downloading copyrighted material instead of linux ISOs? It's either on purpose, which I support, or lack of foresight.

2. As much as I love the JVM, it feels like the wrong platform for this UI. It's a bit of command routing and server side simple html rendering. Go or something would do just fine. The name says tiny, but it ships a UI in a 100M+ docker container, for aria, a 5M cli tool.

If I was building it for myself, I would have no issue with the larger overhead, because I'm comfortable with the ecosystem, but for other people to run it's not a great trade off.

Edit: Sorry, I think this reads pretty one-sided in retrospect, feel free to disregard. I'm trying to be less negative.