skysight-inc/HackerNews huggingface dataset:
All three letters of AGI mean different things to different people. As it happens, ChatGPT meets my pre-existing definition of AGI, though with a low value for the "I".

That it isn't IQ 100 is good, because, given what it read during training, given how broad it is, if it was that level by every measure, then half the world would have become almost instantly unemployable even if minimum wage was reduced to $2/day.
> Hand-writing YAML. YAML has enough foot-guns that I avoid it as much as possible. Instead, our Kubernetes resource definitions are created from TypeScript with Pulumi.

LOL so, rather than linting YAML, bring in a whole programming language runtime plus third party library, adding yet another vendor lock, having to maintain versions, project compiling, moving away from K8S, adding mental overhead...
The largest AI models currently in use have around 0.5 trillion connections between artificial neurons. Each connection is represented and quantified by a weight parameter, i.e., a single floating-point number that is learnable in training. For example, inside an AI model, a linear layer that transforms an input vector with 1024 elements to an output vector with 2048 elements has a weight matrix with 1024×2048 elements, or approximately 2M. Each element of the weight is a parameter specifying by how much each element in the input vector contributes to or subtracts from each element in the output vector. Each output vector element is a weighted sum (AKA a linear combination), of each input vector element.

A human brain has an estimated 100-500 trillion synapses connecting biological neurons. Each synapse is quite a complicated biological structure[a], but if we oversimplify things and assume that every synapse can be modeled as a single parameter in a weight matrix, then the largest AI models today have approximately 100T to 500T ÷ 0.5T = 200x to 1000x fewer connections between neurons that the human brain.

It remains to be seen how AI models will perform in IQ tests if we are able to increase the number of connections, or parameters, by 10x, 100x, 1000x, and beyond.

---

[a] https://en.wikipedia.org/wiki/Synapse
> This is why I've been saying stuff like "if rebinding is an option then why do key layouts matter", which you've yet to explain.

I've explained it several times, yet you keep ignoring the complexity in your trivialized binary option: the amount of effort differs even if rebinding is an option, so key layouts still matter

> If installing 3rd party software and spending tons of time configuring it is an option, I think key layouts matter even less.

For the same reason it actually matters: to reduce the amount of time spent

If you keep ignoring these simple facts you'll never get past your confused state of "weird to hear this so often. Macs also have the same" etc. or...

> I'm confused because you've yet to take a clear position on anything, instead you take small, generally inaccurate swipes at trivial stuff I write.

Which parts of the "better design ... more convenient thumb" confuse you? The swipes are also generaly accurate, thus you keep trying to do all the meta instead of addressing them directly.

> Sorry then, what did you mean by "docs" here

Company's keybinding help web page? You're making it up by trying to move the goalpost to narrower scope of "newer hardware" or "API docs"

> seems to be: "Cmd's position is more convenient for the operations other OSes use Ctrl for, and you can spend a lot of time in Karabiner if you want it to function consistently with other OSes".

That's also something you've made up again, on both points.

1. You can spend very little time with a few tweaks (like using a different keybind to cancel in the terminal). You need to spend a lot of time only if you insist on better matching the original conflicting design. But even then, the amount of time depends on the layout/OS

2. And no, it's not about consistency with other OS since the better design of Cmd on a Mac is NOT consistent with Windows. The goal is to achieve consistency WITHIN the OS so you can, for example, use the same key combo to copy in all apps
IQ tests absolutely test for the ability to reason through novel unknowns.
https://m.youtube.com/watch?v=YqWApMqD4h4

1:40
It sounds so dumb on surface that someone would go such a great length to try protect a vulnerable operating system for browsing by building a forked browser and not use a modern os such as arch/linux.
It's gotten better. I tend to buy guidebooks preferentially on Kindle these days. But I still get cookbooks in hardcover unless they're a super-bargain as well as "coffee table books" of course.
Related yesterday:

A tech billionaire is quietly buying up land in Hawaii. No one knows why

https://news.ycombinator.com/item?id=39576565
When startups fail, these startups clean up
Why does it matter if other birds can adapt? We got lots of different types of birds. It's awesome. Maybe we'll get new types of birds! Why does "this particular variation is going extinct" matter?
Veteran Apple engineering exec Dan Riccio 'nearing retirement'
I came to the comments to find some insight about the format it stores notes on, so thanks.

That's a big advantage for me as usually the issue I had with other note taking apps in the past is how hard they lock you in, particularly after years of using them.
Addiction? I use it for around 30 minutes a day. And sometimes you need to kick back and passively graze content.

You know - after all that exercise, skill learning and art creating...
If old OS's have been air gapped since they've gone EOL, then shouldn't the last browser version they already had be able to support everything they can access?
I actually have the opposite experience, at least with the books I read. Nonfiction is typically highly repetitive and redundant so I find it suits audiobooks far better. Meanwhile fiction has a lot of subtle nuance and rewards carefully reading each sentence.

Of course this depends on what books you read in each category, if it’s a physics textbook vs Colleen Hoover then it’s the opposite.
Yeah I do think lambda-style coding where you move away from the idea of processes toward functions and data are another possibly superior way.

The problem is that right now this gets you lock-in to a proprietary cloud. There are some loose standards but the devil's in the details and once you are deployed somewhere it's damn hard to impossible to move without serious downtime and fixing.
It widowed my sister.

Grow up.
k8s is really about you and if it makes sense for your use case. It’s not universally bad or universally good, and I don’t feel that there is a minimum team size required for it to make sense.

Managing k8s, for me at least, is a lot easier than juggling multiple servers with potentially different hardware, software, or whatever else. It’s rare that businesses will have machines that are all identical. Trying to keep adding machines to a pool that you manage manually and keep them running can be very messy and get out of control if you’re not on top of it.

k8s can also get out of control though it’s also easier to reason about and understand in this context. Eg you have eight machines of varying specs but all they really have installed is what’s required to run k8s, so you haven’t got as much divergence there. You can then use k8s to schedule work across them or ask questions about the machines.
I wonder if the open source element of the project keeps them “honest” to some extent?
There has been a steady increase in car accidents as well since 2001 and that is gradually increasing car insurance in many countries. A smaller effect than inflation but still quite an interesting pattern.
Cloud and terraform gives you those.

You’re right that kubernetes is a bit batteries included, and for that its tempting to take it off the shelf because it “does a lot of needed things”, but you don’t need one tool to do all of those things.

It is ok to have domain specific processes or utilities to solve those.
I don't see where those methods are getting called from a Unix signal handler but the code is complex enough that it's easy to miss, especially perusing through github instead of vscode.

AFAICT those methods are called from `guard::current`. In turn, `guard::current` is used to initialize TLS data when a thread is spawned before a signal is generated (& right after the signal handler is installed): https://github.com/rust-lang/rust/blob/26907374b9478d84d766a...

It doesn't look like there's any UB behavior being relied upon but I could very easily be misreading. If I missed it, please give me some more pointers cause this should be a github issue if it's the case - calling non async-safe methods from a signal handler typically can result in a deadlock which is no bueno.
Recently I was chatting with a friend who has a net worth in and around there (made his money in mining/exploration), he was in a kinda bad mood and I asked what was up... he was supposed to be flying to Italy, but his crew where late putting his USA Yacht away and they hadn't arrived in Italy yet to get his Europe Yacht unpacked and ready to go. I hadn't really considered before... he employs 6 people full-time to travel around the world and deal with his boats. Very different problems from my problems anyway, heh. :)
What I never fully understood is there’s a free parameter in the equation (Implied Volatility)- which has no solid definition besides “the number that makes the rest of the equation work”. At that point… how much value are you really getting from the rest of the equation?
I say “I am reading X” when listening to it. I find my brain doesn’t have a huge distinction, I’m often “reading” 10+ books at the same time in a mix of audio and print formats so I don’t even remember which is which.
Separating a particle's mass from its momentum
Distracted driving is rampant.
That's really nice. What tools are you using? How do you manage adding and removing keys? How many people and devices are involved?

> Where does GitHub come into all this?

To maintain verification dynamically for team members. Maintaining lists are otherwise (and in your example, I think) a N^2 maintenance task. Everyone needs to update their pubkey list when a team member adds or removes a device.
Git is a much more subtle abstraction than k8s though. You can be blissfully unaware that a directory is a git repo, and still read/patch files.

You cannot pretend k8s doesn't exist in a k8s system.
I still feel this is nothing. Last year, I got a rejection email with a link to calendly to book an appointment with the recruiter if I care for feedback. This was two weeks after all 7-10 interviews.

Real thing is - just like candidates employers too are taking chances with multiple candidates for a position. I don’t see a scalable way of running this. We shouldn’t be taking rejections personally.
The regression is also due to that a real SRE is expensive. It's cheaper to just get some newly grads to react to alarms following a set runbook of what to do if that alarm triggers.

VERY few companies operate at googles scale. For 99.99% of companies it makes sense to investigate single machine issues.
Managing structures in programming language is easier than dealing with finicky optional serialization format.

I have drastically reduced the amount of errors, mistakes, bugs, plain old wtf-induced hair pulling, by just mandating avoidance of YAML (and Helm) and using Jsonnet. Sure, there was some up-front work to write library code, but afterwards? I had people introduced to JSonnet with example deployment on one day, and shipping production-ready deployment for another app the next day.

Something we couldn't get with yaml.
Getting sh-t done: simple, paper-based time management
That's called docker compose
Agreed. But if you're already on AWS, I'd say the quality floor is already higher than the potential at 95%+ of other companies.

So I say unless you're at a company that pays top salaries for the top 5% of engineering talent, you're probably better off just using the AWS provided service.
Depends on the team, I think. I've had no luck at all with the OS/framework and "core" apps bugs, except getting the report that it has been fixed, and I should install the new version of the OS. Only to find out the bug wasn't solved.

The Logic team, however, has been helpful, and in one or two cases (that were discussed in musician's forums) went out of their way.
Prescriptivism vs descriptivism. Sorry, descriptivism always wins.
We've found kubernetes to be surprisingly fragile, buggy, inflexible, and strictly imperative.

People make big claims but then it's not declarative enough to look up a resource or build a dependency tree and then your context deadline is exceeded.
Email seems like the only option to me: It's a (virtual) paper trail, something that can be referred to later for whatever reason.
> What does preemption change here? Before the stack checker has finished, nothing else should hold a reference to any of the yet-unchecked stack.

If your thread overflows the stack, it could start writing into memory for which it does not hold a reference. If the thread is preempted before the stack checker can run (see below*) and detect the overflow, and another thread runs which accesses the now-corrupted memory, then you're hosed.

> just an "if (stack_curr - stack_end < desired_size) abort();"

That's not how the compiler-emitted stack checking works AFAIK (*I believe it uses canaries on the stack which are checked at certain points in code). But, I could see this solving the problem. Basically, for every instruction that manipulates the stack pointer (function calls, alloca's, and on some arch's interrupts use the current stack), the resulting address would need to be checked. That would be costly and require OS awareness, but I think it would be safe. Is this an option that the compiler provides? It would save me a lot of time debugging.*
This requires the same skill and experience as figuring out if k8s is going to be a good fit.

Arguably if you can’t evaluate the raw cloud offerings and jump on a supposed silver bullet you need to stop immediately.
We use Pulumi for IAC of non-k8s cloud resources too, so it doesn't introduce anything extra. In reality all but the smallest Kubernetes services will want something other than hand-written YAML: Helm-style templating, HCL, etc. TypeScript gives us type safety, and composable type safety. E.g. we have a function that encapsulates our best practices for speccing a deployment, and we get type safety for free across that function call boundary. Can't do that with YAML.
Yes, but today any negativity is portrayed as mental illness. It's all Tinder all the way down.
Storing binary data in playing cards (2014)
> Is it any wonder the birth rate is dropping?

If you’re referring to the USA, and if all these things are as severe and hopeless as you say then how do you explain that the birth rate has been rising slightly for the last few years?
I run all my projects on Dokku. It’s a sweet spot for me between a barebones VPS with Docker Compose and something a lot more complicated like k8s. Dokku comes with a bunch of solid plugins for databases that handle backups and such. Zero downtime deploys, TLS cert management, reverse proxies, all out of the box. It’s simple enough to understand in a weekend and has been quietly maintained for many years. The only downside is it’s meant mostly for single server deployments, but I’ve never needed another server so far.

https://dokku.com/
Aren’t you just describing the basic features of an orchestrator?

Docker Swarm has all those features for example.

(Not that I am recommending Docker Swarm.)
I thought feedback was never really concretely given, for risk or liability if misconstrued or demonstrated implicit bias?
True, but that tends to require a bunch of extra code, and adds complexity since now you have two different paths to test. Which is manageable, but definitely cuts against the goal of keeping the project “light”. (Of course, it depends on the feature and the language/environment you’re using. Sometimes the fallback is trivial, or can be neatly encapsulated in a third-party polyfill you never have to look at.)
Corporate Tax Avoidance in the First Five Years of the Trump Tax Law
I think googles advice is: don't
I don't see the issue in pointing out that research like this gets misrepresented and weaponized.
I can’t speak to the other things but I looked into the “sales slowing” thing and what’s happening is that we still sell more EV every year than the year before, but the rate of growth has slowed. Despite the misleading title, the article you linked supports this too.

So all this means is that the growth is slowing. Meaning, we’re not on a pure exponential curve but we’re on an s-curve. This is absolutely normal and expected of all new technologies.

Did a famously over-optimistic car company use a pure exponential in their predictions and thus fail to meet predictions? Yes. Are manufacturers of overpriced EVs blaming this instead of their own poor choices? Yes. Are the media trying to make everything much more dramatic than it really is? Also yes.

Point is, EVs are following the absolutely normal trajectory of new tech. They are running low on early adopters and must adapt to the desires of the mainstream buyers - or of they don’t, chinese makers will.
Some custom bash/python/ansible monstrosity is only going to be known by few brains in the world.

K8s is remarkably easier to retain institutional knowledge as well as spread it.
“Automatic recovery”

That’s a joke.
I didn’t find any of it boring, I feel it’s actually very well paced and exciting throughout. I really didn’t expect that going in due to the length.
A man walking his dog found a rare intact dinosaur skeleton
previously:

How did REST come to mean the opposite of REST? - https://news.ycombinator.com/item?id=32141027 - July 2022 (383 comments)
yeah that would be annoying

I have a friend that basically throws the high net worth welcoming party that’s missing from people’s lives

identify a friction and cater to it, this is an underserved field because people are not willing to validate wealthy people’s problems, or specifically invalidate them
For me, it's travel that's the big win. There's space at home as well (and moving if applicable) but that's mostly manageable if you prune things now and then. If I didn't travel by air I'd probably care a lot less.
And even though we're well into the future of optical mice, when my Bluetooth mouse disconnects for a few seconds, the habit of thunking it on the desk a couple times persists... (to unstick the ball)
Personally, I don't like Helm. I think for the vast majority of usecases where all you need is some simple templating/substitution, it just introduces way more complexity and abstraction than it is worth.

I've been really happy with just using `envsubst` and environment variables to generate a manifest at deploy time. It's easy with most CI systems to "archive" the manifest, and it can then be easily read by a human or downloaded/applied manually for debugging with. Deploys are also just `cat k8s/${ENV}/deploy.yaml | envsubt > output.yaml && kubectl apply -f output.yaml`

I've also experimented with using terraform. It's actually been a good enough experience that I may go fully with terraform on a new project and see how it goes.
It’s the same here as well. Everything you read about tech is wishful thinking.
If it's any consolation, our company pays for 20,000 GMail licenses and we seem unable to escalate any issue at all to Google, even major issues such as their clearly not working spam filtering, emails being lost, incorrect deduplication of emails, or their random IMAP throttling.
Wait until I tell you about Java Script.
The tool where keys are stored is called "a git repo". If you need to update your local copy of the keyring, you pull it.
Just my opinion as a hiring manager, but there is ZERO chance that these calls have potential to change the outcome.
Yeah, with plain Kubernetes I'd also see the practical limit around ~0.5s. If you are on GKE Autopilot where you also have little control over node startup there is likely also a lot more unpredictability.

Something like Knative can allow for faster startup times if you follow the common best-practices (pre-fetching images, etc.), but I'm not sure if it supports enough of the session-related feature that you were probably looking for to be a stand-in for Plane.
The thing is, "kubernetes" doesn't give you that either. You want a LB? Here's a list of them that you can add to a cluster. But actually pick multiple, because the one you picked in AWS doesn't support bare metal.
Why would systemd unit files matter for FreeBSD?
FreeBSD has its own rc system and its own ports and packages and maintainers. If and when some major software starts lagging behind the upstream because of runtime issues, then it's time to discuss the alternatives. Right now such things do not happen.

FreeBSD had to mock several parts of systemd in order to port newer GNOMEs that are dependent on systemd. rc still runs this software, but unfortunately software depends on systemd sockets which is absurd design choice but here we are. Again mocking the absurd interprocess part is the way to go, as opposed to supporting entire specification and API of systemd.

"Any unix" doesn't cut it, too general, too broad. You did ask in dual sense in your original question but then you specifically stated FreeBSD as an example; so I'm answering for FreeBSD specifically.

The problem that I have with opinion in your post is an implication about groups of people - people with skills that should supposedly write a systemd clone for FreeBSD or other Unices, and people without skills that are supposedly waiting for the first group to do some work so they can enjoy systemd on *BSD or wherever. Let me be blunt here, I can assure you this is not the case. Systemd is not a factor for anyone in BSD world and it's a factor only for people that would like to migrate from Linux and retain their usual workflow and muscle memory.
Yes and no. I would agree that observability is the place to start. But knowing what needs to be optimized doesn't necessarily mean you know how to optimize it.

Also, while premature optimization is obviously a problem, knowing more about how to actually write optimized code can help you make more informed decisions earlier on in the development process.
Zotero for the win then.
Please ignore this fool, they are clearly a dogmatic libertarian type, not someone who thinks in complexity. He even cited Econ 101 as a source lol.

As long as there are financial speculators, price bubbles will happen. A massive recession can clear out speculators and burst price bubbles, whom will have in the meantime, fleeced the public for billions, as will as made many be homeless.

In commodities markets, the CFTC has different rules about what speculators can do vs real market participants (real producers and consumers). There are very few rules/laws that disincentivize real estate speculation and many forces that incentivize it. These algorithms are additional tools that help speculators maximize profit.

Housing has very limited supply and very inelastic demand. Prices will not come down unless there is another 2008 style recession. Speculators will continue to pile in and fleece renters maximally.

You might say well that’s just business, but the algorithmic price collusion is really not my biggest issue. I think there’s a different moral question we should ask. What is the number of single family properties a single company should own in a given market. Should they be allowed to own 100%? My silly libertarian friend would say why not? The market will correct. A stronger thinker would probably see that a legal limit probably makes sense.
I have 15 years of experience and nobody wants to hire me. This is also your most likely future in tech.

It was a scam.
For a long time Joplin's support on Android was buggy and late on releases, it's why I switched away. Is it better now?