skysight-inc/HackerNews huggingface dataset:
It does make a lot of sense actually. Because cats are predatory, we need to regulate our domestic cat population by keeping them indoors, otherwise their predatory nature will destroy local populations of birds and other animals.

So a for-profit business is greedy by nature, so we need to regulate its natural impulses since it can’t control them itself, much like the cat.
Well, give the finger at climate change! Namely, buy an AC to restore back your energy stolen by the heat wave, that to be able to do more than binge watching youtube vids.
You may find this tool interesting

https://picto3d.com/
15k Reddit comments mentioning pc parts, extracted using NER with spacy
Is this a thing you’ve seen? Really cool idea!

I doubt many would actually use it because complainers on HN aren’t average users, and the number of months you’d have to prepay would likely be quite high to actually make it make sense for the businesses involved.

But still, if you could make a business reselling monthly subs as 1-off purchases, it would be pretty dang cool!
I don't think so. GP is simply making intentionally over the top comparisons to show a potential timeline of how this could go. The obvious absurdity of the comparison is not "transphobic" (whatever thst vague term means), and could have been any over the top comparison, they simply picked a topical one.

If this were slashdot, I'd be giving it a funny/insightful.
What happens is that you'll have to use less stuff and learn to be content with it.

What this means for the endless, exponential "consumer" ideology is that it isn't sustainable in the long run. This should be blindingly obvious but for some reason many people weren't or aren't seeing it.
I will gladly pay for the new version, when they amount to something I care about. Most of them isn't worth it - I would rather accept some minor bugs.

Jetbrains has very good model in that regard. Hope they will not ruin it (new pricing for self hosted Spaces is bit concerning).
Let me add some more fuel to the debate - How can software-as-a-service be regulated in a way that it balances consumer rights and the rights of a business? Perhaps:

1. Every SaaS business should be compelled to offer both a subscription price and perpetual license at a fixed price.

2. The fixed price of a perpetual license should not be more than 10x or 20x (?) of the monthly subscription price.

3. If a user has opted for subscription payment, they should get a perpetual licence after they have paid a certain subscription amount over a period that is not more than 2x or 3x of the fixed price of the perpetual license.

4. SaaS businesses should not be allowed to hold users data hostage if the user decides to end the subscription. (This can be tricky if the data is in some proprietary format).

5. As much as possible, the SaaS should be able to run offline on a user's computer without needing to offload computing to servers.

Ofcourse, most of the above are practical only for software that you can actually run on your computer and don't require massive computing powers from data centers that some services may need. But then again, that's exactly the kind of software that don't need to be SaaS at all in the first place, as the article too points out.
Rather confused by this claim that GNOME 2 was helloworldware. GNOME 2 was one of the very few Linux desktops that saw widespread usage within large companies. Red Hat and Canonical had professional offerings based around it. It attracted a small chunk of home users who were pissed off by Windows Vista. So it definitely got UX tested quite a lot. Red Hat Linux actually still includes a builtin clone of the GNOME 2 design just to cater to people who have been using the same UI in a professional setting for decades. They only recently switched away from this classic clone layout being the default.

KDE is the one that was way more community-focused, but it did see a bit of use for professional workstations.

You may be thinking of GNOME 1 - it was incomplete garbage.
I believe OSI was at least as much corporate as it was governmental. And, like most corporate solutions it ended like it ended, with design by committee.

IP on the other hand was neither, like much of successful technology.

As a side note, the OSI layers are useful as a mental model, but trying to maintain that separation in actual implementation is a poor idea; that’s one of the things IP got right: it doesn’t really match OSI layering, and does cut through layers when it makes sense.
It is often the _device_ that needs better band steering abilities and the Access Point can't do much to force the issue.

Or did you mean that the GP should upgrade both their WAP AND all of the their connecting equipment?
This isn’t unique to Apple, I believe Windows also does this and there is even an RFC explaining the concept.

Also it’s not so much that it deliberately “messes up” anything, it’s more that a DHCP server shouldn’t tell a client device that it holds an address for a certain amount of time and then either not honour it or forget that state. It’s a reasonable thing for a client to resume using an address if there is time still left on the lease and wasn’t told otherwise and the ARP collision detection mechanism is supposed to detect conflicts before it becomes an issue.

Unfortunately, DHCP implementations in the wild vary in quality considerably and the people administering them don’t necessarily understand the inner workings of DHCP all that well either, because as long as it hands out addresses, they normally don’t ever need to.
Show HN: CharityStack|Stripe Atlas for charities|formation, fundraising, banking
Hey HackerNews!

I'm Mubarrat, one of the founders of CharityStack. CharityStack is a platform for anyone to form a nonprofit, fundraise their first dollar, and set up their bank account. We want to make it seamless for anyone and everyone to start a charity and make an impact.

Why build CharityStack?
Before CharityStack, my team and I attempted to create a charity and it was an absolutely terrible process. It took us nearly two years, a couple of thousands of dollars, and a bunch of headaches in between. We quickly realized that we weren't the only ones that had this problem, but something widespread whenever anyone attempts to create a charity.

With Charity Stack you can:

Form your nonprofit:
- State Incorporation
- Federal EIN
- Bylaws
- Conflict of Interest Policy
- Solicitation of Funds Certificate
- 501c3 Application

Fundraise your first dollar:
- Credit Card Transactions
- Bank Transfer
- Apple Pay
- Google Pay
- Paypal & Venmo
- Reoccurring Donations

Set up your bank account:
- Checking Account
- Virtual Debit Cards
- Physical Debit Cards
- Wire, ACH, Checks
- Investment Account
- FDIC Insured up to $250,000

For a limited time, we're waiving fundraising and banking stack pricing for a year for the first 25 charities, just make sure to sign up on the link below

We have a waitlist up on our website here: https://www.charitystack.com/sign-up
The customer pays when a feature they actually care about breaks, and they upgrade.

Sell it as is, or with a very short one year support window. Exactly like all sorts of companies used to profitably do until they realized they could extract more value for the same work with a subscription.

Rent-seeking in the most literal form...
No one is going to use an unpatched bug in your chair to rob your house.
To expand:

There's a prioritized list of requirements in engineering. Use the right tool for the job.

Rust has: (see https://hackmd.io/@rust-ctcft/r1plN4You#/5 )

1. Safety

If you don't need that at the first slot, then the biggest strength of Rust doesn't apply to your problem (and you would waste time having to track lifetime parameters more than necessary to solve your problem).
In 64bit, RISC-V does easily beat ARM and everything else.

In 32bit, it is about as good as m68k and x86, which are quite dense. A good result. Just not as small as ARM thumb/thumb2.

However, RISC-V is not done yet; it will see further improvements, coming from B extension (already ratified, significant for size, and yet wasn't in the test) and from the ongoing Zc size-reduction work[0], which does already achieve a sizable reduction[1].

0. https://github.com/riscv/riscv-code-size-reduction

1. https://docs.google.com/spreadsheets/d/1bFMyGkuuulBXuIaMsjBI...
This has been one of my favorite talks, especially "Don't settle for 'make boot faster.' It's the wrong question. The question is 'make boot fast'"

The opposite of this was the massive performance improvement that sqlite had a few years back. Many small incremental improvements that add up.

These 2 approaches are IMHO what you have to consider if you want to go fast.
It's an interesting question. It'd certainly be an odd cooperative.

Most cooperatives have a large number of members with roughly equal economic power. So, ideas like one-member-one-vote and equal income distribution make sense.

However, in the case of companies requiring FOSS services, I imagine the most valuable customers would be large corporations working in highly risk averse industries like telecommunications and banking that feel the 'need' for a support contract to go along with their linux distribution.

But there would likely be a mix of large blue-chip companies, smaller service suppliers to the aforementioned companies, and other companies that want to leverage services beyond consulting like Red Hat's managed OpenShift offerings.

So our FOSS cooperative membership distribution would probably be heavily weighted towards smaller companies, but most of the revenue would come from the long tail.

I don't see how the small cadre contributing the majority of the revenue would be satisfied having effectively zero voting power. So you might have to mix up the model a bit to assign voting power on the basis of revenue contributed or some proxy like the number of contracts signed.
Again, this isn't a right/wrong thing. Rust moves by default (and a lot of people find "=" a weird pun for that), C++ copies by default and has rvalue-references and an explicit `std::move`.

If you want copy in your C++ lambda, you start it `[=](...) {...}`, if you want take a pointer in your C++ lambda, you start it `[&](...) {...}`, if you want something trickier you do trickier stuff.

Rust opts you in to the nitpicky static analyzer and you have to opt out with `unsafe`, in C++ you have to opt in with e.g. `clang-tidy` or some annotations.

They are remarkably similar, just with different defaults.
This is why we subscribe to things like Disney+ through the App Store app. On iPhone/Mac you can just get an overview of all your subscriptions and cancel them there.
I am never gonna win any game of this. fax!
Another idea: pausable subscription (like cancelling then re-subscribing, but without the hassle or stigma). I think I've seen a music plugin do this before. It's the idea of losing money to "idle time" that makes me allergic to subscriptions. You'd have to be a business that constantly uses the product for that to make sense.

The opposite effect is you are pressured to keep using the product and I feel my friends are losing valuable time because of their Netflix subscriptions.

Pay-per-use might also be a similar option, and I'm happy with many web services working this way.
At the expense of unrealistic download size.
Windows 3.11, Office, Windows 95 etc seem to have done ok without monthly payments.
The mentioned advantage seems dubious considering that the only cell type for which that is currently true is those using lead, for which the toxicity issue isn't solved. Trading the complexity of the cleanroom facility for the complexity of lead containment doesn't appear to be a good choice. The tin based cells might look interesting though.

PS. OTOH I wasn't aware that Si based panels might have lead in them, too (even though much less?) as per https://news.ycombinator.com/item?id=32283432
> One of the biggest issues with reference counting, from a performance perspective, is that it turns reads into writes: if you read a heap-object out of a data structure, you have to increment the object's reference count.

This is one of the biggest misconception about RC. You need not to increase the refcount just to read the referred data because you already have a reference whose count has been increased when handed down to you. That’s a semantic that’s very well carried off by Rust’s Arc type: the count is inc’ when the Arc is cloned, and dec’ when the cloned Arc is dropped. But you can still get a regular ref to the data since the compiler will be able to enforce locally the borrow, ownership and lifetime rules.

For example, in a web server, you might have the app’s config behind an Arc. It gets cloned for each request (thus rc inc’d), read a lot during the req, then dropped (thus rc dec’d) at the end of the handler.
There were these things called API spies back in the VB6 days that would figure out the appropriate way to refer to whatever you clicked. The one from PatorJK would even produce code to do things to it from downloadable templates.

It's still around: https://patorjk.com/blog/software/

I wonder why no one ever made something like this for the web.
Interesting, Rolls Royce is doing the same in the UK and have been working on this since last year [0].

After having dealt with SONGS not long after Fukushima and seeing first hand the long-term adverse effects of Chernobyl in Europe I became anti-nuclear, but in time I realize that in reality what I was actually anti 20th Century nuclear business model and the corrupt regulatory frame work as most were built haphazardly in locations with immense inherit pitfalls, coupled with poor long-term logistical and waste management planning and ignored continuous warnings to decommission--TEPCO stated that the Fukushima disaster was entirely avoidable.

And that is what I think still needs to addressed, because the regulatory capture of these agencies poses a much bigger issue than these small reactors do, which are seemingly promising solutions to contribute to the World's energy needs.

0: https://www.rolls-royce.com/innovation/small-modular-reactor...
What a stunning observation that I totally hadn't considered. /s

This is an overused excuse that does not actually justify nearly as much as what it's used for.

Also, online services suffer leaks and outtages and 3-letter/police pressure that I have no control or knowledge of that self owned self hosted software does not.

None of the excuses for rent hell are actually valid. They are just the excuses used to sell the idea.

The fact that services have their own problems does not mean there is no such thing as a valid service, or that the security update issue is not a real thing, it just means that this security update issue is just a thing like a lot of other things, that only really necessarily applies in certain cases, and doesn't apply everywhere, and doesn't override all other concerns, and there are other equally valid issues that are addressed by the opposite sort of model. Ie, it's nothing special and does not excuse or trump anything else.
The colors on the site, dark letters on a dark(ish) background, make it very hard for me to read
Disabling IPv6 is recommended? I thought we are all moving to use IPv6.
Was just going to recommend Stop the Madness!
I have come to be OK with some subscription models, but not all.

I think SaaS, and even many platform applications, are OK as subs.

"Buy once" platform app models are subs, anyway. It is unreasonable to expect a software developer to keep a package updated through many new operating systems. Some systems, like MS Windows (and, I suspect -but don't know for sure- Linux), do a great job of retrofitting, so older apps can often keep going, but most mobile systems won't. Apple is in the middle. It supports a ways back, but will deprecate features that older apps may require.

I used to buy the Adobe CS suite, yearly. Each year, I would get an upgrade, as the software would usually get new features that I wanted. I suspect that, eventually, the version I had, would stop working, but I never let it age that long. I probably could have gotten away with reupping every two, or even three, years.

I like the new sub model. I get access to every single Adobe app, at a lower price than what I paid for my yearly upgrades (but more than if I did it bi-yearly). This allows me to do something like install inDesign, if someone sends me an ID file. I don't want to keep the app around, otherwise.

SaaS is basically built around a "service," and "services," by definition, are subs. If I subscribe to a newspaper, that paper hits my doorstep every weekend, until I stop paying the bill. That's an ancient model, that has not changed; nor does it need to.

Hardware is another matter. I can see having a piece of hardware that could benefit from regular firmware updates, but I think it should keep running at spec, with a single firmware setup, despite new versions coming up.

I'm also pretty cynical about hardware that is sold with "lifetime upgrades." It's been my experience that "lifetime," is actually only a couple of years, before the firmware stops being upgraded. As long as the device keeps working with the last firmware, then that's basically what I paid for, anyway. If the device is "time-bombed," though, that's just evil.

If the device works, but uses a SaaS subscription, then I would think that the manufacturer needs to figure out how to keep supporting the device for as long as possible, and have some way to transition the device to “standalone” operation; especially if the company is going out of business, or phasing out support for the hardware. This would probably require legal backing, against corporate officers, personally, as corporations can get off the hook, fairly easily.

Also, I think we should do away with "lifetime" anything. I think the expected lifespan of stuff (like firmware updates and SaaS support) should be spelled out at purchase time, and legally enforced.
Testing Vulkan drivers with games that cannot run on the target device
But can a developer live off of $10/year? You would need a lot of customers, compared to a more expensive $8/month model.
[1] and [2] look fine and considered. I'm not watching a youtube video.
Please make a modern airport base station.
More profitable, of course. Why do you assume a corporation wouldn't do that?

That doesn't mean the rest of your statement, but if that happened then competition in a free market would take care of it. Perhaps you can start the next billion-dollar Adobe?
TLDR: The conflict range is the entire SQLite database. mvsqlite does not support concurrent read-write transactions to the same DB. If multiple RW transactions with overlapping [read_version, commit_version] ranges are are requested to be committed, only one of the commits will succeed.

To scale out writes, you can use smaller databases - one database per user, for example. It is possible to do multi-database serializable transactions with mvsqlite (not yet implemented, but the logic shouldn't be complex).

mvsqlite actually doesn't just use FDB's native transaction, as I would like to avoid FDB's low txn size and time limits. Instead, there are two separate keyspaces for each SQLite DB - one "page index" keyspace, and one content-addressed store keyspace.

For reads: Pages are fully versioned, so they are always snapshot-readable in the future. The read version is fetched from `mvstore` when each SQLite transaction starts, and is used as the page index per-page range scan upper bound in future read requests.

For writes: Pages are first written to the content-addressed store keyed by the page's hash. At commit, hashes of each written page in the SQLite transaction is written to the page index in a single FDB transaction to preserve atomicity. With 8K pages and ~60B per key-value entry in the page index, each SQLite transaction can be as large as 1.3 GB (compared to FDB's native txn size limit of 10 MB).

So actually, you can do one page read or write per FDB transaction and still preserve ACID properties.
It takes significantly more effort to constantly catch hundreds of small time unknown criminals versus the handfuls of elites in the public limelight or government positions.
> people who presumably “have it all” because they gained financial freedom are often depressed…

Is this the case though? I know it’s not your main point, but it’s a premise that I think should be questioned. I can think of reasons why it probably wouldn’t be true, and I wouldn’t be surprised if data indicates that financial freedom correlates strongly with mental health. And I can think of many reasons why this popular notion (that the wealthy are often unfulfilled and miserable) might persist even if it’s not really true in general.
From where I sit the killer feature of Rust is that a bunch of amazingly cool software is written in it, especially in the terminal. I'm a big terminal guy, and I can't think off the top of my head of anything I use constantly that isn't written in Rust. `rg`, `fzf`, `zoxide`, `bat`, `viddy`, the list goes on and on, I fucking love the shit people are writing in Rust.

And I think that should be the killer feature of a language: that cool software is written in it and is continuing to be written in it. This is a killer feature shared by Rust and C++ and these days to be serious about performant software in diverse settings, you pretty much have to know both well.
I don't think that's intentional. Russian doesn't have articles [1], so misuse (or omission) of the/a is not uncommon when Russian speakers write English.

[1] "Definite and indefinite articles (corresponding to 'the', 'a', 'an' in English) do not exist in the Russian language. The sense conveyed by such articles can be determined in Russian by context." https://en.wikipedia.org/wiki/Russian_grammar
The problem with subscriptions is the difficulty in canceling. To join XM Radio or the Wall Street Journal is quick and easy. To cancel requires an hour long phone call navigating through high pressure sales.
Fun fact from Wikipedia:

> Since the beginning of the 1990s new high-speed passenger lines in Spain have been built to the international standard gauge of 1,435 mm (4 ft 8+1⁄2 in), to allow these lines to link to the European high-speed network.

(...)

> In general the interface between the two gauges in Spain is dealt with by means of gauge-changing installations, which can adjust the gauge of appropriately designed wheelsets on the move.

I didn't know that!
I'm assuming they were showing an example of a regex that will match a list of terms, and the sheer quantity of terms (rather than the initial presence of) weighted its score heavily.

It's a little unfortunate, but 3 days isn't terrible, and it's a good lesson in false positives.
> We'll see in a few years when more "heavy shit" has been written/rewritten in rust.

I'd really like to see that. Would be cool to see a completely new Linux user space written in Rust. Not necessarily a rewrite of existing software, new ideas would be great. I tested Linux system calls and they worked very well even though they needed experimental inline assembly functionality to work. With system call support, anything is possible.
Sounds like a mistake that will be corrected. Posting it about it elsewhere is just shit stirring.
It may be unrealistic for your business plan and your product (which is fine, no criticism here), but the existance of software that still uses the pay-once-use-forever model proves that it is possible for many apps without being unsustainable. E.g: Serif / Affinity, JetBrains (as you still get a perpetual fallback license to the last version you payed for, so it still can be viewed as a one-time-payment, IMO - just cancel immediately).

Infinite support or updates and a one-time-payment is unrealistic, yeah, ruling out cloud-based SaaS. But for common desktop apps and on-prem stuff, that just isn't neccessary. Drop support at some (previously announced) point and the customer can decide if they want to upgrade. Adobe CS6 still runs fine.
Storybook is awesome. Just wanted to clarify is has nothing to do with Facebook or Meta.