antipurist

One major difference is that H.I. often cares for the outcome, so directing them is enough. LLM has no capacity to care, it is just a tool, more like watercolors that you paint with than a H.I. storyboard artist that can promise you meaningful results.

It's simple, and it doesn't work as `Exclude` only applies to union types. For type `string` it just returns the same type `string`.

Are you quoting the same polls that simply didn't offer respondents any way to say "I'm against all of it"?

Dishonest polls do not demonstrate popular support.

https://consumerrights.wiki/w/User:Louis/Manufacturing_suppo...

I'm not aware of any relevant research, but to answer the "So what can we do about it?" question I have a wild idea: invert the power structure, with cooperative of workers hiring their managers instead of managers hiring workers. And no, this doesn't automatically lead to the same tree, just inverted, it could form a much flatter structure.

I imagine that a cooperative can hire a person who measures the value generated by each worker/team, and then the cooperative members agree upon compensation readjustment.

Then each person/team can hire a manager to help them generate more value if they can't keep track of what's going on within the cooperative without that help.

This way you might get a completely flat structure where each IC decides if they need someone to boss them around or not, and to what extent. Or it might devolve into a typical hierarchy if every IC fully delegates their decision-making, priority-setting, and coordination to their manager, but that devolution will be a bottom-up process, not a result of top-down pressure.

Can this work? No idea.

The third value could map to "mu" [1], or "unask the question".

[1] https://en.wikipedia.org/wiki/Mu_(negative)

> This website uses cookies > We use cookies to personalise content and ads, to provide social media features

I know there are some services that send GDPR data removal requests on your behalf. I wonder if there are any similar services that send messages like "Why the hell do you need these cookies?" to website operators.

I hardly ever see these cookie banners as my browser blocks most of them, but I still think it would be great to rub the idea of "Your website doesn't need any non-technical cookies" in website operators' faces.

Human-carrying birds have been built.

Piloted ornithopter: https://www.youtube.com/watch?v=a-qS7oN-3tA

Human-powered ornithopter: https://youtu.be/0E77j1imdhQ?si=Dd5hLla27Pz8gJNe&t=100

Also, Quetzalcoatlus northropi could've been powerful enough to carry a human.

Second-chance pool: https://news.ycombinator.com/item?id=26998308

It's "macOS" [1] if you really want to be pedantic. However, it's still "Intel Mac OS X" in Safari UA even on M1 MacBook, so why Statcounter data includes both OS X and macOS remains a mystery.

[1] https://www.apple.com/macos/macos-sequoia/

> the look and feel of a regular pair of glasses

That's a bold claim for glasses this comically thick.

If you're interested in more normal-looking glasses with a HUD, I suggest taking a look at Even Realities G1 [1] — I have not seen them in person, but at least in photos / videos they don't scream "a piece of tech".

[1] https://www.evenrealities.com/

You don't need plastics for that. Warp knitting has been used for the last few centuries with cotton/linen/silk/wool to get stretchy textiles, and there are plenty of stretchy pants that are made of natural materials available today for those who struggle fitting into jeans.

You might find Eloquent[1] (and a related HN discussion[2]) interesting.

[1] https://www.32al.io/projects/eloquent/

[2] https://news.ycombinator.com/item?id=37630804

Something like

    if ('Bun' in globalThis) ...
    if ('Deno' in globalThis) ...
    if ('window' in globalThis) ...

could be used to determine the runtime.

You and Symbiote are technically correct, what I'm suggesting wouldn't match The Open Source Definition [1]. But being "correct" matters little to me, what matters is promotion of the idea & usage of free software.

> Free software is software that gives you the user the freedom to share, study and modify it. We call this free software because the user is free. [2]

I believe you'd agree that everything-as-a-service and tivoized products do not make users free, even if they technically don't violate the terms of FOSS-licensed code that they incorporate.

> The Business Source Licence

Yes, I've heard about that license, but I think it's mostly applicable when an already existing company decides to make its product more open, while I was thinking of the opposite — a group of independent contributors realizing "hey, we've made something big, let's protect our work (and potentially get rewarded for our efforts)" and creating a more formal entity around it.

[1] https://opensource.org/osd/ [2] https://www.fsf.org/about/what-is-free-software

Your comment, and this line in particular:

> A license is like a constitution for an ecosystem for how people will interact, a check-and-balance on the monopoly power of the license-holder, and a community contract.

finally gave me an answer to the question that bothered me for a while: how do we reconcile the goal of making FOSS available for everyone to run/tinker with/distribute freely with the issue of corporations leeching off community-created FOSS? Now the solution is clear to me: less focus on licenses, more focus on people interactions and actual contracts.

Instead of writing some code and throwing it to the MIT-license winds with little hope to gain anything in return it should be possible to create software cooperatives, i.e. real legal entities, with a simple premise: the code is free for non-commercial use; any person whose contribution was accepted is free to join the cooperative; any company that wants to use software stewarded by the cooperative has to pay for it, with said payment being shared among the members and/or saved for later. That would be an overkill for a tiny personal weekend FOSS project, but for serious products the overhead of formalizing the community would likely be totally worth it.

I'm pretty sure I'm not the first to come up with such an idea, I wonder if anyone has already implemented it in practice.

You can find examples of people using eye trackers for coding/gaming on Youtube and judge the latency yourself, here's one such example: https://youtu.be/FZRgBw8m34c?feature=shared&t=90

> What ensures that the “rest of the string” is, in fact, a suffix of the input?

Nothing, unless you have unit tests. Or use Liquid Haskell:

https://ucsd-progsys.github.io/liquidhaskell/

There are languages that let you express stronger guarantees/requirements via type system, but it’s better not to go down the rabbit hole of dependent typing.

> Everything is always on. Power consumption is constant.

That was the case in ye olden days of single-core CPUs, but is it still true today?

I can easily imagine a computer that has one always-on core for kernel chores and hardware management, and a dozen dormant cores that wake up when userland tasks need those cycles, all running in hard real time. Or even better, a mix of real-time for UI & audio on some cores + non-time-bound jobs on others.

I’m glad that the free software movement existed for so long and achieved a lot, giving me the opportunity to reap the benefits of their work.

And that’s exactly what disappoints me: everyone can benefit without giving anything in return. FSF didn’t find an approach to software freedom that incentivises participants to contribute. FOSS is not a business model, so we see what we see: https://xkcd.com/2347/

I believe there is a need to adopt more semi-free source-available licenses that will force corporations to finance the projects they rely upon, while granting the expected freedoms to individual users, tinkerers and contributors.

>many companies don't allow you to use code with the unlicense because of its unclear legal status

I'd argue that this is an advantage of "funny" licenses: any megacorp can use your MIT code without giving you anything in return; if the same corporation really wants to use your funny-licensed project while being legally in the clear, they are now incentivised to approach you, potentially offering some compensation for a more "serious" license.

At the same time, funny licenses don't stop enthusiasts from working together, and that's what makes open source software good.

There is a third option: make your language shine where it matters (to you), and accept subpar experience in areas that matter less. Specific things you mentioned — debugging, profiling & analysis — could be treated as a solved problem if you transpile your language into some other language that already has these nice-to-haves. JS is a wonderful target, as long as you generate something remotely readable you already have a way to debug it, no need to reinvent it. Instead, it's much more fun and beneficial to focus on the reason you want to create the language, on the features that make it stand out.

Sure thing, if you're building something complex, you have to deal with complexity, there is no way around it, low-code doesn't change it.

But I've seen lots of non-coding professionals who spend hours every week just looking up some info on various websites just to copy some text/number/address from a well-structured page and paste it into a spreadsheet. Could this be automated? Absolutely! Do they want to learn how to write a program, handle errors, manage the deployment of their scripts? Absolutely not.

Low Code has its place, and there are no conceptual downsides to starting with a low-code solution and then hiring software engineers to flesh it out and handle all the special cases. All we need is a low-code platform built around some real programming language that you can put into git, review, debug locally etc — with a no-coder-friendly interface built on top of it. This part is missing, and that's what causes people to dislike the low-coding in general.

I was sceptical about ChatGPT and still am, as it's too boneheaded and verbose to be inspiring. But in this case it helped me to understand where do I want to head next, so thanks for creating this service.

I'm still confident that the machine is not yet ready to take the suggested job of "technical trainer or software instructor", but I'd better hurry before it gets smart enough :)

I find it funny that the author dislikes "casting magic spells", and yet cherishes the book which states that we conjure the spirits of the computer with our spells.

What I don't find funny is that people keep suggesting SICP instead of a much more digestible How to Design Programs — https://htdp.org/

> eee-vic-ser

https://github.com/google/evcxr/issues/215

"Why did it take so long?" and "Pointless bloat!" reactions were much more common:

https://news.ycombinator.com/item?id=3780367

https://news.ycombinator.com/item?id=6418337

Hopefully, soon we'll be able to get the exact pleasure that comes from animal fats and proteins without slaughtering cows or plant-based imitations — cultured meat is already a thing, it's a matter of time before it becomes affordable: https://mosameat.com/growing-beef

Those conventions are held indoors: https://www.youtube.com/watch?v=TMRmuyy9f_w&t=30s

Not a unison aficionado, but I believe this is an OK problem to have given that we already have to deal with a (weaker) variant of the same problem in every other PL: if your dependency has a bug, you/dependency vendors have to create a new version of that dependency and then change every single module that depends on it. The scale might be different, but the nature of this Really Hard Problem appears to be the same in both cases.

Also, it seems like a solution to the really nasty problem of changing transitive dependencies.

Lisps let you define macros. Racket lets you define languages.

https://docs.racket-lang.org/guide/languages.html

https://docs.racket-lang.org/guide/more-hash-lang.html

Example of a language-in-racket: https://github.com/soegaard/minipascal/tree/master