I feel like if your body follows the Unix filesystem structure, you have a real problem.

It’s a glob pattern (edit: tried to find a source that actually showed ** in use).

That’s why you have backups.

sudo rm /heart/arteries/**/clot

I wonder why I haven’t seen a standard open-source license for this.

This would be a lot more readable with some paragraph breaks.

I’ve recently been thinking a lot about the recyclability of plastic. I have several stacks of plastic drink cups from various fast food joints in my kitchen; as much as possible, I try to save up and bundle together similar types of plastic before I throw it in the recycling bin, to try to save some sorting effort. And in doing so, I noticed something.

The thing is, a lot of single-use plastics have very similar properties. PETE, HDPE, Polypropylene, solid polystyrene, they’re all used to package similar or identical products. I think they’re more or less interchangeable, and the choice of a given plastic for a given application has more to do with cost, availability and the preferences of the product engineer than any specific material properties of the plastic itself. There’s obviously going to be some exceptions, but I think those are going to be few and far between, and a lot of them could be addressed by switching to other materials.

I think a great first step would be for regulators to encourage/force industries to standardize on one or two types of plastic at most, and eliminate plastics that aren’t worth recycling, like polystyrene. That should reduce the manual labor required by a significant amount once the other plastics are eliminated from the waste stream, and make it feasible to recycle plastics locally instead of shipping them off to a third world country.

I think companies should be taxed or otherwise penalized for the plastic waste they foist on consumers, because often there’s little choice involved unless you want to boycott a company entirely. If I wanted to eliminate plastic cups from my life, I’d pretty much have to stop getting fast food altogether (yes I know I should probably do that anyway, but that’s beside the point). A tax on bulk purchases of plastic may end up being passed down to consumers, but the revenue could be put towards subsidizing production of more renewable materials.

I think food stamp programs could be a strong driver for change on this, as they could refuse to cover products that generate excessive waste. With enough warning, there should be enough time for companies to switch their products to be compliant with little disruption to the consumer.

I’m an open source maintainer part-time. My God how I’ve wanted to call so many people “idiot” straight to their face.

I don’t blame some people for turning bitter. You wouldn’t have much faith in humanity left either, after closing your 100th duplicate issue with a solution that sums up to “read the fucking docs”.

Any highlights from those in the know?

A lot of physical laws are really just the inverse-square law in a new wig.

It was $5k worth of training, and well worth it, since you still remember the lesson.

Yep.

That’s also not the most money I’ve ever unintentionally cost an employer.

The applications I’ve built weren’t designed for serverless deployment so I wouldn’t know. It seems like you pay a premium for the convenience though.

I ran up like a $5k bill over a couple weeks by having an application log in a hot loop when it got disconnected from another service in the same cluster. When I wrote that code, I expected the warnings to eventually get hooked up to page us to let us know that something was broken.

Turns out, disconnections happen regularly because ingress connections have like a 30 minute timeout by default. So it would time out, emit like 5 GB of logs before Kubernetes noticed the container was unhealthy and restarted it, rinse and repeat.

I know $5k is chump change at enterprise scale, but this was at a small scale startup during the initial development phase, so it was definitely noticed. Fortunately, the only thing that happened to me was some good-natured ribbing.

It executes on a native thread in the background. That way it doesn’t stall the Javascript execution loop, even if you give it a gigabyte of data to hash.

I actually wonder how much in the article is actually deliberate misinformation meant to trip up anyone trying to build their own device.

For example, this bit caught my attention:

In modern weapons, the neutron generator is a high-voltage vacuum tube containing a particle accelerator which bombards a deuterium/tritium-metal hydride target with deuterium and tritium ions. The resulting small-scale fusion produces neutrons at a protected location outside the physics package, from which they penetrate the pit.

That seems really finicky to me.

You can apply this same logic to basically all of chemistry:

H: explosive, the main ingredient in stars

O: literally the reason fire is a thing, causes rust and kills cells via free radicals

H2O: I’m so wet, UwU

I once had a spambot @ me and like 100 other people I didn’t know on a repo I’d never touched before.

I reported it for spam and got an email from Github Support within an hour notifying me that they had taken action.

Percutaneous means “through the skin”: https://en.m.wikipedia.org/wiki/Percutaneous

In general, percutaneous refers to the access modality of a medical procedure, whereby a medical device is introduced into a patient’s blood vessel via a needle stick.

Actually, Android doesn’t really use Dalvik anymore. They still use the bytecode format, but built a new runtime. The architecture of that runtime is detailed on the page I linked. IIRC, Dalvik didn’t cache JIT compilation results and had to redo it every time the application was run.

FWIW, I’ve heard libgcc-jit doesn’t generate particularly high quality code. If the AOT compiled code was compiled with aggressive optimizations and a specific CPU in mind, of course it’ll be faster. JIT compiled code can meet or exceed native performance, but it depends on a lot of variables.

As for mawk vs JAWK vs go-awk, a JIT is not going to fix bad code. If it were a true apples to apples comparison, I’d expect a difference of maybe 30-50%, not ~2 orders of magnitude. A performance gap that wide suggests fundamental differences between the different implementations, maybe bad cache locality or inefficient use of syscalls in the latter two.

On top of that, you’re not really comparing the languages or runtimes so much as their regular expression engines. Java’s isn’t particularly fast, and neither is Go’s. Compare that to Javascript and Perl, both languages with heavyweight runtimes, but which perform extraordinarily well on this benchmark thanks to their heavily optimized regex engines.

It looks like mawk uses its own bespoke regex engine, which is honestly quite impressive in that it performs that well. However, it only supports POSIX regular expressions, and doesn’t even implement braces, at least in the latest release listed on the site: https://github.com/ThomasDickey/mawk-20140914

(The author creates a new Github repo to mirror each release, which shows just how much they refuse to learn to use Git. That’s a respectable level of contempt right there.)

Meanwhile, Java’s regex engine is a lot more complex with more features, such as lookahead/behind and backreferences, but that complexity comes at a cost. Similarly, if go-awk is using Go’s regexp package, it’s using a much more complex regex engine than is strictly necessary. And Golang admits in their own FAQ that it’s not nearly as optimized as other engines like PCRE.

Thus, it’s really not an apples to apples comparison. I suspect that’s where most of the performance difference arises.

Go has reference counting and heap etc, basically a ‘compiled VM’.

This statement is completely wrong. Like, to a baffling degree. It kinda makes me wonder if you’re trolling.

Go doesn’t use any kind of VM, and has never used reference counting for memory management as far as I can tell. It compiles directly to native machine code which is executed directly by the processor, but the binary comes with a runtime baked in. This runtime includes a tracing garbage collector and manages the execution of goroutines and related things like non-blocking sockets.

Additionally, heap management is a core function of any program compiled for a modern operating system. Programs written in C and C++ use heap allocations constantly unless they’re specifically written to avoid them. And depending on what you’re doing and what you need, a C or C++ program could end up with a more heavyweight collective of runtime dependencies than the JVM itself.

At the end of the day, trying to write the fastest code possible isn’t usually the most productive approach. When you have a job to do, you’re going to welcome any tool that makes that job easier.

Yeah but Go has the best error handling paradigm of any programming language ever created:

ret, err := do_thing()

if err != nil {
    return nil, err
}

Don’t you just love doing that every 5 lines of code?