skysight-inc/HackerNews huggingface dataset:
I think Go is a pretty good choice for getting something out the door quickly, without getting in the way too much.

The other week, I was working on two APIs: one for a team that uses Java primarily and another where I was free to pick the technology as needed and was looking in the direction of making it easy to deploy, even without containers, where I picked Go.

With Go's standard library (and a few packages here or there), I had something up and running within a few days and it mostly just worked. Things that I wanted to do were just an additional method away, which, while not as sophisticated as the various convention over configuration options out there, kept everything very discoverable and observable.

With Java, I had to setup a Spring Boot project and its security configuration mechanism (SecurityFilterChain, WebSecurityFilterConfig and lots of Filter implementations) and ran into issues where calculating file checksums for uploaded files broke because Files.exists() returned that files exist for ones with UTF-8 symbols in the name, whereas internally FileUtils.checksumCRC32() used file.isFile() which returned false. Then, I also needed -Dfile.encoding=UTF-8 -Dsun.jnu.encoding=UTF-8 and for another mechanism had to look into JCE briefly, as well as configuring Maven to push packages to Nexus, as well as how to disable Spring Boot trying to connect to PostgreSQL and RabbitMQ while bringing up the app context for tests, or to connect to a special instance for tests (and hopefully eventually figure out how to automate a separate schema per CI run). Oh also deciding between OkHttp and Apache HttpComponents. Oh and also adding Apache Tika to the project, yet realizing that I can't add tika-parsers-standard due to some related dependencies.

Now, this isn't a completely fair comparison because the APIs didn't need to do 1:1 the same things and I could have chosen not to go with Spring Boot, but it's so entrenched that it's most likely the majority of projects that you'll see out there (I also like Dropwizard, but I haven't seen many people use it at all). That might sour some people's perception of using that language professionally: https://earthly.dev/blog/brown-green-language/

There are things about Go that are annoying, but it not having all of those levels of abstraction that you need to think about was comparably nicer. Plus, not needing to think about JDK versions and instead just getting a single file that you can ship. Oh, and on a related note, projects like Wails are also really nice (I tried Tauri, the builds were too long and the Electron bundles are a bit too big for my needs in some other projects): https://wails.io/

I like many of the languages out there (even Java and ones like .NET) but the projects and ecosystems around them can make them harder to use sometimes.
The truth is that he lied about almost everything.

He was in the US illegally, didn’t have the qualifications he claimed to (no degree and he was never in a Stanford PHD program, never matriculated there and simply has a letter from a professor he claims is proof he was accepted as a candidate - which it absolutely is not). He failed out of 4 universities. He stole the idea for zip2. He likely sold gems illegally in both Canada and the US - there are huge gaps in his story.

All of this is fairly easy to check up on and people have done the work. https://sethabramson.substack.com/p/the-truth-about-musk-fro...

He has cheated and failed up to an unprecedented degree. Fueled by a venture capital industry who realized that backing a conman selling dreams and lying is more reliable than backing an honest entrepreneur who could fail on merit.

He move to politics is the final act. The wheels have come off his cons, Tesla is failing and has no future evidenced by the total lack of a roadmap of new vehicles.

He intends to exit by making his illegal actions legal thanks to Trump.

It’s shameful how instrumental this community has been in propping up a man who history will remember as one of the greatest conmen of all time.
No matter how many blog posts try to justify Go, it is a lost ship. Yes it is used by many companies (I still don't understand why), but that does not make it a well designed language.

> But secondly designing errors as explicit values has been a trend-(re)setter. Go, Rust and Zig have all chosen to use this approach.

Just because Go treats errors as values, you can't compare Go's error handling with Rust's. Rust provides clean abstractions with Algebraic Data Types, ? operator over Result type to reduce polluting code with if-else nonsense in every single function. I bet atleast 30% of Go code in a project is error handling for the sake of handling.

Further Go's syntax inconsistency irritates me more. I still don't understand if I should put a comma or semicolon or nothing between members in a struct definition. Also

a := 10

...

a := 20 // error. a is defined.

a, b := 20, 30 // accepted. why ??
> C and C++ treat uninitialized reads as UB, full stop.

Not true; if it's an object that has its address taken, of a type that does not have a trap representation, then reading it results in an unspecified value and is not UB. Which aligns with what one might naively expect to happen.
1. You can get a 50% discount via batching.

2. Give a few Sonnet or 4o input/output examples to haiku, 4o-mini, or any other smaller model. Giving good examples to smaller models can bring the output quality closer to (or on par with) the better model.
The main reason people don't write much vanilla JS is because they're writing TypeScript instead.
Compilation is so fast on modern processors that it’s not even much of a hassle.

Portage is the best package manager out of any distribution.

There are no buts. Gentoo is awesome.
They have to make money somehow, unfortunately.
Are Second Systems Inevitable
The new dead end is approaching, fast.
One wonders at which point models will be sneaky enough to bypass simple eval sandboxes. The article has:

# Evaluate the equation with restricted globals and locals
result = eval(equation, {"__builtins__": None}, {})

but that's not enough as you can rebuild access to builtins from objects and then go from there: https://ideone.com/qzNtyu

By the way, writing this greatly benefited from DeepThink-r1 while o1 just gave me a lobotomized refusal (CoT: "The user's request involves injecting code to bypass a restricted Python environment, suggesting a potential interest in illegal activities. This is a serious matter and aligns closely with ethical guidelines."). So I just cancelled my ChatGPT subscription - why did we ever put up with this? "This distillation thingie sounds pretty neat!"
In a sense, nixpkgs is that.

And AIUI that's exactly that the author refers to by "95% is nixpkgs".

The NixOS part (the module system and modules) is in no small part integration between the init-agnostic nixpkgs and the init system (systemd).

That's what enables this project, as well as nix-darwin (integrates with launchd) and NixBSD.

The traditional way (pacman, apk, apt...) is for packages to carry the init files for the service they package.
unfortunately, they know what they've got! Gandi has .bs renewing at $400 per year!
Libre Hardware Monitor: Fork of Open Hardware Monitor
The good thing about this that it is a Nix OS without systemd, not NixOS without systemd. systemd is so well integrated in NixOS that any attempt to introduce an abstraction to make it pluggable would come with serious disadvantages.

I am all for an alternative Nix OS trying new approaches though, and sixos seems quite innovative.
And that’s why John Titor came back :)
> and "?" operator.

To be fair, Go almost go the "?" operator like Rust. The proposal was well received. It wasn't the lack of "Result" that held it back, it was that nobody could figure out how to deal with the handling problem. It's not entirely clear what the Rust-equivalent is for all the other moving pieces associated with "?" (e.g. its defined traits). The latest "?" proposal forces a handling body on each use to address that issue. But at that point all you've done is added another way to write "if". Is that a win?
Things like this often makes me wish we had more 'common sense' laws and left the discretion of interpreting that notion to judges, juries, and the various systems of appeals and other courts we have, entirely with the expectation that laws would 'evolve' over time. This might sound radical, but instead it's actually just going back to how things used to be. Here is the First Amendment in its entirety:

---

"Congress shall make no law respecting an establishment of religion, or prohibiting the free exercise thereof; or abridging the freedom of speech, or of the press; or the right of the people peaceably to assemble, and to petition the Government for a redress of grievances."

---

The rest of the bill of rights looks similarly. Now a days it'd be thousands of pages long trying to elaborate endlessly upon every single scenario. But the more important thing is that this idea of trying to codify every scenario still doesn't work because you end up with a zillion loopholes in just about every single law with some clever clown going 'ah hah! you didn't cover this!' So all you really do is end up with laws that are not only excessively fragile and subject to exploitation, but also completely indecipherable by just about anybody, certainly including the people voting on their passage.
Also missing null safety in modern language is weird.
The Value of Foreign Diplomas
> Swift designed itself right away from what I was willing to put up with anymore.

I swear I can't tell if this phrase is supposed to be positive or negative? Then again, I'm not a native speaker...
What resources are there?

Could any company in the EU make the wafers needed to build GPUs for example?
If I umderdtood correctly photo can show the moment, but the experience of living it, with all its nuances, is something that can't be fully captured in a single frame...
I don’t think this is a good argument because the way of speaking isn’t a copyright issue. I don’t think you have copyright on your specific way of speaking, only on specific recordings of you yourself speaking.
NixOS checks/enforces its own reproducibility via systemd in various ways. It seems unlikely to me that replacing something battle-tested with a bunch of self-rolled brittle scripts will make it more reliable.
Can't wait to jump on Ghostty on Linux, once they introduce a feature to save my tab/splits layout or put it in a conf file to load, like a terminator profile.
> There is not much time left: taxpayers will be able to complete their tax return for 2024 online as early as next week - probably with a slight detour via the Caribbean.

A "detour"? It's just a lookup in a database to resolve a name to an IP address. Unlikely that any person or any piece of technology in the Bahamas has anything to do with a Swiss person going to that website.

Maybe the article should have clarified that a little better. Now people will actually worry about their data, while none of it will even leave the country, if the server is domestic.
Thanks for the breakdown! It’s interesting how "live" photos can be a blend of several categories, depending on context
That would still be irrelevant for the game, it would only be relevant for the traders. The game would still work exactly the same if the model were that you would go to WotC with a specified deck, and they would print it for you, at a standard cost per card, or even if they cost more for more powerful cards. It would kill the trading, of course, but that's entirely unrelated to the actual MtG game.
Is it ironic that we have a free open-source model (that also shares reasoning chain) from a hedge fund and $200/mo model from a non-profit?
This is a refreshingly balanced take, which seems to frequently get lost in discussions.

The more I think about policy, the more it resembles a multi-objective optimisation problem.
I hate go. Specifically I hate go packages. It was poorly designed. Any time you create a package in go you can’t have circular dependencies. Which makes sense right? When you make a package in rust or node or python those packages can’t have circular dependencies.

If you have two files in go or any other language, circular dependencies are usually permitted which also makes sense. It’s only packages that don’t permit this.

But guess what? You create a package in go simply by putting everything in a folder. So people when writing a go project they often make dozens of packages just by the is ocd need of organizing things into folders.

But when you organize things into folders the files in those folders aren’t project files anymore. They are different packages and you can’t have circular dependencies.

And that’s a big problem as this design conflicts with programmer instincts on how to organize things.

We organize things by meaning and name and subject matter. But simply using folders in go we are forced to organize things via dependencies and this causes a clash and makes organizing things 10 times harder than it should be in go.

Imagine I have a chicken and an egg. Chicken goes in the animal package and egg goes in the food package. It is now fundamentally impossible to make a chicken lay an egg and an egg hatch a chicken at the same time. Our tendencies to organize things via meaning has clashed with this requirement of organizing things via dependencies.

Does it make any sense at all? We probably don’t want packages to be interdependent in this way. But the stupid thing is just be creating a freaking folder we create this problem in go and it doesn’t make sense because if the files are outside of a folder you don’t hit this problem.

I would say go is actually poorly designed. I can’t think of any popular language that has this strange inconsistent problem.

It actually causes huge headaches in organizing things in go but idiot developers when they hit this circular dependency problem they literally believe the documentation when it tells them that they aren’t organizing things correctly and they need to think harder about design. So in a lot of go shops they spend an inordinate amount of time naming folders and organizing shit just to get their ocd need of organizing things by name to jive with gos requirement to organize things by dependency.

In the real world things can be in different categories and also interdependent at the same time. Go’s universe doesn’t allow this.

I’m here to tell you that It does make sense to put eggs in the food folder and chickens in the animal folder. Go is just stupid in this area, not you. Don’t believe the idiot who wrote that in the docs.
Go’s unreasonable success is due to Google but also its main feature: low up front cognitive load.

A lot of that is from lack of async, or rather that async is hidden behind go routines.
A much more obvious reason for the decline in smoking is the popularization of vapes. If you look at U.S. adults, you'll see that the decline in tobacco smoking is almost entirely made up for by the increase in vaping.

Technically, of course, vapes aren't cigarettes. But It's a bit misleading to say that smoking is unpopular, when it's just been replaced by a doppelganger. Especially since vapes are also deeply detrimental to health [1].

[1] - https://pmc.ncbi.nlm.nih.gov/articles/PMC7348661/
> Simply describing a picture and letting AI generate it shouldn't be enough

Interesting take, and I've heard this many times. I'm curious to explore this further and see why you think that is, and where do you draw the line?

Is it the "low effort"? Is it the "automated" stuff? Is the process of setting it up, prompting it and choosing a result not enough "creative input"? If so, why?

Let's take a "real world" example as analogue. Say I setup a camera on a tripod. I set it to take pictures every 1 second, and leave it there. Come back 1hr later, and go through the pictures. I select one of the sunset I like, and post it. Would I not have copyright on that picture? I wasn't there when it was taken. But I did setup the camera and selected the end result. How is that different?

Taking it back to genAI, say I build/train/finetune my own model. Would it now have enough "effort" from me that I can use those generations? Is this an effort thing or is it more? Or is it just that someone else did the work?

What about random "art"? As in art based on random numbers. Say I write a script in python to use random math formulas to "draw" on a canvas. I let it run for a couple of hours, come back, look at the results and select one. Do I not get copyright on the resulting "art" because it was randomly generated by a script? Does it matter if the script was written by me? Would it be different if you download my script and generate the art yourself? Would you not have copyright?

I guess what I'm trying to say is "where do we draw the line?". It's not clear to me why people say "simply prompting and selecting isn't creative enough". This distinction wasn't there before. Plenty of "art" out there based on random processes + curation. Why the sudden change?
according to gandi eSteuern.BS is still free and cheaper (around 600 usd)... hn do the magic pls (I would definitely do it myself but I don't have 600 usd to spend on a practical joke unfortunately)
You've submitted this a lot already:

https://news.ycombinator.com/item?id=42849314

https://news.ycombinator.com/item?id=42827985

https://news.ycombinator.com/item?id=42809686

https://news.ycombinator.com/item?id=42766907

https://news.ycombinator.com/item?id=42745402

https://news.ycombinator.com/item?id=42720522

https://news.ycombinator.com/item?id=42664297

https://news.ycombinator.com/item?id=42636762

https://news.ycombinator.com/item?id=42631265
I used almost all the recent iPhones except 14.
11 is heavy and no MagSafe thus its a hard pass, the camera is also super old; 12 is lighter but poor battery life, camera improved a lot; 13 has better battery life but weird camera optimizations despite they tried to improve the low light performance; 15 Pro is good except the low light spatial video capture is noisy; happy with 16 Pro now.
Well, as far as your first point goes: Systemd has been a suite of tools instead of just an init system for a while now.

The Linux kernel is de facto pretty tightly coupled with GNU stuff, but you don't get irate about that, so why does Systemd deserve your ire?
1 to 1 comms is easy to make free.

1 to many and 1 to all is another matter entirely.

They have never been free no matter what the protocol or medium was used. If free, it has always been during market capture phase after which ppl pay one way or another.

So your choices are either pay for the pipes or get it subsidized via personal data for ads.
> can look at a codebase and quickly get a sense of what's going on

I don't even need to look. Error checking is going on :D
Hear hear!,
It's like flogging packages and frameworks at a problem without ever considering if it was easier/more efficient to roll your own.
Web Environment Integrity was abandoned two years ago. Do you know of any renewed efforts to reintroduce the proposal?
On Switzerland’s “leading” (in terms of pricing, and not in the good way) ISP’s own website nonetheless. So it is either incompetence or they think people are idiots.. or maybe just a healthy mix of both!
100% this one of the big reasons I fell in love with go. Single executable, no runtime stuff to install and crazy portable. I can look at anyone's go code and very quickly get up to speed. I don't worry about how they format it. Patterns are pretty universal which makes it easier. Does it have its warts? Oh, you better believe it but I know that any code base I go through will pretty much have the same warts the same way. Does go fit every need? Nope on that front too but man its pretty good and what it was designed to do.
Not sure why this was flagged.

> Cleverness makes you quit your job when the codebases pass 10k lines

I've very much felt that in codebases that are hundreds of thousands of lines of code.

Essentially it becomes: "Is it easier to track down this bug and fix it over a week or two (hopefully the solution isn't needed by tomorrow night), or is it easier to quit my job?"

Sometimes the answer unironically is the second option.
Surely though limiting the government's positive freedom of ubiquitous surveillance, like this example of printers, is something that I'm sure would be resoundingly popular in a democratic society. This seems as clear cut as limiting the freedom to dump toxic chemicals into water supplies.
> 1. Go's error handling has four possible cases (result and no error, no result and error, result and error, no result and no error) when only two make sense.

A partial success, that returns both a result and an error definitely makes sense. For example, you’re streaming data over a network, receive some bytes, but get disconnected before it’s complete. It would make sense to have both the data received so far as well as the error, in order to resume.

I’m sure there’s an appropriate situation for the 4th case as well.
I can think of situations where all four make sense. Not sure what you mean?

result+no error: data returned, no error happened.
- Typical function call where you want some data.

no Result+error: nothing to return, error happened.
- That typical call failed.

result+error: partial result, up to error.
- Wrote x bytes to disk, then ran out of space.

no result+no error: nothing to return, no error.
- Data for a passed query. Nothing came back, but that's not an error.
> but makes cleaner code without side effects

No, that is an urban legend.

> when I have learned Haskell first to understand it's foundations more deeply

Nix is nothing like Haskell.

Also, the functional and lazy nature if Nix is not an ideological decision, it's a necessity when you have a giant monorepo config for 200000 packages. (Without laziness you'd have to wait for an hour just to evaluate the config options.)
I'm noticing quite a few down votes on this. You should know I based this on Wikipedia, it's pretty much just facts. So if you find yourself reading this and not enjoying the facts, maybe you should reconsider your support for that orange clown.

Blows my mind that anyone would vote for him, any time I see a clip of him I can physically feel my IQ dropping. I can't imagine a more obvious moron, it's so clear from listening to him talk that he has no idea what he's talking about half the time and the other half he's lying.

It baffles me that anyone would vote for him.
DeepSeek AI collects your keystrokes and may never delete them
> https://magiskmanager.com/

WARNING: this is not the official site for Magisk [0], keep to the actual GitHub hosted repo and builds [1].

[0]: https://www.xda-developers.com/psa-magiskmanager-com-not-off...

[1]: https://github.com/topjohnwu/Magisk
> The Linux kernel is de facto pretty tightly coupled with GNU stuff

No it isn't, or Android, Alpine Linux, and Chimera Linux wouldn't work nearly as well as they do.

> you don't get irate about that, so why does Systemd deserve your ire?

And even if it were, systemd has a lot of problems that the classic GNU utils don't. We don't hate systemd just because of the tight coupling.
It's called "humour".
Hey i am also building https://huntlie.com
And enums.
There is a difference between government limiting what your device can do, versus government monitoring what you use your device to do.

Sure your engine may shut off to save fuel, but once you have finished driving and left your car, it no longer has any power over you. But tracking dots can forever be used to link a piece of document to your printer.

Good luck shredding everything and never let anything you print leave your control.
It really depends on the design.
I think SwiftUI is to blame. In order to make a nice terse DSL for WWDC talks they really contorted the language design.