skysight-inc/HackerNews huggingface dataset:
I think the other obvious worry is that people post well meaning answers on the job, but it turns out that their contract says their employer owns the copyright to all code they write on the job.

They have no ownership over the copyright to give.
It does not. I tried to replicate some symbolic computation code I wrote during my PhD in Mathematica in SageMath, and I just failed to get anywhere despite weeks of trying. I don't think I don't understand SageMath enough.
It sounds like you’re not really a libertarian then. Fwiw, this consequentialist (rather than deontological) view of libertarianism that you’re espousing is what turns libertarians into either liberals or conservatives.
Well, the latter might not be as shoppable (you know, because it's time sensitive), but joint replacements certainly can be.
Guidelines for Business Meetings
To someone on HN who isn’t familiar with what ECC does that explains nothing about how ECC works and how it could have prevented these situations. Or how often they really happen.
No. It uses a unified package of LPDDR4x SDRAM
I like the idea of looking at implications and limitations. That discussion can be useful for understanding. However, at the end I think all options need to be filtered through "will it work?" Because if it doesn't there is no point. That discussion may also result in a change to the definition used for weather it works or not.
K&R C also doesn't teach how to write code that is actually correct in modern C compilers, nor does it teach C best practices on how to at least try to write safe code in C.
Need help: Pricing strategy for a developer tool with 400000 users
I need an opinion, I am a developer and in 2019 I built a tool for developers(it falls in collaboration tool category), I set this tool for free and during 2019 we gained around 15000 users, things were going smooth until Covid-19 came and our tool exploded in popularity.

We get around 20000-35000 new users every month and have around 400000 (Four hundred thousand users) in total, every month around 80000-100000 users use it actively. All the traffic was from Google organic and word of mouth, i recruited 2 fellow develops as co-founders and we spent the whole 2020 to develop the features and make it enterprise ready.

It is free until today and from 1st feb 2021 we want to launch a Paid version. Now we are not sure how to price our tool, we have 3 main competitors and the largest one have around 60000 users, but we marketed our service as a free tool. Now we are thinking about having 90% of the features as free and then offer a Pro/Enterprise plan with features like (SSO and integrations) etc in the paid plan.

The challenge is that there are 20-30 other tools poped up in last 12 months and most of them are copying our strategy of marketing it as a free tool. Now how should we approach this, if we go very hard on pricing and locking features we fear that our users will go to those free tools and our growth momentum will fall. On the other hand we also want to have reveneue and also want to reach 1 million users. Please give ur suggestions as I am very depressed due to this situation.

OTHER NOTES: we are a team of 3 developers and have 2 freelance developers, we have not made any money from our tool and received an equity free grant from Govt (In EU we have this option), we were approached by few investors, 1 want 30% equity for 250K USD(we said no), and other is waiting for some paid conversion. We have spent around 50K of our own investment and 75k from the grant until now, monthly infrastructure cost is around 3000 USD
Isn't this a huge vulnerability that rises to the level of "Chrome team should police this"?

I mean, just thinking potential threats (which now I'm removing the extension because of them):

-- corporate web pages potentially sniffable if installed on work computer

-- personal passwords, password manager traffic

The potentially malicious actor is able to just scoop up any domain's encrypted traffic, isn't it? Or is there any practical assurance that they're only gathering domain names, high level traffic stats, etc?
> These prices are fairy tales. It's a figure next to no one will actually ever pay. Insurers pay less. If you ask for a discount you will pay less.

Columns H through AI represent the negotiated insurance rates or agreed schedules. AJ represents the lowest negotiated charge for that service across all providers.

Interesting reading, really. Aetna largely seems to pay retail, whereas others like Cigna and Emblem are getting "decent" discounts. Also provides a good basis for negotiation if you're a cash payer. "I can pay your minimum negotiated charge for this, or I can dispute it during collection"

But even still, these prices are ridiculous even after negotiation and are indicative of a broken system. For what it's worth, hospitals aren't charging these fees because they're profiting; many of them are struggling to stay in the black.

(I used to run appsec at a healthcare best practice and advisory firm. A lot of my background on this was absorbed through osmosis, though I can't say I'm an expert)
The UK military (amongst others) map stakeholders into one of four categories: Responsible, Accountable, Consulted and Informed. (RACI) [0]. Stakeholders tend to sit up and take notice if they think they might be Responsible let alone Accountable for something.

Note: the distinction between Responsible and Accountable is really important but not always understood. If a manager puts an untrained employee in charge of something, it is the manager who should be accountable when something bad happens, not the employee.

[0] https://en.wikipedia.org/wiki/Responsibility_assignment_matr...
I do something similar and, depending on which group a given stakeholder falls into, determines how much effort I put into getting their input.

For those in the 'agree' group I plan ahead to ensure I can get time with them 'in person' to discuss and debate the proposal in real time.

For those in 'accept' I email/post the document and ask for comments/feedback by a specific, reasonable, deadline. If they're too busy to respond then they've forfeited any right to criticize, complain or block the proposal later on. If they provide feedback that I don't implement then I need to have good reasons why I'm not and share that with them.

The 'understand' group tends to be upper mgmt who trust me and, so long as I've gotten everyone in the 'agree' group onboard, will support the decision/proposal. This is typically done in a regular 'check in' or via email.
We use a similar process, inspired by Basecamp[0]. For us it seems like the biggest challenge is getting feedback from the right people. Mostly due to the sheer number of pitches (RFCs, project proposals). And we're a small team. Also it's a bit difficult to decide what goes first and how to make sure we don't bite more than we can chew.

Overall I agree with the article that the biggest benefit is from writing things and thinking about them in a structured way. Some ideas sound great, but once you start digging, problems emerge. Being able to pull the brakes even before starting, or refining the idea to a much smaller core is perhaps the most valuable and non-intuitive benefit.

[0] https://basecamp.com/shapeup
I don't know if ECC is that important, but reliability of RAM (or any storage) feels pretty crazy to me.
128GB being refreshed every second for a month error requires that the per-bit refresh process has a reliability of 99.9999999999999999% to be flawless.
Considering we are dealing with quantum effects (which are inherently probabilistic), I wouldn't trust myself to design anything like that.

Now back to ECC, I'll probably be corrected, but I don't think ECC helps gain more than two order of magnitudes, so we still need incredibly reliable RAM. If we move to ECC RAM by default everywhere, aren't we simply going to get less reliable RAM at the end?
He uses "do do" instead of "to do" which is a more obvious typo. Linus usually comes across as borderline arrogant, and deservedly so, but not necessarily perfect in his writing. I think it's an effective strategy to communicate his priorities and wrangle smart but easily intimidated folk "do do" what he believes is right!
> My stack requires no maintenance

That’s all fine and good, if it’s true and you anticipate it staying true. And plain HTML and CSS can go a long way for a static site.

But when you want to change something site-wide, and you’ve accumulated a lot of content, it can be a ton of work to do manually and incredibly error prone to automate.

This is where we reach for tooling. Even if it’s just a simple template engine to generate HTML/CSS. After all, the author is right: that stack will outlive all others. But all the others (for web) are fundamentally built on it.

Now, it also depends a lot on the complexity of what you want to build into HTML/CSS. For instance, I’m working on a site with art derived from some fairly involved maths. All of the art is rendered statically. I could manually calculate the various inputs and outputs, but what a pain. And my intention is to evolve the art over time (again still rendering statically, but existing images will be updated), which would mean going back and manually recalculating each one. Exponential pain.

The thing that bugs me about this tech-minimalism web trend that’s pervasive here isn’t just that it’s a weird sort of Luddism, but that it’s fundamentally uncreative. There’s great work being done on tech stacks that allow us to write programs to solve repetitive and complex problems but still ship efficient code to the client. Not just the current breed of static site generators, but also more involved tools that strip out code at build time allowing eg components which are static by default but progressively enhanced with some interactivity. Examples:

- Microsite (I’m currently investigating this for my project)

- Preact with partial client hydration (there are a ton of proofs of concept out there)

- Solid (which is also investigating partial hydration)

- Marko (does partial hydration automatically with static analysis)

- Similar efforts for Svelte and Vue

- React server components

All of these may be dead ends in the long run, but the progression toward powerful build tools that produce efficient sites is a good thing, and the web will benefit from it without trying to force an extreme tech minimalism that will never capture a large part of the web dev culture because it’s inefficient for a lot of what people want to build.
Castlevania 4's password system looks identical from the player's perspective. I wonder how similar the implementations are.
> In the EU, there are lower charges for the merchant when a debit card is used.

This is definitely the case in the US. The fees vary between different acquiring banks, merchant gateways and cards, but generally they follow a pattern similar to the following:

CC - $0.25 + 1-4% of the transaction amount

Debit - $0.25 - 0.50 and no percentage
There was this NES game called "The Magic of Scheherazade" that had what at first looked like a very complex password system, but even as a kid, I was able to figure out how to exploit it to cheat at the game, giving me lots of money or start at higher levels, as it wasn't actually hashed very well.

The game itself is kind of obscure and looks like it's a cheap ripoff of Legend of Zelda (there are several scenes that are actually blatant rips), but it's got a lot of depth and is a lot of fun, even today. There's both over-world-action- and turn-based combat, and a whole time travel component.

IIRC, the password system was so bad that you could create game-puzzle-breaking states with it, to where you were in certain levels without items that you needed to progress.
Then you'll have to pay a huge primer for that privilege. I can assure you that your standard computer components are not rated for century-scale use.

That's why I've always been on the fence with this ECC thing. For servers it's vital because you need stability and security.

For desktops I think that for a long time it was fine without ECC. If I have to chose between having, say, 30% more RAM or avoid a potential crash once a year, I'll probably take the additional RAM.

The problem is that now these problem can be exploited by malicious code instead of just merely happening because of cosmic rays. That's the main argument in favour of ECC IMO, the rest is just a tradeoff to consider.
Now days it's more likely to be included in an accessibility menu. Games like Celeste, for instance, have options that might have historically been called "cheats".
> For a 2nd language speaker making these homophonic mistakes is actually a sign of fluency.

I kinda disagree because while the homophony works in (spoken) English in written it stands as a sore thumb. So yeah you will make it if you only heard it but doesn't know the written form.

(And in their native language it's probably two unrelated words, so that might intensify the feeling of wrongness)
You've already ID'd the way forward: Bootstrapping.
I have usually had at least fifteen stupid little problems by lunch time every day, so just try to be cognizant of the irritating things that you regularly come across. The chances are pretty good that someone is already selling some cool widget that attempts to solve your exact problem. I am not saying that you will encounter huge problems to solve, but you can at least easily entertain yourself.

Or you could watch MacGyver for some inspiration... I have been inspired to build a time machine to go back in time so that I can inform Richard Dean Anderson that the mullet is actually not a cool haircut.
Most of these projects are token sales and yes you can discount them as the technology is irrelevant to the scheme

Winners in an ICO utility token sale (a gift card sale, not equity/money only marketed as such). Coin FOUNDERS that get a starting stake. Early INVESTORS that get coins at a discount. INSIDER traders that know when the positive media or coin listing will happen. EXCHANGES that get paid to list and pump the coin. Loser. You the bag holder
> there are checks to ensure that expletives and comments that might cause severe repercussions (i.e. political statements) are not inserted

Related: In the past, after Microsoft was forced to release Hyper-V linux driver source code under GPL, someone noticed 'naughty phrase' in magic number that Hyper-V used, which is '0xB16B00B5' or 'BIG BOOBS', Microsoft apologized afterwards [0]

[0]: http://www.networkworld.com/community/blog/microsoft-code-co...
I'm hoping the next generation will move off of TI-8x calculators and into things like Octave for grade school use.

There was a point in my education where I had mastered my trusty TI-83; I knew the purpose of every single function and how to use them. But then, I started running into problems in the real world that required more than 32 KB of memory to solve. When I moved to a laptop I had to relearn all of that knowledge again. Haven't touched my TI-83 since.

It would be nice if the tools we learned how to use in school could also be useful in solving our problems after we graduate!
Yes, auto-corrects compound the problem.
Vivaldi also has hibernate feature for a while and Firefox too if I'm right.

TGS caused issues resulting in loosing pinned tabs in Brave and Vivaldi and so I had to remove it there; Now I'm glad I had to do it.
There are situations though, where you’re working on a document and the documents “save” format is a memory dump. Corruption for things of that type (Adobe RAW for example) would remove data.

It might present itself as a 1pixel colour difference, but it could be more damaging (incorrect finances, in accounting software for example). Software trusts memory; but memory can lie.

That’s dangerous.
I guess you are talking about this `Visitor` trait [0]. I have only used serde in combination with the derive macros so please enlighten me, but each `visit_* ` function of the `Visitor` trait already takes a typed value (`bool`, integer types, ...) so these already have too be parsed (instantiated?) from the input string/bytes. Couldn't you have an `SerdeTypes` enum that implements `From` for each `visit_* ` type to remove some boilerplate and then use pattern matching? Could you elaborate where there would be overhead?

Don't get me wrong. I'm sure, the serde developers know better than me and have good reasons to implement it the way they did, but I'd like to understand the rational behind the decision.

Edit: formatting

[0]: https://github.com/serde-rs/serde/blob/master/serde/src/de/m...
Because otherwise, unscrupulous company X can harm paying Apple customers with unvetted malicious apps
That is what I wanted to say. The Python scientific ecosystem seems like it is written by programmers for scientists, while Matlab/Mathematica seem like they are written by scientists for scientists.
Interesting product, but the examples are weak. I expect AI to personalize landing pages for every visitor in the future. Still, right now, I don't trust it enough to touch my bottom line.
Indeed the two binary rails approach corresponds to a logic as well, namely Belnap's A4:
https://en.m.wikipedia.org/wiki/Four-valued_logic
I don't think it generally should for modern devices. They generally just throw compute at the problem, attempt to acquire every possible satellite at every possible location in parallel, and then download all their ephemeris data in parallel (which is more precise than the almanac, but only available once you've actually acquired the satellite). Makes the almanac kind of redundant, and typical acquisition time is anout 45 seconds doing it that way since the ephemeris data is broadcast much more often.
Thanks for posting these links.

What I miss in those solutions is the possibility to add text to your photos like it is done in Google Photos. The ability to give albums contextual background with a nice and simple typesetting is a key differentiator from the classic solution to keep picture files in folders (on-/offline). photoprism seems to have such functionality. The text, however, is associated to a photo, and not to an album like Google Photos.
$15 minimum wage for Chinese workers. Where is that?
The problem is that, if you don't have ECC to detect the errors, it's very hard to know what exactly caused a random, non-reproducible crash. Especially in kernel mode where there's little memory protection and basically any driver could be writing anywhere at any time.

I can understand Linus's frustration from that point of view: without ECC RAM when you get some super weird crash report where some pointer got corrupted for no apparent reason you can't be sure if it's was just a random bitflip or if it's actually hiding a bigger problem.
Hopefully during 2021, LLVM won't be any longer the only option to compile Rust, as the work for integrating cranelift backend into stable keeps going on.

Zig also has the same issue with LLVM until the language is fully bootstraped and the original LLVM based compiler no longer part of the build process.

However, packaging a C and C++ compiler alongside for the ride doesn't make it that much simpler.
But then it's no longer stateless. So you've lost the primary benefit, while losing the ability to store any other associated secret information in the vault.
I would recommend https://github.com/PaddlePaddle/PaddleOCR over the default tesseract. It seems to do a better job these days and uses more modern approaches.
That's the start , yes. What are my other options ?
One thing that I found to work well is to create an escalation process. By default people are trusted to make decisions but if they fail to do so, then there is a higher authority that will make it and has the trust in the organization to do so.

I’ve used this for open source projects with prettier and excalidraw and at work too.
Found something interesting - https://www.upmyinterest.com/article/investportfoliolt

SP 500 was -5.9% in 2018, but it went up to 31% in 2019...pretty fair.
I would agree with all of these points except "pattern matching". Yes several libraries implement it, but it is not built in and even the best libraries feel clunky compared to for instance the built in destructuring. Rich explicitly rejected pattern matching ala ML for the reasons provided here: https://gist.github.com/reborg/dc8b0c96c397a56668905e2767fd6...
This might address the "closed source" problem (although personally I'm skeptical it would work), but doesn't address the problem of how to get people to perform reviews.
If you want to know why the Collison brothers are so rich, it’s because they were the only deeply technical guys who also had the ability, interest, and energy to deal with all this.
Reveal, REPLs and Networking
You don't need to look at kernel crashes to speculate about bus and memory errors -- just check the logs on a few systems that do have ecc. Pretty soon you'll see correctable errors being reported.
I've had an extension which I downloaded for automatic tab reloading on chrome insert porn ads into YouTube, I think the extension was removed after reporting but considering Google does take payment for publishing extensions (Unlike Mozilla) and puts them through review; Why not do it right?
(I guess I could google for a few hours to find out, help on this would also be appreciated)
I tried to sign up for their wait list but gave up after entering my real name, a fake date of birth, and a fake phone number, which means I couldn't get their verification code. I understand asking for demographic info to prioritize a wait list, but that's not what they're asking.

why do they need all this info for a wait list of a service they don't yet provide? this doesn't inspire confidence.
A system on Earth, at sea level, with 4 GB of RAM has a 96% percent chance of having a bit error in three days without ECC RAM. With ECC RAM, that goes down to 1.67e-10 or about one chance in six billions.

So I'd say ECC is not only important but insanely impactful. There's a reason why many organizations don't even want to hear about getting rigs with non-ECC memory.
Of course it would not be the only element in the table. But either way, it would at least tell you that an extension is leaking data when it isn't supposed to leak data (for extensions that should not require an Internet connection).
Sounds like we need to reinvent data stores!

SQL is due for replacement. The combination of schema and data in one constantly mutating hodge podge with no atomic immutable versioning or rollback is absolutely ancient. Migrations are an okay hack but definitely not good enough.

ZFS and LVM prove filesystems can do snapshots and restores on a version of filesystem history without a lot of pain, so clearly we just need more work here to make it an everyday thing. Versioning should be the default and probably also an infinite transaction log, seeing as capacity and performance is ridiculous now.

And couldn't we lock writes, revert a perpetual write journal/transaction log to some previous version, and then continue a new write history tree? If you run out of space, overwrite the old history. If you don't run out of space, allow reverting back.

And allow bulk atomic updates by specifying a method to write files that aren't 'live' until you perform some ioctl, and then atomically expose them and receive the new history version. Then you could do immutable version-controlled storage on a filesystem, right?

Blob/object stores should be much simpler to do the same with. Just an API rather than ioctl.

In this way, replacing a data store immutably will just be replacing a reference to a storage version, the same as using snapshots, but built into the filesystem/API.