skysight-inc/HackerNews huggingface dataset:
raku - the bastard child of functional and OO

class MyTable is export {
has @.data;

multi method new(@data) {
$.new: :@data;
}

method render {
table :border<1>,
tbody do for @!data -> @row {
tr do for @row -> $cell {
td $cell } };
}
}
For cases where you can realistically include a full v8 in your project, yea - that seems fairly reasonable nowadays.

Javascript took an extremely high-complexity, high-cost, and nearly-all-effort-in-just-two-impls-for-over-a-decade route to get to the current (stunning) performance though. How do small-scale embedded interpreters stack up? That's what many things that aren't Electron apps will be using.

I ask this honestly, to be clear - I'm not sure how they stack up. I know Lua has historically targeted and dominated this area so I'd expect it to win, but I have not seen any data and I largely agree - JS is a massively better development environment now, and I would love to choose it. Everything I can find pits it against v8, and that's kinda like comparing the performance of a bike against a train - they are so different in many situations that it's meaningless. Otherwise I'd probably choose WASM today, or maybe docker containers where performance and platform needs isn't an issue.
Forgive my stupidity -- how is it possible to walk from the new world to the old? How does one walk over the oceans?
Donald Knuth's 2024 Christmas lecture: 'strong' memories
Not necessarily true.
LuaLS, the most popular LSP, uses LuaCATS (Lua comments and type system) annotations.
You can place annotation files (type stubs) in a directory and the LSP will pick them up.

I use this for a project of mine where I embed a Lua interpreter where I made several additional Lua modules available.
The is no such thing as TAI. TAI is what you get if you start with UTC and then subtract the number of leap seconds you care about. TAI is not maintained as some sort of separate standard quantity.

In most (all?) countries, civil time is based on UTC. Nobody is going to set all clocks in the world backwards by about half a minute because it is somewhat more pure.

GPS time also has an offset compared to TAI. Nobody care a bout that. Just like nobody really cares about the Unix epoch. As long as results are consistent.
If you’re looking for a neuroscience approach, check out Numenta https://www.numenta.com/
> The cause of the difficulty was the large number of crates using types from these libraries in their public API.

This has bitten me on the ass so many times. Exposing third party types means you have to upgrade the library simultaneously across the entire application, even if the language allows you to load different versions of the same library in different parts of the app. And if you’re trying to skirt Conway, having multiple teams sharing a single deployable, you’re gonna have a bad time. Because good luck getting all teams to agree to drop everything and upgrade next sprint.

I’d much rather my coworkers use libraries instead of NIH, but you have to be very careful how you use them. It gives me a little sympathy for microservices, but that’s often just swapping in a devil you don’t know.
Show HN: migrate-to-uv – Migrate a project from Poetry/Pipenv to uv
Threejs.ai – Generate threejs assets for any projects using AI
There's a 4D mini golf VR game you might be interested in checking out. It's called, uh, 4D Golf. Creative! I've not played it myself, but it's on my list. I hear it's pretty cool!
a bunch of that comes from awk.
A common downside is that the distribution picks the lowest common denominator of some dependency and all apps that require a newer version are held behind. That version may well be out of support and not receive fixes at all any more, which leaves the burden of maintenance on the distribution. Depending on the package maintainer, results may vary. (We sysadmins still remember debians effort to backport a fix to OpenSSL and breaking key generation.)

This is clearly a tradeoff with no easy win for either side.
Adam Langley is probably one of the most gifted teachers when it comes to explaining cryptography concepts. Very clear, concise, precise, and makes it simple enough for me to follow without getting my neurons all knotted up.
This probably makes more sense in 2024 but for many years JavaScript was not a serious option. I wasn't until the mid-late 2000's that it started to get traction as an application language and had any way to run it outside of a web browser.

Lua as an embedded language already had over a decade head start.
Normies*

Gamer used to be a word for people who already believed in this
Why would they only care about that if they're trying to hack into a system?
For comparison, Claude 3.5 Sonnet (my favorite model for coding tasks) is: Input $3 Output $15.
> Physics and maths! I'm in my gap year at the moment, but I want to be prepared for my physics degree next year. I'm already really quite rusty.

You should really check out Math Academy! It'll diagnose where your gaps are and build you up to all the math you need for a physics degree and then some [0].

[0] https://jonathanwhitmore.com/posts/2024-09-10-MathAcademy-af...
"most people should use the things I use and am familiar with" is a common opinion but you should realize that between Javascript and Lua, Lua is the boring standard language in this context.

Also there are whole books written on the quirks you need to master with Javascript. Lua has its rough edges but it's a much simpler language, so there are far fewer of them.
> Why are arrays tables

I might be able to provide at least some insight into that.

One of the things I found while implementing my language was that the ordering of elements in a hash table is essentially random. Literally random if you mix in some randomness into the hash function's initial state in order to harden it against collision attacks.

Many languages guarantee insertion ordering. It's a useful property to have, makes testing easy and deterministic and it's intuitive for users. A simple way to implement that is to put a perfectly normal array of values into the hash table, and then have the buckets which the keys hash into contain indexes into that array. That way the indexes of values remain stable no matter what the keys hash to.

So a sufficiently advanced hash table will have an array of values inside it. I suppose some language designers took one look at that situation and decided to just merge both types already by using hash tables for everything. For example, PHP also did that. Associative arrays, they call it.
No.

That'd be like saying some points in time that don't have a ISO 8601 year. Every point in time has a year, but some years are longer than others.

If you sat down and watched https://time.is/UTC, it would monotonically tick up, except that occasionally some seconds would be very slightly longer. Like 0.001% longer over the course of 24 hours.
Wow, this channel is amazing, so many good history videos on tech. Thanks!
Logseq is floss(gnu license, closurescript) and almost perfect for me but it's totally mysterious to me what's stopping it from serving a web interface that serves files on the web server. It's an electron app with an HTTP API but for some reason the web demo only opens files clientside with filesystem API

Anyway, one of these days I'll fork it and make it work for me. I also have a perverted desire to change the serialization format from markdown to XML so I can manipulate the graph with other tools that talk xpath, xquery, basex.
Brief Overview of the Stanford GraphBase (1996)
I wish there was a better user experience when downloading an image a user creates on a website like this on iPhone - it’s really weird that you can’t save it to your camera roll. It goes into downloads and confuses everyone.
Rising Colorado Startup Stars
"One also running from Helsinki to Tallinn is owned by the Chinese-owned CITIC Telecom."

Has Sikorski made a "thank you" tweet to any suspected party?
Meanwhile, every YC startup these days is some unimaginative variant of "let's automate this with LLMs".

Humanity racing towards maximum idiocy.
Thanks for the tip! Added it to an issue: https://github.com/shalanah/inapp-spy/issues/37
This is where my stance is.

As a developer, I want my PRs to actually be reviewed by my coworkers and to have issues caught as a second layer of defense, etc.

As a reviewer, I effectively stopped approving things I couldn't give at least a cursory, reasonable glance (and tried to encourage others to follow suit because if we're not reviewing things, why not just push directly to main).

As a consequence, I have:

* tried to review most things within like half an hour of their announcement
in the shared MR channel

* requested a pair programming session and offered to do a pair programming
session for any large and semi-or-fully automated refactoring session,
like running a linter or doing a multi-file variable rename
(the pair programmer immediately comments on and approves the MR when it
appears)

* tried to limit my PRs to approximately 400 lines (not a rigid rule)

There were some specific instances of people not liking the "you must pair program if you're going to touch 400 files in one PR" requirement; but otherwise, I would like to think those on my team liked the more regular PRs, more people doing the PRs, etc, that resulted from this and some healthy culture changes.

I would also like to feel like the more junior devs were more willing to say anything at all in the PRs because they could follow the change.
Agreed, I implemented TLS key pinning for a project at Okta using one of Adam's blog posts
All programming languages have tiny differences. Some use }, some use keywords like "end" or "fi", some use indentation like python.

Its a trivial difference that does not matter.
The eight year old and I hanging out on this. She is a huge fan. The moment she saw it, she said “I want to use this.” And now we’re both making snowflakes on our devices.

I can’t name many apps that provide equal entertainment to my kid and I. You’ve done very well. As a bonus, the eight year old seems particularly motivated to learn JavaScript and start working on this kind of stuff herself.

Nice work and excellent share. Thanks so much for this!
> Mantras like "methods should be shorter than 15 lines of code" or "classes should be small" turned out to be somewhat wrong.

I really have some concerns about this kind of opinion.

I know that we can't follow this rule (or smell) every time, but I already see this affirmation being used by very poor or inexperienced programmers to justify understandable gigantic and hard to test pieces of code.

This is the type of advice that just experienced programmers can understand what this means and know when is applied.

Most part of the time, it's easier to fix a cod
> Consider passkeys as a standardized interface for password managers.

I have not followed WebAuthn spec for a while but I vaguely remember that the spec discouraged software-only authenticators.

Which made me feel like WebAuthn is yet another attempt to take the power from users and even states and concentrate it in the hands of a few multinationals controlled by US government.

Pretty much what happened to Certificate Authorities and the push to use HTTPS everywhere.

Of course there are benefits to HTTPS Everywhere and to passwordless authentication.

But they do not outweight concerns over the digital autonomy of my country.
FDs optin, memory too given the insane performance pitfalls architectural issues and pernicious security problems (think cloning a CSPRNGs internal state) and suddenly you realize CreateProcessA was and always has been the superior API.
The authors actually just released a second edition of the AWK book!
> And if you’re trying to skirt Conway, having multiple teams sharing a single deployable, you’re gonna have a bad time. Because good luck getting all teams to agree to drop everything and upgrade next sprint.

this is why I'm not on team monorepo. Let other teams vendor their dependencies and upgrade on their own time. Just don't go trying to release N versions. Measure who is on an old version and work with them to update. But again, this slow team allows the other N-1 teams to adopt the new version and provide value to the org.

for those of you who are pro monorepo and have worked in one with dozens of teams in different orgs who have competing priorities and can't upgrade a dependency in lock-step, how have you solved this?
Building an AI Steering Committee in the Aurora CO School District
You made the original claim without evidence. It's up to you to provide that evidence. You're engaging in a classic crank move there. I'm just applying Hitchen's Razor: "what is asserted without evidence may be dismissed without evidence."

I have pointed out that these specific chemicals look to be less toxic than the class in general, so just pointing to evidence about the class in general is not sufficient.
MacOS and Windows both seem to do quite well actually on this front. You should have OS-level defense mechanisms rather than trying to keep every single application secure. For example, qBitTorrent didn’t verify HTTPS certs for something like a decade. It’s really difficult to keep everything patched when it’s your full time job. When it’s arbitrary users with a mix of technical abilities and understandings of the issue it’s a much worse problem.
I recently built a small Python library to try getting time management right [1]. Exactly because of the first part of your comment, I concluded that the only way to apply a time delta in "calendar" units is to provide the starting point. It was fun developing variable-length time spans :) I however did not address leap seconds.

You are very right that future calendar arithmetic is undefined. I guess that the only viable approach is to assume that it works based on what we know today, and to treat future changes as unpredictable events (as if earth would slow its rotation). Otherwise, we should just stop using calendar arithmetic, but in many fields this is just unfeasible...

[1] https://github.com/sarusso/Propertime
I love Lua as a language; even if it can be a bit cumbersome at times, its simplicity and low barrier of entry is refreshing. I'm currently building a full-stack web application with https://redbean.dev in Lua and it's mostly been a joy.
So many major outages and little gets fixed. Almost as if nothing was learned since the previous postmortem from the last outage.

Can't wait for this postmortem to be released.
Oh that is one of my pet peeves.

"If only people would do their jobs properly".

So we just fire all the employees and hire better ones only because someone did not pay attention to the comment.

Of course it is an exaggeration - but also in the same line people who think "others are failing at their jobs" - should pick up and do all the work there is to be done and see how long they go until they miss something or make a mistake.

Solution should be systematic to prevent people from failing and not expecting "someone doing their job properly".

Not having comments as something that needs a review reduces workload on everyone involved.

Besides, interfaces for PRs they clearly mark what changed - they don't point what hasn't been changed. So naturally people review what has changed. You still get the context of course and can see couple lines above and below... But still I blame the tool not people.
There are other preprint servers. But to your question, there are centralized indices that track all papers.

DOI is the primary identifier and preprints are also issuing them now.

Crossref has papers by DOI. OpenAlex and SemanticScholar also have records, with different id types supported (doi, pmid, etc).
Casual Viewing – Why Netflix looks like that
If one properly specifies the input, output, and clobber constraints to the asm statement, there is no need for the volatile keyword in any of this.
Walmart 3D Prints Store Expansion, Marking Commercial Real Estate Milestone
Thank you I know what l systems are. A Semi-Thue grammar which is not really a Chomsky grammar - the way the production rules are applied differs. They are after the name of famous biologist called Lindenmayer, thus the name. I’ve been teaching these.

Now my question was - is this an L-system or another one. Not what are L-systems which are. As far as I get from your reply, the plug-in does not facilitate. Thanks.
I ran into this recently in the emulator… it seems to be using a very half-baked OCR engine that can't even recognize default Android's default font correctly.
Wouldn’t subtrees fix this instead of a mono-repo? Or even (gasp) submodules?
OSS Maintainer Behavior Survey
Cold-Related Deaths in the US
Unless they are specifically targeting that system my assumption would be that they are just looking for open ports for known services, then if found checking if exploits work or not, and if not move on. I could very well be wrong but from a practical standpoint I can’t imagine this service mattering to someone that is running a program to scan for open ports with vulnerabilities.
Yes, that's explored in the sequel. He lives on in Urique, Mexico where his likeness is plastered everywhere and is the namesake for the big annual race in that town.
I've sometimes thought perhaps coding would be much simpler if instead of creating a new programming language, we instead create a fantasy workstation akin to PICO-8/Picotron geared towards building business applications.

On the user interface side, you only have to code to the fantasy workstation's fixed UI and it can be smart enough to automatically be responsive for different screen sizes. Since it's geared towards business apps that are primarily forms, it doesn't have to care about all the edge cases of the web's presentation layer.

Concepts like durable messages queues (like Temporal.io) could be first class citizens so instead of the distributed mess of lambdas, queues, step functions, etc, you just have basic code that can be web scale.

I haven't given it too much thought. It just seemed like something interesting to explore.
Love this! It'd be interesting if some builds this but adds more dimensions (similar to Company status) to it that you can query or group by. For example, if I look at S21 and W21 batches, then it'd be nice to know things like -

1. How many of these companies made it to series A, series B, etc

2. How many of these companies have > x employees (where x can be 5, 10, 20, etc)

3. How many of these companies had a founder that moved on to something else

This does require a lot more intelligent data scraping or manual data collection though.
Maybe a $80M should make profit.

Sounds like a failed business.
Huge fan of that blog and its author!
The lake of meaning is in our mind when we can't find any meaning to attach to what is exposed.

In that case, the text was specifically pointing to how so general statements can hardly lead to any robust conclusion.

All systems have their unique weaknesses, which can lead to dangerous situations.

On a pure retorical level, we can pick any system that can be conceptually exposed and discuss its theoretical virtues all day through. Or expose all the danger we can envision from mechanisms it implies on conceptual level.

In theory, an enlightened dictator is the best system, just as well as democracy with enlightened crowd, or gerontocracy with enlightened elders that don't fall in illusion that everything was better before and new generations are a bunch of lazy arrogant ignorants that will doom the civilization, or whatever gouvernement form we can theorize about.

It's easy to blame the ruler when you are not put with the duty to actively participate in the policy creation that should content all stake holders, and it's easy to blame the ruled ones when you don't have to obey the same rules as everyone because of course your exceptional contributions to society necessarily implies exceptional privilegies and you are the one that makes the laws anyway.

Except of course in a system where everyone is imposed the duty and means to contribute to maintain and evolve the laws that everyone have to follow, self included.
If anyone's interested, last year I replicated this exercise for an x86-64 Linux executable [0], and also golfed a Hello World as small as I could. I ended up using a little-known pattern (an ET_DYN executable with no interpreter, normally only used for the ld.so binary) to shave off more bytes than anyone else who had tried it, to the best of my knowledge.

[0] https://tmpout.sh/3/22.html
> Proponents of small functions argue that you don't have to read more than the signature and name of a function to understand what it does; it's obvious what a function called last that takes a list and returns an optional value does.

I used to be one of those proponents, and have done a 180.

The problems are:

1. The names are never as self-evident as you think, even if you take great care with them.

2. Simply having so many names is an impediment in itself.

The better way:

Only break things up when you need to do. This means the "pieces" of the system correspond to the things you care about and are likely to change. You'll know where to look.

When you actually need an abstraction to share code between parts of the system, create it then.
How does this differ from Navidrome and other Subsonic-based music servers?
It doesn't. You can try running it when your keyboard is open and see what an absolute trainwreck the OCR makes of that.
Microsoft Bundling Practices Focus of Federal Antitrust Probe
Deliberation in Latent Space via Differentiable Cache Augmentation [pdf]
Luau [1] developed by Roblox is a backwards-compatible fork of Lua 5.1 with some very significant improvements to speed and QoL [2]. It also mostly alleviates the nil-terminated array problem.

[1] https://github.com/luau-lang/luau

[2] https://github.com/luau-lang/rfcs/tree/master/docs
When I was doing my degree (area studies and linguistics), a friend who was in mathematics liked to tell me that mathematics was the second-most democratic science: all you need is a pen, some paper, and a waste paper basket; the humanities were the only thing that was more accessible - since we don't even need the waster paper basket...

(I also miss my old subjects, not to mention being young and in university)
How do you use Scala as an embedded scripting language?
> But you must know what you intend to do when designing the MCU, and history shows (and some of the questioning here also shows) that this isn’t the case. As you point out expected lifespans are long, so what is a designer to do?

Designers do know that UARTs, SPIs, I2C, timers etc will be around essentially forever. Anything new has to be so much faster/better, the competition being the status quo and its long tail, that you would lay down a dedicated block anyway.

I think we'll disagree, but I'm not convinced by many of the cases given here (usually DVI on an RP2040...) as you would just buy a slightly higher spec and better optimised system that has the interface already built in. Personal opinion: great fun to play with and definitely good to have a couple to handle niche interfaces (e.g. OneWire), but not for majority of use cases.

> A similar thing occurs with almost any non trivial SPI usage where a lot of people end up building “big” (relatively) buffers in memory in advance.

This is neither here nor there for a "PIO" or a fixed function - there has be state and data somewhere. I would rather allocate just what is needed for e.g. a UART (on my weapon of choice, that amounts to a heady 40 bits local to the peripheral written once to configure it, overloaded with SPI and I2C functionality) and not trouble the memory bus other than for data (well said on data movement, burns a lot and it's harder to capture).

> Assuming the tiny cores can have their own program memory they will be no less deterministic than any other sort of peripheral while radically freeing up the central part of the system.

Agreed, only if it's dedicated to a single function of course otherwise you have access contention. And, of course, we already have radically freed up the central part of the system :P

Regardless, enjoyed the conversation, thank you!