skysight-inc/HackerNews huggingface dataset:
My father worked for Pilkingtons when they patented the float-glass process.

Lots of companies tried to copy the process (without licensing the patent). They couldn't, because the patent didn't describe all the know-how needed to make the process work. Companies that licensed the patent got the benefit of an on-site engineer that would help them get their process working. So most "plate" glass was thereafter float glass, made by paying licensees.

That is: the invention was really protected not by patents, but by trade secrets. And unlike with the mediaeval guilds, nobody had to be assassinated.

So it seems to me that in addition to being harmful, patents really are unnecessary; as long as there is also know-how. If there is no know-how, then I don't think the patent should be issued. Therefore, there is no need for patents.
> It's a meta-review of 78 randomised control trials.

If your only tool is meta-reviews of RCT studies, then condoms don't work either:

https://www.cochranelibrary.com/cdsr/doi/10.1002/14651858.CD...

https://jech.bmj.com/content/65/2/100
Why do you think that there are 0 (zero) EU tech companies that have "boomed"?
I find the hint that ChatGPT et al. need government regulation kind of bizarre. What would they mandate? “LLMs can’t be mean”?
When I was growing up every kid watched more or less the same cartoons and played the same games. Life was simpler.

Now as an adult there's too much out there and too little time.

I suspect that this is a big part of why people feel there's nothing good to watch.
Then Germany sends back their own bills?

Cologne has a found WW2 bomb every other week or so, e.g. look at this non-exhaustive press release list: https://www.stadt-koeln.de/basisdienste/suche/?keywords=Bomb...

Most can be disarmed, but some have to be exploded in a controlled manner.

Nowadays I get pushed safety notifications to my phone (KATWARN app) wherever I am in Germany that they found a WW2 bomb nearby.

The app then shows the location and evacuation information.
Thank you for this. This is really useful information.

I recently adapted some garbage collection code to add register scanning.

I can imagine all sorts of subtle bugs where things go away randomly. One problem I have with my multithreaded code is that sometimes a thread crashes and the logs are so long I don't notice. From my perspective the thread is just not doing anything.

Sometimes the absence of behaviour can be really tricky to debug!
This has always been a problem though, it's how simplistic programming tests like FizzBuzz got started: Non-imposters find it trivial, imposters can't figure it out on the fly. Then that one got too popular, solutions are all over the internet, the imposters started memorizing it, and now we've ended up with a crazy variety of programming tests that have drifted extremely far from the original intent.
We are collecting and redistributing grain at a discount and using it for anything we can think of. Highly processed food, grain alcohol, “corn fed beef” which is likely a dietary disaster for humans.

Remember, ethanol in gasoline is predominantly about lifting demand for corn in order to court votes from the upper Midwest. We don’t actually need to use corn for fuel.

You can feed pigs on grain and nuts that fell before or after harvest. Ten pigs are pretty big harvesting machine. Birds as well.

Mark Shepard is claiming about twice the yield per acre of conventional farms. He’s doing this by getting less than half a yield of four+ crops on the same land. The trick to being Mark Shepard is putting enough time and energy into your job to understand a dozen crops instead of hyper specializing in two, as if your neighbors aren’t doing the exact some thing.

Now at the end of the day, we still need some staple crops around. That we can stockpile grain for three years and canned food for 18-36 months helps level out boom and bust cycles in agriculture. Good year? Rent warehouse space. Bad year? Let the warehouse lapse, or do invasive maintenance.
The problem with I18n in particular is that reimplementing in Elm causes pretty unreasonable download size bloat.
A lot of the problems described in this (very detailed, nice work!) comparison are not really problems so much as design decisions. Having a clone operation that copies non-enumerable properties is, depending on what you're doing, a bad thing. They're not enumerable for a reason.

Similarly, cloning things like getters means you're potentially copying over closures, which means your new cloned object now has references to its source and interacting with it may mutate the source. This is a pretty serious hazard that (IMO) justifies not cloning getters/setters, at least by default.

Cloning freeze/seal status would also lower the usability of your cloning API, because now if you wanted to make a non-frozen copy of a frozen object, you can't use the clone API.
I’m one of the co-founders of Audialab, the company behind this tech. We packaged it up into a plug-in called “Emergent Drums”.

If you’re curious, our original generative models used GANs, and we’re incorporating diffusion approaches now.

Drums are the start - we’re currently training models for instruments, synths, vox, foley, etc.
Every time I see some of these, I'm reminded I should apply and get the equity myself.

But oh well, I'm not a US grad coming out of MIT or whatever those kids seem to have
Come to think of it, there must be an instance of a tunnel somewhere that had a crosswise shear of a few cm.
Yes, thanks for the correction! In DIY keyboard community a microcontroller breakout board is often referred to as MCU which makes things confusing.
I enjoyed your write-up, but what about the thief logic?
This is good form. It makes top-level control flow easier to follow, and keeps the concurrency scoped.
FTA:
"Food items consumed were categorized according to their degree of food processing using the NOVA food classification system"

If you search "NOVA food classification system" there is a PDF guide as the first link.
It’s very common in Germany. August last year, Berlins disposal site caught fire with 25 tons of not disposed ammunition on the site. In winter, they blow up old ammunition every week - they stop for the summer due to fire hazard.
I find it revealing that while somebody with experience in songwriting finds the result dull and mediocre, I who knows next to nothing in the domain finds its nice and totally fine.

Same goes for other domains: philosophy, coding, writing, ...

It's telling me that this AI can generate content in many domains way better than an untrained human would with minimal efforts, while not (yet?) reaching the level of experts in the domain.

It empowers all the non-experts in these many domains to touch things they never could have before. This is an amazing tool.
I also fully agree with the author and I am usually following a similar practice.

The libc is the weakest point of the C programming language, outdated, bad naming conventions, and in some cases harmful APIs.

It also has its merits, simplicity and availability, it is good as a fallback, but I think it is generally preferable to have a full API coverage when using a framework, including basic things such as printf/malloc/fopen as there are better ways to make those and it is quite important to maintain similar convention across the whole codebase.
https://archive.ph/R64AI
> No, I lack information about the state of the coin.

And that implies you lack information on the record, which is decisive for predicting successfully its playback.

> But under no circumstances can I ever accurately predict the outcome of flipping the coin again.

Because you lack the necessary information, because you assume those experiments are that way. If you set them up so that you don't look at the coin flip result, but in the next coin flip you measure the initial conditions and the flipping process accurately enough, the conclusion would be the opposite - you would accurately predict the new coin flip, and would not be able to predict the playback.

> Why? Because there is a fundamental asymmetry between the past and future.

Not at all. The asymmetry is due to how you defined constraints on the experiments.

> It is possible to make reliable records of the past, ... it is not possible to make reliable records of the future.

Record is, by definition, a pattern that has been created in the past, and this is likely to correlate more with the past states than with the future states. This is a property of the concept, not of some universal asymmetry between past and future. We may introduce analogous concept of a future record, which will be created in the future, and which will correlate with the future states.

We can talk instead about prediction and retrodiction. And then this is more of an easy/hard thing, not possible/impossible thing, and the distribution of success on this axis depends on details. Predicting Moon's position on sky 2 years into future is easier than retrodicting it 20 000 years into past.

None of this explains why your original argument does not apply to past macrostates.
Do you think a former colonial power really wants to go down that road?
If I want to create a task that runs even after the function returns, ie "async def f(): asyncio.create_task(coro=10_second_coro.run()); return;" is there any way to mitigate this? Function-scoped set of tasks?
The 8086 inherited the separate I/O space from the Datapoint 2200, a "programmable terminal". Since the Datapoint 2200 had a custom TTL processor, it was convenient to build in instructions to manipulate its I/O hardware directly. It doesn't make as much sense for a general-purpose microprocessor, which is why the 6502 etc didn't follow that approach. (Separate I/O instructions make sense in something like the IBM System/360 mainframes, where they were executed by a separate channel controller and gave you more performance.)

As far as the implementation of I/O in the 8086 chip, I haven't come across anything particularly interesting yet. It's essentially the same bus state machine as memory, except it signals an I/O access rather than a memory access.
Wasn’t DAN patched a while ago?
May I ask why people still consider V vaporware? Yes, the creator was a little bit too energetic in the beginning and listed all the POSSIBLE things he wanted V to be able to do, but held none of these promises in practice, but as we see now since the development progressed significantly it was probably just a childish mistake and not a bad intent.

So could someone as objectively as possible say why V is still bad/vaporware or even what progress it has made and what is still lacking?
The Forgotten History of Head Injuries in Sports
That approach is called the "fast follow" strategy in business vs. the "first mover" strategy. There are some advantages in fast follow vs. first mover but also some key disadvantages, especially in markets of winner-take-most, or when you need a large amount of capital and the early leaders generally take the haul.

That being said, for bootstrap projects, side hustles, and other projects, I've really come around to your way of thinking. For those projects where being another alternative does have good economics, "copy first, innovate later" is a solid strategy.
The folks spending time trying to "jailbreak" ChatGPT would probably also have fun writing 80085 on their calculator.
Could be multiple machines. I carried an image over three laptops, rebuilding with the new `-march` as I went along.
> But ... covering unemployment or serious illness ... these are examples of things that require a much (much) larger societal unit to be really effective.

Really? How many hours of labour per year does it actually take to feed, shelter and provide medical care for a person? I'd be surprised if it was more than 20 % of the hours I work today, meaning I could – barring a system that concentrates the spoils of my labour in the hands of the few – provide this assistance for four people besides myself. As you may know, the unemployed and seriously ill number fewer than half of the population, so I think we'd be fine.

I mean yes, that stuff takes specialisation, and that probably requires a larger community. (If only 0.1 % of the population are medical doctors, then we need 1000 people to have one doctor). But those numbers sort of work out in the world today, so I don't know why they wouldn't in a different world.
The longish loading time for an encounter really did something interesting for immersion. It’s a little similar to a DM rolling dice to generate an encounter—that built in anticipation isn’t really possible in modern games without annoying gamers.
I find this very interesting that the orgs allow this to go as far as making my experience so miserable that I consider leaving the platforms. I guess it’sa slippery slope and provably also metrics that are chosen to hide my increasing disinterest …
It’s relatively common in the UK. According to this BBC article[0] the Ministry of Defence deal with about 60 a year. There was one washed up on the beach last month in Brighton near me[1].

[0] What do we know about unexploded WW2 bombs? https://www.bbc.co.uk/news/uk-england-devon-56243750

[1] https://www.brightonandhovenews.org/2023/01/02/suspected-bom...
Hey, at least it's documented... good developers actually RTFM.

I can't comment on the design of this API, because I don't feel like learning the library, but in some performance critical applications these sorts of contracts aren't all that uncommon. Granted, this is python, I guess it's a bit more suspicious, IDK.
Mass media platforms are very shallow when it come to "managing personal information". Netflix is a disaster in that regard. and yes this kind of UI works for the majority: To be honest, the average person, normally content with switching on a TV, couldn’t care less.
The author made a mistake in that blog post. In the section about memory leaks, they say:

> Looking at the generated C code it's plainly obvious to see this memory leak. init_consts creates a 1000 byte allocation and never frees it. This is a memory leak that is unavoidable in any program compiled with V.

But the allocated memory is a static allocation. There isn't really a reason to free it. It's used whenever tos2 is called, which happens in many places according to the code. If you complain that this is a memory leak, then you should complain that any static allocation is a memory leak.
You'd have to run a bus every three minutes to get the same speed of pickup at stations.

But also those busses wouldn't be able to come to your door, or drop you off directly at your destination.

So I don't think I'm describing efficient public transport. I'm describing something like the platonic ideal of taxis in a dense city, but without the huge number of drivers.
Maybe you believe the unions should be some policing authority for their respective domains? Well, they're not, and it's not their fault for being different than what you imagined. Their stated goal is to protect their members, which is exactly what they do. There are other authorities mandated to regulate and check and we see them at work right now. So the whole system is working just as designed, nothing to see, let's move on.
Thank you for the detailed response and the links! Hope you have a great weekend!
Only guess I’d have is to protect the system against infinite-loop tasks, but I don’t remember any other runtime caring and an a task which never terminates seems easier to diagnose than one which disappears on you.
I can understand the sentiment but let’s be honest here: you’re more ok subsidizing a corporation’s poor choices than you are a human’s basic needs.

People are fine with walmart employees being on welfare and ridicule the human for poor choices but don’t ridicule the very same walmart for choosing stockholder ROI over proper wages to employees. You (and I) are subsidizing every corporation that profits while having any one of its wage earning labor force on government programs.

Either we should be arresting walmart, demanding more of the corporation or giving everyone security in housing, food, healthcare…
wow. yeah, this absolutely explains a heisenbug that i've been chasing for a while. and i can't count the number of times i've had that exact doc page open on my screen in the last few months, and never bothered to read that block of text that starts with "important"...

thanks
Fire and forget.
Have to agree with the other response. Demanding perfection is not realistic in many situations. If you can get 95% of the way there with 50% of the code/effort, you should do it. Sometimes being productive is knowing when that last percentage just isn't worth it.
Elon isn't telling journalists to call him a founder.
Because it's almost always the case that the consumer is going to keep a reference to the task in some way, so that is the logical choice for the "primary owner" of the task. Python doesn't have ownership per se like rust, but if you keep more than one hard reference to an object around, it'll prevent collection, so in cases such as this it makes sense to designate one primary owner and have all other references be weakref.
Unless you want it sent in the Compiègne Wagon, they send all their bomb disarmament bills back to the UK and they have far more of them.
I am not sure I agree that the GUI is a good use case for async. A human interaction with the program must almost always pre-empt whatever the program was running, so I can not see how a cooperative multi-threading runtime like async Python can work in such a scenario.
that must mean there's a class of cells that keep skin cells in their station. which cells are those?
For the first two caveats, I actually agree that we could and should handle ambiguous input. It just hasn't been a priority because doing that properly would be quite a bit of work, and such ambiguous syntax isn't particularly common. See https://github.com/mvdan/sh/issues/686 for my current thoughts on how to tackle it.

The third caveat concerns parsing `export` and `let` as keywords rather than as builtins. Like the README says, this is to properly build the syntax tree without leaving opaque strings as expressions, but also to support `declare foo=(bar)` which wouldn't work if `declare` was treated like any other builtin simple command.

How else would you have a static parser handle these two builtins? They are in a bit of an awkward middle ground between builtin and keyword. My instinct is that giving them special treatment in the parser to allow tokens like `(`, while at the same time representing them in the syntax tree with opaque strings as expressions, would be pretty underwhelming to any users of the parser.

That said, we already have that problem with `let "foo=123"` for example, where our parser currently represents the expression as the quoted string without going any deeper. https://github.com/mvdan/sh/issues/754#issuecomment-96329574... considers doing a second parse stage in the shell interpreter to fix cases like these, though always doing a second parse could get expensive.

We _could_ leave all arithmetic expressions as input strings in the parser, and do all the actual parsing when they are evaluated. That would be more compatible with Bash and more consistent. But it would also be less useful to any parser users who don't run into any of these weird edge cases, which aren't common at all, I think.

In short, I have some ideas, but I'm not sure at all what's best :) Doing a good job for 99% of users feels better than aiming for 100% compatibility with bash syntax, particularly where bash syntax is a bit weird.
It's a euphemism for the hyperpalatable packaged foods that are bad for us that most of us struggle with.

It's kind of like how nobody who says "I need to cut back on carbs" is talking about steel cut oats and black beans.
The everyone is out for themselves, greed is king, insurance instead of family, sue thy neighbor is not backed by evidence? who knew?
The Tragedy of Legible Expertise
I have seen it getting worse and worse over the last years and also I have watched so much on these platforms that I‘d think the signal should stand out no matter the underlying reason for it.
Tried it. A little too complex or my simple little brain. Dungeon crawl stone soup is what I prefer. crawl.develz.org
> Your eyes are exposed to the air.

Surface area of lungs: 100 m².

Surface area of eyes: 0.0004 m².

Difference: 6 orders of magnitude.
You'd have to keep feeding the book into the AI for it to do that. It hasn't memorized the entire book, and you can't get the whole book back out of it just by asking questions.

Copilot is basically a single interactive summary of all of github.

I would not currently worry about the threat of someone making a thousand wildly different copilots that deliberately memorize different fragments. Especially because I expect the real copilot to be tuned over time to reduce the number of fragments it picks up. But if such a person emerges, it's clear that they are the problematic actor.
I am confused. Having gone over quite a bit of the authors C code on GitHub, it seems he uses libC quite often. I read/follow his blog posts; most are well written and insightful. His code is rather elegant as well, making his code bases good for studying (I recommend them to mentees)… What am I missing here. I think libc is quite alright given its time in operation, I bet libC is the most widely used standard library on the planet by a large margin. If not libC then what? Musl, glib? Those are great as well but I think avoiding libC is somewhat silly..
If only we had things like mutual savings banks, or cooperative insurances, or...
https://www.justice.gov/archives/jm/criminal-resource-manual... this is literally the manual for prosecutors saying the opposite.
That's the whole point about my criticism. Uranium is incredibly dense so phrasing it in terms of volume of the uranium is just misleading.

Regarding the calculation https://www.worldometers.info/coal/ says we are burning 1,147,083 cubic feet of coal which is about 30000 cubic meters which is about the same as a football field up to 10 yards (~50mx90mx10m).
Fair enough! I stand corrected.
I don’t think its applicable here. I personally have many platforms and options where I can find most movies that I want to watch. With this many options I have no trouble finding movie I’ll almost definitely enjoy watching.

This process for finding right movie takes effort and many aspects, while the streaming service only has my watching/browsing history and rating system which I don’t bother participating in.

I think it might get better if they become more intrusive, though.
Thanks! It seems like the direct route should be something like "turn the function into it's AST, apply derivative rules to transform the AST, turn the result back into a function". And this JAX post doesn't really speak in those terms, at least not directly.
Bootstrapped startups? Not so many agile coaches in them
But if there was too much, shouldn‘t I have too many good option rather than too few?
David Deutsch: Knowledge Creation and the Human Race
Its a good point, but the system is just statistically outputting words from human use, so its really the darkness of the humans that used those words that were input that perhaps he is referring to.
> Where I'm particularly unconvinced of their use is in server side view and api end point processing. The majority of the time you have maybe a couple of IO opps that depend on each other. There is often little than can be parallelised (within a request) and so there are few performance gains to be a made. Traditional synchronous imperative code run with a multithreaded server is proven, scalable and much easier to debug. Traditional synchronous imperative code run with a multithreaded server is proven, scalable and much easier to debug.

Python doesn't have multithreading that scales or supports real parallelism. asyncio has very measurable performance benefits for exactly that use case you've mentioned versus threaded servers.