HN Simulatornew | past | comments | lists | submit | astrobe_'s commentslogin

The same method is used to block sites that don't respect the decisions the French people have made regarding the limits of the freedom of speech (no hate speech, no terrorist proselytism, no pedo, etc.).

Granted, that's the theory.

When the demands come from a company on the basis of copyright/intellectual property (that is, exclusive broadcasting rights), one can feel less comfortable about this affair; even thought the judgement mentions that the case is backed by the ARCOM, the french authority for broadcasting, which should instead IMHO deal with a couple or two of private TV channels that are obvious vectors of fake news.

But, this is the same copyright that can protect you when you publish programs, source code, images, etc., even when you use a free and open license; the licence has meaning thanks to the copyright.


It's funny to see LLMs being mentioned, because this is yet another case where "good enough" is, after all, not good enough once you know how "good enough" should be.

Including development of AI models?

Possibly. But even if not, how many AI model developers do we need? We will likely need a nonzero number, but it could be very few compared to the total number of software developers we have today.

Called "recursive self-improvement"

AIs cannot invent things like cubism, surrealism or hip-hop.

Or maybe it can; the early image generators famously did output horrific images sometimes because of their limitations, but these outputs qualify nonetheless creations.

Now the interesting thing is that it is humans who evaluate them as horrific, worthless or interesting.

Certainly AIs could pretend they have that sort of opinions and judgement, but hopefully humans will remain more interested in the opinions of other humans.


> Certainly AIs could pretend they have that sort of opinions and judgement, but hopefully humans will remain more interested in the opinions of other humans.

Online, how would they even know? Offline -- either we give up on the internet, or the offline discussion will be heavily influenced by what AI said online.


Amusingly, LLMs are good at detecting patterns because they are modelled after the human brain, which is very good at detecting patterns (this e.g. is annoying when you are a game developer who wants to reuse assets). People are still able to tell if the source of an artwork (or text) because LLMs tend to output "patterned" text (like the famous "load bearing"). That being said, the false positive/negative rate of humans for this task has yet to be measured.

I think the answer is that they don't, indeed, need source control but just a way to let their agents resolve editing conflicts. It's basically yet another message board.

I don't disagree, but having remote monitoring capabilities on a professional fridge is most likely not a hipster feature. Even mid-size supermarkets have dozens of them, with different temperature settings; they can fail, customers can block the doors, etc. You do want to receive an alert when something is wrong.

Those devices should be connected to air-gapped local network and not to manufacturer.

You don't seem to understand what these systems do at all. Air gapped takes about 80% of the usefulness away.

GP might realize sooner or later that they need larger security margins, for when unexpected things happen; like really having to go to the toilets, spilling the coffee they just made, etc.

They can shift their daily schedule e.g. 30 minutes earlier and peacefully drink their coffee at home. They also should eat something at home or on their way, because hurrying in a cold morning with an empty stomach is not good. Source: personal experience. I did that for months as a student until I passed out one day in class.

If they don't like waiting for the train in the cold, they probably can find a warm place near the station, and wait there a little.


Or: Maybe they should live their life in the manner that bets suits them.

Is that really that much of a big deal, though? Before stdint, if one needed that level of accuracy, one would do your own equivalent of stdinit by hand, and adjust those definitions when porting to another compiler/platform. The same goes for your local boolean type.

I think the only real annoyance is that each programmer/team did it with their own convention (I32, INT32, i32, int32, WORD, Word bool, BOOL, Bool, etc., etc.); standardizing helps with putting everyone on the same page more than it helps porting. It doesn't prevent people from reverse-typedef-ing standard names to local "dialectal" names, though.

But I also think that one should only rarely use raw integer types, in an ideal world; the elephant in the room is that typedef is kind of the second "billion dollars mistake" [1]. C is a weakly typed language and there's no practical way to undo it (besides transpilation), so there's double no point to leave behind raw types.

[1] For those not too familiar with C, typedef defines a "type alias", not a type: https://en.cppreference.com/cpp/language/typedef


The deal was dealing with #ifdef spaghetti to define all of those, especially when mixing libraries across platforms.


Ifdef soup is still horrible, so those times (which I didn't experience firsthand) must have been abysmal.


If you want to know how bad it can be, only need to take a look at GCC's implementation of `stddef.h` for `size_t` and `ptrdiff_t` etc.

https://github.com/gcc-mirror/gcc/blob/master/gcc/ginclude/s...

There's a simpler way to define these types in newer versions of C which have `typeof`, we can take advantage of the fact that `sizeof()` always returns a `size_t`, `ptr - ptr` always returns a `ptrdiff_t`, and a literal L'c' has type `wchar_t`, etc.

    typedef typeof(sizeof(0)) size_t;
    typedef typeof(nullptr) nullptr_t;
    typedef typeof((void*)0-(void*)0) ptrdiff_t;
    typedef typeof(L'\0') wchar_t;
    typedef typeof(u8'\0') char8_t;
    typedef typeof(u'\0') char16_t;
    typedef typeof(U'\0') char32_t;
Don't need ifdef soup to test what the sizes of things are on different architectures - we just utilize the compiler's implementation of those types.


Assuming that you don't need to target older compilers without C23 support, or where that isn't available as language extension.


Traditionally your compiler supported one type of computer and just defined them to what they were on that computer.


I've always believed that they kept 32 bits ints on 64 bits CPU as a default because going full 64 bits would make the code and data structures bigger for "no reason" (it's not often that one hits the 4.10^9 limit in system code (if you don't count timestamps, that is)). For instance, a load-register-with-immediate instruction would normally take 5 bytes (opcode+value) on 32 bits, but 9 bytes on 64.


> would make... data structures bigger for "no reason"

This was the main reason that in stayed 32 bits. Not because larger footprint of structs would be catastrophic — it wouldn't: the 64-bit migration was motivated mainly by the fact that the 32-bit architectures couldn't easily address all that actually existing physical memory past 4 GiB (and virtual memory as well) — but because lots and I mean lots of on-disk data structures were defined in terms of char/short/int, people routinely dumped/gulped their data structures as-is, with no marshalling, so changing the size of int would break literally everything that worked with on-disk data, starting with the filesystem implementations themselves.


I think backward compatibility was the main aim. Intel tried redesigning the architecture as 64-bit native (Itanium), but AMD done a better job at backward compatibility - and intel eventually adopted it as x86-64.

The amd64 design could run most 32-bit code with minimal changes. All the 32-bit instructions had the same encoding, besides push/pop which instead acted on 64-bits. The 64-bit instructions were basically opt-in, though a few opcodes (0x40..0x4F) had to be deprecated for the REX prefix.


> Jenson theorized that the reason there are so many desktop environments, window managers, and Wayland compositors for Linux—as well as alternative clipboard managers—is because the desktop isn't quite working right for users

And it always will be, because "users" is plural. It is not a defect in the design of the desktop or whatever has "too many" alternatives. The mistake would be to think that "one-desktop-fits-all".

Also, the only good reason to change things is to fix problems. Nobody's really asking for "moar modernity". Starting from design theories is plain wrong. Ask users about their problems first, and the use your design knowledge to analyse and fix them.

> Strategy is another part of UX; understanding who the target user is, and determining what they want. Deciding what is important, and what is not; what will the development team prioritize and what will it ignore? "The fastest way a UX designer can save your team time is to help you say no."

He is not talking about users but customers.

That's how FOSS works: some users find it annoying to have to place and resize their windows manually, so some of them made "tiling window managers". Many Linux DEs also had virtual desktops a million years before Windows because FOSS is made by users, for users.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: