What even is a good experimental design for probiotic tea? Brew -> agitate in hydrochloric acid & digestive enzymes for X minutes -> mix with billions of existing gut microbes (that may kill this microbe or out-compete it for resources) and incubate at body temperature -> count the number of new colonies of this particular microbe?

#pragma is a real keyword in C but # is just a comment in python - why not use a pythonic @decorator?

Vendoring a library like this into an app seems like a lot more toil than just writing the native multiprocessing python code, or using something built for number crunching like arrayfire or numpy

In my world, I think the worst possible outcome would be a java.util.json library that does 50-95% of what I currently do with GSON or Jackson. In that scenario I still need an external dependency, and I can either ignore java.util.json or turn a codebase into an error-prone mix of both.

Maybe a good set of design considerations for java.util.json would be “what does this API need to run a CRUD app written in modern java?” Parse requests from the web, send responses to the web, and serialize/deserialize data from X database (e.g. if noSQL or jsonb). In my head “in modern java” would mean that JSON is converted to records at application boundaries

Since there wasn’t a link to the source code in that post, can you help me understand this - for the SLF4J baseline is your logger impl a console appender, a file appender, or a network service like an OTel collector? Does any of that matter for GC context?

I think I prefer Springboot AOP, especially with SpEL.

The term “cross cutting concerns” is thrown around a lot when discussing AOP. Took me a while to appreciate just how powerful it is in this context - sprinkle an AOP annotation here or there to avoid massive refactors in a large codebase, or avoid rewriting classes in a way that makes your classes themselves “cross cut concerns.”

Sonarqube or CodeQL reports might tell me what percentage of a repo is duplicated code, and a large percentage of that is in src/test/java

I find that a lot of the time this is not just some flippant observation but a clue that I should be using a mechanism like @ParameterizedTest instead of @Test, so I rewrite those tests in a way that makes them easier to set-up, define parameters/constraints, inputs, and outputs. Sometimes it does get a little convoluted as you either use a lot of naked Arguments.of() or define test-class-scoped nested records to encapsulate test parameters, inputs, expected outputs, etc.

Do you need the 15V input to torch the capacitors and run the relays? Could I use a 5V USB ESP32 dev board instead, and just put a boost circuit or MOSFET on the relay load side for the explosion circuit when it needs to go off, or are there other components that need the higher voltage?

I feel like the importance of padding is a bit understated on this page - BLAS and LAPACK require LDA and LDB parameters, and you can definitely tune these to the page size of a particular system/machine to improve performance.

When working with BLAS/LAPACK or other matrix libs, you can often apply a little linear algebra to reshape the problem rather than the input data to avoid a transpose altogether

Something worth thinking about that since you mentioned it’s geared towards “scientific” data streams. If we’re talking about precise measurements from instruments, your sensor is typically an analog signal which you digitize. Digitizers exist that can output floats, but DACs used in industry like a Rincon or Alazar (that sample at multiples of 100 MHz) prefer to output quantized shorts or ints that are rescaled to a float with a magic number (i.e. 32767/pi for a phase measurement, or gain/(16 mA) for industrial transducers) somewhere down the line. I bring this up because you pointed out your max throughput is about 120 MiB/s which would make it a big bottleneck for scientific data coming out of a digitizer that can pump out 800-1600MiB/s. 120 MiB/s throughput of doubles is not really that high for CPU level computations or network Tx bandwidth on modern hardware.

For an example of this look for items on eBay whose shipping method is “freight.” As a buyer (or sometimes seller, if your buyer is clueless) of one of those items, it is your responsibility to arrange an LTL freight carrier (flatbed or liftgate truck). Fastenal and Uber freight will accept 1 pallet, up to a certain weight limit; you may even be responsible to bring it to a freight hub yourself. Above that size you’re on your own calling trucking companies, and renting a forklift or crane when you actually find a trucker.

It’s a smaller market than small packages, but more revenue per transaction. And if you figure it out and get it up and running, eBay (e.g.) might allow buyers and sellers to automatically select your service as the shipping method instead of black box “freight.”

Source = my personal experience 1. selling a metal building kit on eBay that the local zoning board would not let me erect. 2. Buying a large greenhouse kit online

Seems like a great product, potentially quite powerful for automated testing of SPAs.

Maybe I’m overthinking it but I can’t quite envision a use case where a python service and C++ service would be sharing a filesystem

There’s generally not a faster version of inverse trig functions to inline, but it might optimize some other stuff out.

Unrelated to that, I’ve seen implementations (ie julia/base/special/trig) that use a “rational approximation” to asin, did you go down that road at any point?