skysight-inc/HackerNews huggingface dataset:
> Perhaps burning oil (and all the technology enabled by it) is what gave us global stability in the first place since countries could get richer by being productive instead of conquering each other.

That, and nuclear weapons (MAD), very much yes. It's not oil per se, but cheap energy (non-energy use of petrochemicals notwithstanding). We're not in danger of running out of that resource.

Climate change is threatening food supply and habitability. That much is obvious, since it's already happening. The rest is not hard to guess, as mass migrations (albeit on a much lower scale) are also a thing that happened in the past.
ECC is done on 8-byte words. The basic form of RAM ECC is called "SECDED" ECC, and is an 8-bit hamming code that can correct one error silently and detect any two. It's not just a parity bit.

The number of ECC bits needed for any error correction level on n bits are proportional to log(n).

DDR actually operates in bursts of 4 or 8 64-bit words (+8 ECC), so you can make a better ECC using all 32 or 64 bits to cover the full burst rather than covering each 8 bytes separately.
> The general issue with coding interviews is most companies don't validate that the interview is actually correlated with job performance. Of course a process where the blind leads the blind is going to have issues.

Yes, I was looking for someone to finally say this!

Without the feedback, the process is much more like an initiation ceremony to "legitimise" the hiring of the new employee. You put them through an fairly arbitrary ordeal so they can finally be crowned as a proper employee.
Indexing/search/relations/performance would be some counterpoints that SQlite already solved.

I have experience with flat file CMS systems (similar usecase) and at some point of complexity you end up rewriting your own database. Once every file has UUID an you have text file indexes of these than you realize you might have gone too far.

But not all projects need that and the argument for version control is big.
someone down here in this thread said:

> The problem with government (or too-large unions) is that different jobs have different employment concerns. It's hard to legislate in a way that covers all cases from seasonal farm work to IT office jobs to airline pilots. A union gives you more fine-grained representation to address the problems specific to your profession and workplace.

In Sweden government labor protection rules are somewhat low (there is not a minimum wage for example), but unions have a lot of power and a good chunk of workers are unionised. The job of the gov is to guarantee a basic minimum of labor regulations and unions do the rest.
Technically it’s an ointer on PowerPC and SPARC, but a pointe everywhere else.
Current web issues IMVHO are:

- it's not personal, yes we can save much contents, but it's not that manageable nor can be evolved much easier personally, we need a textual web, where anyone can grab text, store it locally naturally, change it as they wish. The "app" part should be just APIs and UIs;

- it's not immediate for anyone, yes we can buy a domain name, it's pretty cheap in most cases, we can use a ready made static website generator, but we do miss the most important part: IPv6 with a static global per host, so we can made OUR OWN WEB with our own friends;

- it's isolated, we have the modern web and WebVMs improperly named browsers for legacy reason, then we have desktops that act more like WebVM bootloaders than classic connected desktops, than some local apps, that tend to be limited and limiting. We need INTERNET much more than the web.

We need RSS for anything, with modern feedreader and a spread culture that content aggregation is a personal thing. We need easy to import data, pure natural language text and numerical data, so for instance if we go to our Amazon profile we can see a feed of all our purchase we can import in our reader, piping from it to our favorite financial software that also import other feeds from our banks/cards etc to make automation easy for things we can automate. We need data ownership, local iron in a classic desktop model.
Edit to add: the 1040 GPUs are orders that are below the current market price.
> teacher's unions in particular don't seem to have improved pay or working conditions much.

The difference in pay between unionized and nonunionized teachers is big enough that I wonder where you got such an idea.
StackOverflow is banning accounts that delete answers in protest against OpenAI
I've noticed a lot lately, that sites, projects, even big projects, don't have an easy to find "TL;DR", an "elevator pitch", right at the top of the page.

Most of the time I scroll, it looks like something that might be interesting, but it takes too much effort to figure out, so move on. There is so much content on the web now, these efforts need to put little bit more into the marketing if they want attention.

I'm sure scrolling down maybe it is discernable, but not really obvious.

Or maybe this is just so high concept that a short pitch can't explain it?

So what is this about?
Never. Not ever, ever ever.

Apple currently has 5 major build trains: macOS, iOS, watchOS, tvOS (which also runs HomePod), and visionOS. Huge amounts of the code are already the same between them: they literally just build the same stuff with different build settings… except for the UI. The UI has actually unique stuff in each train.

This has become more true over time… teams are likely sick of not having certain dependencies on certain trains, so they’re becoming more identical at the foundation/framework level every release.

Saying they’ll make a macOS with a touch UI is like saying Honda is finally going to make a motorcycle with four wheels and a full car frame. The UI is the differentiating factor in the OS’s. Everything else has already converged or is rapidly doing so.

If the goal is to support macOS apps on iOS then there’s a dilemma: how do you suddenly make apps that are designed from the ground up for a mouse, good for touch? The answer is you don’t: you just make the rest of the system identical (make the same APIs available everywhere) and ask developers to make the UI parts different.

I could almost believe that they’d make a macOS VM available for use with a keyboard and mouse within iOS. But to me it’d make more sense to do a sort of reverse version of how iOS apps are supported on macOS… where macOS apps are run natively on the iPad, but rendered with the iPad’s window management (modulo whatever multitasking features they still need to implement to make this seamless) and strictly require a keyboard and mouse to be in this mode. There’s just no reason to make a VM if you’re doing this: you can just run the binary directly. The kernel is the same, the required frameworks are the same. No VM is needed.
Yes, Hitler was socialist but he taught that hierarchies were inevitable since they are found everywhere in nature. It was called natural law.
If doing SSH properly, yes.

Though for new hosts people often don't verify the initial host key at all, just blindly accepting it, so that would be an extra risk vector.

Heck, I'm sure many don't bother verifying a new key when they get the warning, instead just removing the old from .ssh/known_hosts (or equivalent) to quiet the complaining! Though to be honest, with that security posture nothing is going to save them and our efforts are better spent securing others! I know at least one of our clients has automated systems that ignore key changes, because we once had a temporary config cockup that sent some connections to a host with the wrong key and some data was received there without any reported issues…
"Left" is a relative concept. The original French revolution left was liberalist. Liberalism is the core ideology of the current western world. Both Democrats and Republicans are liberalists. Even Putin is predominantly a liberalist.
100% agreed, of course. I didn't mean the market will solve this problem - just that if things get bad enough, the market incentives will align towards solving the problem... just a tiny bit, just until it stops being profitable enough to continue solving it.
I imagined executable pages and pages explicitly marked by the application/kernel via VirtualProtect[1] or similar.

Of course an application that marks GB of data this way could play havoc with other processes, so maybe some OS limits on how many non-executable pages a process can mark may be needed.

And there certainly might be some further dragons I'm not considering.

[1]: https://learn.microsoft.com/en-us/windows/win32/api/memoryap...
If SpaceX wants Starshield to operate in Taiwan, it would. If DoD wants it to, it means nothing unless they convince SpaceX, which apparently has a conflict of interest through its CEO’s other businesses, or force it legally.
> Honestly, I'd just love a operating system that doesn't decide its going to restart itself periodically!

My MBP has been running without any restart for over a month.
Can confirm, I worked in 909 Walnut, and witnessed downtown transform.

KC is an underrated city, and a surprising tech area. Getting Google Fiber first definitely helped. It is commonly called Silicon Prairie.
Luxury car market is 20% of US car market. Even more among people who can afford the option. It's not "most people" but it's not an outlier either.
VM writers use this egregiously. I've not heard of it causing issues. It's not that complicated.

Lua, Lisps, many others.
Show HN: Awesome Regex – Best tools/tuts/libs/etc. for all major regex flavors
I created a curated and opinionated list of the best regular expression tools, tutorials, libraries, and many other resources. It covers all major regex flavors, and currently includes especially deep coverage of regular expressions in JavaScript (including a concise history of all regex features added to JavaScript in ES6 through ES2024, plus active proposals for the future).
Show HN: Tracexec – TUI for tracing execve and pre-exec behavior
tracexec helps you to figure out what and how programs get executed when you execute a command.

It's useful for debugging build systems, catching fd leaks, understanding what shell scripts actually do, figuring out what programs does a proprietary software run, etc.
No. Their reputation for poor performance mostly arises because the default data structure is a singly–linked list. Although the language makes these lists extremely convenient for the programmer to use, linked lists invariably result in terrible cache locality. High–performance systems that are written in lisp (and they do exist), achieve that performance by avoiding lists and using vectors and arenas instead.

Of course, it must be said that this performance penalty rarely matters in practice. For most programs, the limiting factor is not performance but the cost of implementation and maintenance. Lisp has has many powerful and convenient features that make implementation faster and surer than in any other language, and which usually greatly lower the cost of maintenance as well. Thus by writing a new program in Lisp you can get it off the ground and earning you money faster than you could in almost any other language. You can also add features more cheaply as time goes on, allowing you to keep up with your competitors. It is only when your system is nearing completion, and all necessary features have been invented and implemented, that you should think about rewriting select parts of that system in a systems language where more efficiency is possible. Not only will you only understand the system after it is written, but you can measure the actual performance of the system to figure out which parts you need to rewrite, and which parts have acceptable performance already and thus do not need to be rewritten.
Ancient Native Americans used to have an interesting system. Most of the year they would roam around in "anarchic" groups of 100-200. During the buffalo hunting season, hundreds of nomadic tribes would come together and build a tent city with thousands of individuals. They'd elect a tribe to "police" the hunt, effectively insuring that everyone got a fair split of meat, and other animal products. There was a rule where the same tribe couldn't be elected twice, so if someone took an issue with the way order was kept, they could wait until hunting season was over and volunteer their own tribe to police next year.
Read the thread in its entirety please, you are quoting me quoting someone else.
> I find this definition interesting because it seems to me there’s a very prevalent portrayal in media pointing towards the opposite, that is that humans left alone (read, without some powerful/wealthy authority) will unravel into the most depraved state imaginable.

That's not surprising as the media, speaking generally, is a class which aligns itself closely with the ruling class and is incentivized to maintain the status quo.
The biggest tool a union has is striking. If you can’t strike you’re not really a union.
I think that the way you use "high level" here is vague and so makes it hard to see what's going on. I define a high-level language as one that trades off control over memory resources in exchange for higher abstraction (by relying on automatic memory management, AKA garbage collection -- be it based on a refcounting or a tracing algorithm -- as the primary means of memory management), while a low-level language makes the opposite tradeoff. By this definition, C++ is just as low-level as C. We can argue over which C++ features made it more attractive than C in the low-level space, but it is clear that the overall market share of C + C++ has only declined over the past thirty years, and C++ has failed to make significant inroads in application programming over the long term (it had a short-lived rise followed by a drop). The question I focus on is whether a low-level language, by my definition, should have features specifically accommodating application programming. The obvious failure of low-level languages -- which include C++ according to my definition -- to take a significant market share of application programming leads me to answer that question in the negative.

Various features accommodating low-level programming -- those that may have helped C++ take market share away from C but, crucially, have not helped it gain market share in application programming (over the long term) are, therefore, irrelevant to this core question. It's one thing to make a low-level language more attractive to low-level programming, and a whole other thing to make it more attractive to application programming. C++ has succeeded in the former but failed in the latter.
C++ has a bazillion different ways of initializing a value, most of which contain syntactic footguns of some kind that don't do what you probably intended. That's not fundamental complexity of reality, that's messy evolution over decades coupled with the inability to break backwards compatibility.

C++ also does "lie" about reality in a lot of ways, in the sense that the actual compiled program behaves quite a bit differently than a plain reading of the code implies to a nonexpert. The most obvious form of this is the rules for effect ordering. Even the recurring complaints about the compiler doing unexpected things based on the as-if rule and undefined behavior seem to count here.
As I mentioned in my other reply[1], I imagined executable pages and those marked explicitly through code.

This allows the kernel and applications to protect important variables and data structures.

[1]: https://news.ycombinator.com/item?id=40297035
StackOverflow mods frustrated as users delete answers since OpenAI partnership
This look like something that debuggers would hate, because following pointers would be broken
https://www.productive-hub.com/_vercel/image?url=%2Fplus-cir... didn't load for me but fine when I refreshed the website. Probably just temporary network issue.
My speculation was a lot more simple: China can blackmail or bribe internal employees to disclose the back door. Significantly less expensive and easier
“Finite time” isn’t much of a guarantee. A million years is finite. Totality checking is useful in language for doing proofs, where you need a guarantee that a function always returns a value even though you never run it.

In languages for doing practical calculations, a progress dialog and a cancel button are more useful than a totality guarantee. It should be easier to make complex, long-running calculations safely cancellable.

(Still true with laziness, though it changes a bit. At some point you will ask for a value to be calculated.)
Considering how common it is to use indices in lieu of pointers in Rust, it would be nice if it had native NonMax integer types similar to the NonZero types it already has. NonZero gives you the niche-filling optimization (e.g. Option<NonZero> and NonZero are the same size) but with indices you want zero to be a valid value, so it would be natural to use the maximum as the illegal value instead. You can kind of do it by offsetting the index by 1 or inverting the bits then putting it in a NonZero but that's a small extra runtime cost on every use.
Luxury means beauty and comfort, beyond the bare necessity of function.
Thanks for the input! I'll definitely take this into consideration and research more before deciding. Currently staying with SQlite and pretty happy with it.
What you say is true, but it’s because their pricing is deliberately complex and they’re performing yield maximization. I get that. However, it feels more like a new car negotiation that wastes everyone’s time. If you’re willing to accept X price at Y volume, just say that. If you offer discounts at certain tiers, provide those tiers.

Mutual Fund companies do it, and successfully, even if you’re only signing a letter of intent and aren’t buying at the higher tier today.

The charade involving salespeople, and let-me-talk-to-my-manager isn’t as productive as it seems. I’ve walked from several vendors (or discounted them in an RFP) due to that behavior.
Indeed, anarchy was the default state of human nature until communities reached Dunbar's number, i.e. around 150 people. Then, they did invent civilization for a reason!
I wonder if an interview process more like academic science would help.

It usually goes like this:

Candidates are roughly screened by their CV. A handful (in my experience roughly 6) are invited to hang out at the lab for most of the day.

They usually give a presentation on previous projects, and then chat with each member of the lab in turn, hearing about their work and asking questions etc.

Then you all go and have lunch together (usually without the boss). Later the candidate has a more formal panel interview with the group leader and some other faculty.

A few days later, they are told the outcome of the interview.

It may seem like a long process, but it all happens in one hit. The advantage is you get a much better feel of the candidate over this continuous process, than you would with shorter interview tasks.
yes but at least Brexit really happened.
Well the US is making them care by punishing China with this move.
X media controlled by X doesn't mean other media is not accessible. I'm all for local media (of a significant size) not having foreign influence as long as you can have access to foreign media. It's actually awesome to hear about your country from something quite remote, like for example Al Jazeera. It puts things in perspective.
This is a good idea. The tree constructed by a parser is relatively likely to want similar lifetimes for most of the nodes.

If the nodes are mutable you can link them together as you go, meaning some amount of overhead in the structure for links that aren't in use, but no garbage left behind.

Storing pointers as distance from the start of a contiguous arena means a structure you can mmap later without relocating.

All good stuff.
Yeah the JVM is quite fast at this point after it starts up.
>do you consider yourself neither left nor right on the political spectrum, because you believe that society is fundamentally broken and both sides just further consumerism in different ways (the right supports big business directly, and the left tries to create equal opportunities for everyone to further consumerism)

No, because I find that extremely reductionist, simplistic and naive. In my experience points of view that abandon nuance in favor of equivocation and cynicism tend themselves to be attempts at propaganda and control.

It is true, if you adopt the left/right political model (which you don't even need to, it is itself a propaganda tool meant to normalize the two party paradigm in American politics) that both the Democratic and Republican parties in the US serve the needs of capitalism and the military industrial complex. It is not, however, true that all leftist ideology and all right-wing ideology are essentially the same as a result, and that neither have any purpose or value beyond simply being vehicles for capitalism.
Yes you have the right to tell your employer to "fuck themselves", but will find that you no longer have a job a millisecond later. When it comes to an employer-employee relationship an "optional" request isn't really optional.
It seems that you're trying to "educate" me on how containers and virtualization work, when in fact I've been doing this for a while, on macOS, Linux and Windows (itself having its own Hyper-V pitfalls).

I know you mean well, though.

There is no Docker on macOS without a hypervisor layer - period - and a VM, though there are multiple possible container runtimes not named Docker that are suitable for devops-y local development deployments (which will always, of course, be constrained in comparison to the scale of lab / staging / production environments). Some of these can better leverage the Rosetta 2 translation layer that Apple provides, than others.
That's true. Also there are too ways to approach it:
1. Brew as much as you would use on a busy day and price in wastage in case it doesn't all sell.
2. Brew a small amount and price it higher so that only a small amount needs to be sold in order to turn a profit.
Those kids are growing up in much harsher circumstances. Little money, parents working multiple jobs, homes with flaking lead paint, communities with lots of drugs and poor access to preventative healthcare. It also creates a vicious cycle where the culture adapts to distrust and discourage academic achievement, in favor of lottery odds in sports and entrepreneurship.
Not so easy. A lot of crime in zones with high density of immigration goes unreported because immigrants are illegal. A lot of crime in shit neighborhoods goes unreported because of "code of silence" mentality.
The scanner can probably be zero allocation though - zig should be able to express an iterator over the input byte array that returns a token on dereference without needing more state than the position in the array
I don't know what you mean. Maybe in the early early 80s that was the case, but PCs were still 16-bit back then, and would've been a poor fit for Lisp anyway.

One of the reasons why the Lisp machines died out is that round about the mid-80s or so, compiler technology improved for generic 32-bit processors, and it became possible to run Lisp software on a VAX, 68k, or RISC CPU faster than it ran on the Lisp machines' bespoke architecture. Back during the first AI hypecycle, the makers of Golden Common Lisp introduced the Hummingboard to the market, billed as an inexpensive solution to have a "Lisp machine in a PC". It was just a 386 on an ISA card (predating Compaq's 386 PC by about a year) with gobs of memory on board; a special build of Golden Common Lisp allowed code to be run on that CPU rather than the main one.
Yep I misread that.
That’s merely an elaboration on the same theme.