Yes, when I implemented ImportC (a C compiler built in to the D compiler), I had to spend a lot of time finding ways to work with all the nutburger nonsense in the various .h files.
One of my pet-peeves with C projects is that it's so often more or less "works on my machine" when written by Linux users (as a Windows and FreeBSD user it often hits you on both those platforms).
The article highlights a typical piece:
#if !(defined __GNUC__ || defined __clang__ || defined __TINYC__)
# define __attribute__(xyz) /* Ignore */
#endif
There is no reason that !defined check to not include a check for __attribute__ already being defined (a custom compiler author could then force an define for __attribute__ that translates to an internal __mycompiler__attribute__ replacement by default).
But outside of that, just trying to compile on FreeBSD you often run into systemd dependencies or other non-posix behaviors (Not to mention on Windows but I'm not here to bring on flamewars so I'll leave that part).
matheusmoreira 24 hours ago [-]
> One of my pet-peeves with C projects is that it's so often more or less "works on my machine" when written by Linux users (as a Windows and FreeBSD user it often hits you on both those platforms).
Windows users singling out Linux users for not catering to their platform. How the times change...
> you often run into systemd dependencies or other non-posix behaviors
Not a problem. POSIX is irrelevant, systemd is great and we should all be using Linux to its fullest extent. Linux has great features and there is absolutely no reason not to use them all. Nobody complains about the fact BSDs have cool things like kqueue and unveil.
whizzter 8 hours ago [-]
> Windows users singling out Linux users for not catering to their platform. How the times change...
This goes back to the days I was browsing freshmeat and saw some interesting command line tool or otherwise non-UI tool from some hopeful developer for something useful. Node had significant traction but didn't really blow up until it became really cross-platform.
And perhaps is less of an issue these days since so many people use Mac's as their primary, so less Linux-isms survive once in context with osX.
> Not a problem. POSIX is irrelevant, systemd is great and we should all be using Linux to its fullest extent. Linux has great features and there is absolutely no reason not to use them all. Nobody complains about the fact BSDs have cool things like kqueue and unveil.
From following it over the year it was not entirely welcomed even in the linux community (and some of the security issues made one shudder). Mostly it's the monolithic nature that's makes it a questionable, is it Gnu/Linux these days or Systemd/Linux ?
kqueue is just an api, just like epoll, io_uring or even iocp on windows. And yes, it's a special case for high-perf servers where posix becomes less relevant (and while I can appreciate some lower-perf fallback to be able to develop/port to another platform like a console I do see that some programs are inherently platform bound).
I think one thing lost in my original comment was that I was often encountering things like this with "simple" CLI tools or lower level format libraries, and honestly projects like that also had a tendency to break over time without updates as they often relied on specific versions of libraries the maintainers had installed via Linux package managers, in the same fashion as npm has caused churn in the JS community. (npm at least has version pinning so old cli tools can often be run as long as node hasn't deprecated api's).
matheusmoreira 4 hours ago [-]
> And perhaps is less of an issue these days since so many people use Mac's as their primary, so less Linux-isms survive once in context with osX.
Yeah, and then we get "osX-isms" instead. Before node, there was rubygems which contained lots of macOS specific software.
Nothing particularly wrong with that. People should use their preferred platforms to the fullest. Why make it a point to single us out for "linux-isms" though? Makes absolutely no sense. BSD-isms, Win32-isms, macOS-isms are just as abundant.
> From following it over the year it was not entirely welcomed even in the linux community (and some of the security issues made one shudder).
It's definitely welcomed now. There's plenty of legitimate criticism against systemd but lack of standards compliance, incompatibility with other platforms or lack of devotion to some nebulous "unix way" religion aren't among them. The whole point of systemd is to use Linux kernel features like cgroups to the fullest extent, and it does so to great effect.
> Mostly it's the monolithic nature that's makes it a questionable, is it Gnu/Linux these days or Systemd/Linux ?
It's just "Linux".
GNU is not in any way special either. GNU, systemd, they're all just random user space stuff you can put on top of Linux. You can boot Linux directly into your software if you'd like.
It's strictly less monolithic than BSDs which ship a kernel and a whole bunch of system components and user space libraries you can never ever bypass because they explicitly don't guarantee ABI stability like Linux does. To say nothing of macOS which becomes more of a walled garden every day that passes.
neonz80 20 hours ago [-]
> Windows users singling out Linux users for not catering to their platform. How the times change...
In my experience this was a problem over 25 years ago when I developed for Solaris and other non-Linux operating systems.
benj111 6 hours ago [-]
I think I may(?) have got into Linux 20+ years ago when I was trying to learn c and even the basic Hello World wouldn't work for me.
So I suppose it does have a marketing benefit in that I now use Linux.
rwmj 1 days ago [-]
MSVC support for C is fairly terrible. For the projects we write that are portable to Windows we insist you use GCC or Clang on Windows. No one has time to deal with the lack of even standard C1x/C2x features (never mind useful extensions like attribute cleanup).
Surprised about FreeBSD. My experience is that porting Linux software is usually pretty easy as long as it's not using some Linux-only feature (io_uring for instance).
bigbadfeline 21 hours ago [-]
> Surprised about FreeBSD. My experience is that porting Linux software is usually pretty easy as long as it's not using some Linux-only feature (io_uring for instance).
I'm not sure why you're surprised, the parent of you comment clearly stated
"on FreeBSD you often run into systemd dependencies or other non-posix behaviors"
which means, software written for Linux often uses "Linux-only features" such as systemd and other non-posix dependencies that are foreign to the BSDs and traditional UNIX. Thus, it shouldn't be surprising that Linux software is hard to port to the BSDs.
Linux used to be a pretty good UNIX, I'm not sure what it is now.
matheusmoreira 3 hours ago [-]
Linux is just Linux. There is no need for it to be part of some larger category of operating systems.
And BSDs are just as happy to accumulate nifty features like kqueue, unveil and whatever else it is that they have. These features are all just as foreign to Linux as io_uring is to them, and just as non-POSIX compliant.
Yet somehow I just don't see people complaining about them endlessly the way people complain about "linux-isms". When I see such features I am very impressed because I think they're amazing innovations, and my only reaction is to wonder when Linux will gain the same features so it can be just as great as they are.
lmz 10 hours ago [-]
How is that Linux only features line different from OpenSSH (OpenBSD specific) vs Portable OpenSSH? If it bothered people that much they can also band together and make a Portable $whatever.
kjs3 17 hours ago [-]
Linux used to be a pretty good UNIX, I'm not sure what it is now.
Linux has become Linux, it's own thing that as often as not says "yeah, that old Unix stuff is fine for you boomers and other fossils...we're going to be over here doing our own thing". Which is probably fine, I guess, because all the old Unix versions did the same thing to some extent and the computing world had changed over a dozen times since Unix showed up. Unless you were on one of the minimally massaged System V reference ports, going from one vendor to another was anything between "lots of annoying differences that make life less fun than it could be" to "WTF said this was Unix and why did you make me touch it?". Ultrix, SCO and UTek (among many others) weren't awful. Solaris and HP/UX had some vendor-only things that were hard to replicate. AIX made you question your life choices, especially if you wandered off into one of the mainframe versions; you had clearly angered the gods.
There used to be Windows, Unix, and everything else. Now there's Windows, Linux, and everything else, with Unix (BSD mostly) being part of everything else. Times change, shit happens, and there's only so much that impotently shaking your fist at the unjust universe will fix.
pif 6 hours ago [-]
Also, people confuse "good" with "ought to live forever". It's time to leave BSD and LISP in the history books.
kjs3 4 hours ago [-]
How dare anyone spend time on things you don't approve of. /s
pif 4 hours ago [-]
Spending time on your hobby is wondwerful. Expecting the world to consider your hobby important is arrogant.
kjs3 6 minutes ago [-]
Much like saying It's time to leave (your hobby) in the history books. But it's obvious that the distinction and thus the irony is completely lost here.
bitwize 7 hours ago [-]
Generally speaking, if someone is not actively using/hacking software on a particular platform, support for that platform can fall in a hole. It's often not hard to add, however, if the code base is well written and keeps portability in mind. I fixed an issue with NetBSD support in GrafX2 (pixel art editor) some years back in like fifteen minutes.
jstimpfle 22 hours ago [-]
What do you even miss, honestly works fine for me? In terms of platform APIs, I prefer the Windows ones on Windows anyway
drwu 22 hours ago [-]
Complex numbers, for example.
Also, C preprocessor expands macros differently on MSVC.
david2ndaccount 12 hours ago [-]
Use the new standards-conformant preprocessor with `/Zc:preprocessor`
Wasn't aware of preprocessor conformity issues, good to know!
BadBadJellyBean 1 days ago [-]
If it is an open source project then that is quite alright with me. An open source author doesn't need to support all platforms. Only those they care about. If someone else wants support for another platform they have the source.
whizzter 8 hours ago [-]
Yeah, I think I did miss mentioning that my comment was more weighted on simpler cli tools or library projects (file format readers,etc).
I don't expect anyone writing GUI tools or more high-perf servers to spend their time porting to other platforms (trying to compile GTK on Windows wasn't for the faint of heart).
dgrunwald 8 hours ago [-]
In our compiler (in a code analysis tool), we have
#pragma immutable_macro __attribute__
After this pragma, any attempt to #define/#undef the macro "__attribute__" will be silently ignored. This lets us (or our customers) bypass such stupidity in library headers. It's also often useful to replace broken macros with working versions.
kps 1 days ago [-]
>One of my pet-peeves with C projects is that it's so often more or less "works on my machine"
For a bunch of software categories there isn't really much point to support Windows at all these days. We've had "developed for unix, ported to Windows" software for a long time and it often doesn't work that well, because the agreement even for fairly basic stuff is not that large between the two.
whizzter 1 days ago [-]
1: My point isn't "developer on unix, ported to Windows", it's "developed on linux, maybe works elsewhere".
2: You could easily compile Samba yourself for FreeBSD in the past, last time I tried a new version it broke in what I remember being due to linux-isms (yes there is ports, but being reliant on older versions if ports maintainers can't keep up isn't a good thing).
3: The only "fairly basic" stuff that's hugely different is mostly the absence/reliance on shell-scripts (when building), but that has little to do with the actual code function (Personally I often used Node scripts in those scenarios, Python scripts would probably be an improvement since there's no reason it couldn't be everywhere).
I used to use Tremor to decode Ogg audio (no UI needs, just binary data in, arrays of primitive values in audio buffers out), early versions were easy to compile under Windows but building later versions were buried in shell scripts generating headers,etc for no real good reason (maybe to help port when working on a Linux workstation to other embedded devices but made the code less easily compilable by default), the core functionality only really needed a C compiler as early versions showed.
I can agree that something with advanced UI's like Blender (that relies on GL/3d rendering for UI) might not be easily portable, but when algortihm libraries often requires heavy reworking it's not a good thing (Here I think Github has helped since people has had an easier time to contribute, it's a sad thing that people are moving away due to the AI-crap).
In the end, it's not about _actual_ differences but more of a superiority complex of Linux users that is the main roadblock.
matheusmoreira 23 hours ago [-]
Superiority complex?
How many times have we been told that we're entitled freeloaders for expecting Linux compatibility work from others? Insulted by people who use dominant platforms that get all the commercial support while we get literally nothing? Reduced to reverse engineering stuff with no documentation and zero help?
Pretty wild to watch this unfold. Now that Linux is finally coming out ahead, as it should, because people are finally writing software for it... Suddenly we're the bullies.
whizzter 8 hours ago [-]
This isn't a new thing, like I mentioned in another comment it goes back to freshmeat.net days ("oh, cool a tool to manipulate fileformat-x", "oh ok too full of gcc-isms, linux-only headers to run on either windows or even bsd").
I worked in gamedev, consoles, etc. Linux support was often discussed but the whole mess of different libraries on various distros vs static library linkage legality, evolving audio api's,etc was real blockers (Valve just defaulting on Wine and Win32 binaries for steamdecks could be discussed at length).
Honestly, could even be posited that the rise of the Web as a delivery platform, Java and Node,etc is in large part DUE to the fragmented story of much of C/C++ code platform-tiedness, Linux just happened to move ahead due to it's momentum as the "free" option (quotation marks due to Android).
matheusmoreira 4 hours ago [-]
> oh ok too full of gcc-isms, linux-only headers to run on either windows or even bsd
You have the source code and it's literally free software. What else do you need?
It's honestly pretty incredible to hear complaints like "it didn't compile on my preferred platform unchanged".
> the whole mess of different libraries on various distros
All the various Berkeley Software Distributions out there don't have different systems and libraries of their own?
This is a user space problem anyway. Linux kernel is actually better here. Linux actually lets you bypass system libraries and talk to the kernel directly. You can write Linux applications in freestanding C and they will work. BSDs will eventually break ABI and your program if you do that.
> static library linkage legality
Nothing illegal about it. Just gotta follow the terms of the GPL. Whether you're willing to do it is a completely separate matter.
> Valve just defaulting on Wine and Win32 binaries for steamdecks could be discussed at length
Don't think there's any discussion to be had here. It's just the pragmatic choice that buys us access to vast amounts of existing software that will never be ported. Linux kernel is even gaining NT functionality now just to support this. Nothing wrong with it.
You can totally get Linux versions of games in the Steam Deck, it's just that they're often second class ports, outdated and generally forgotten by all including the developers. There is no reason whatsoever to sit around waiting for things that will never come.
justin66 23 hours ago [-]
> Now that Linux is finally coming out ahead
Where have you been for the last quarter century?
matheusmoreira 23 hours ago [-]
I was using Linux on my machines despite all the difficulties involved.
avadodin 10 hours ago [-]
The decent cross-compatibility in the early 00s was a result of the multipolarity of the era.
In the late 90s-early 00s we had SystemV, Linux, BSD, macOS and the market begged for standards like POSIX and to an extent CDE and many other proposed ones. As the largest player, Linux always had an attitude.
Now, after winning the Server, embracing, extending and extinguishing the Workstation/Desktop(WSL, Valve), and with a foothold in mobile(Android) Linux is the de-facto standard.
The BSDs have declared POSIX dead and gone their own way while supporting Linux(SystemD, Wayland) APIs even if they are more half-baked than POSIX in order to benefit from what is now virtually a Linux ecosystem.
I don't like this any more than you but it is what it is.
rootnod3 1 days ago [-]
Exactly, the amount of patches needed in many FreeBSD or other BSD ports just to appease the Linux-centricity is bonkers. And many times the changes aren't even that grave.
jdw64 1 days ago [-]
in Asia, and over here, Windows is the de facto standard while Linux is actually a poor option. Almost all of the infrastructure is written for Windows, so the second you switch to Linux, you're fighting an uphill battle just to do basic tasks. Seeing this makes you realize that our worldview is entirely shaped by the ecosystem we live in
zephen 1 days ago [-]
There's portability between systems, which as you note, has ever-diminishing returns.
Then there's portability between compilers, which, as the article notes, glibc is also completely hostile to (except for anointed compilers) for no good reason whatsoever.
account42 8 hours ago [-]
> which, as the article notes, glibc is also completely hostile to
This is neither true nor claimed by the article.
zephen 7 hours ago [-]
The article specifically states "If you aren't gcc, clang, or tcc, tough luck."
It doesn't work. For no good reason. Because there are a few anointed compilers.
That it wasn't on purpose doesn't make it not hostile.
1 days ago [-]
dooglius 1 days ago [-]
The preceding comment indicates that the intent is to support other compilers. I think a better approach is to define __glibc_attribute__ based on compiler support and to stick to that within glibc since there's no reason to think that another compiler's attributes have the same semantics as GNU C's.
rurban 22 hours ago [-]
That ship sailed already. You simply have to mimic gcc.
Which is at least better than with MSVC, where they did everything differently, and only half of it.
account42 8 hours ago [-]
Well in practice you have to mimic GCC except for Windows where you have to mimic MSVC.
rurban 6 hours ago [-]
Not really. MSVC is too broken. I just mimic x86_64-w64-mingw32-gcc, which exists everywhere.
einpoklum 1 days ago [-]
systemd is indeed the bane of Linux, and a pain in the ass for a lot of FOSS. Once the main distributions made it mandatory to install (not just the default, but mandatory) - we've started to see this sort of bifrucation of a lot more FOSS away from being standard-based and multi-platform to being Linux-specific.
That said - I think a rule-of-thumb one can follow is that any inclusion of a file with a directory prefix, especially `<sys/whatever>`, needs a guarantee-of-availability in your build configuration phase, e.g. CMake `find_package()`, or or at least `check_include_file()` and such. That way, you might be more likely to fail to build, but at least you'll be telling the user "I expect these things to be present".
jeltz 21 hours ago [-]
No, systemd is not the bane of Linux. What existed before it was much worse. Upstart was a totally broken mess and almost all sysv init scripts contained several bugs.
I don't like systemd but it is a lesser evil.
anthk 9 hours ago [-]
Upstart? These Ubuntu-centric kids will never learn. OpenRC works fine there.
Meanwhile people still have issues on turning off their machines.
einpoklum 20 hours ago [-]
systemd is not an init system; it _contains_ an init system. It is a huge swatch of the whole userspace of a Linux system up to shell or GUI sessions - and having an init system was just an excuse; and in fact, the systemd point brought up in the linked article is unrelated to init systems.
There are quite a few init systems: The venerable sysvinit, runit, s6, openrc and others. You don't like upstart? Ok, choose another one, there are many. Here is a comparison table by the Gentoo folks:
As for the claim of "almost all sysvinit scripts contained several bugs" - that's both hyperbole and false. Plus, you seem to be implying that systemd has not been troubled by bugs, which of course it has (and that does not disqualify it; the fundamental design and organizational nature as a project are the disqualifiers).
cestith 4 hours ago [-]
The systemd init system is quite the Trojan horse, though. I prefer it greatly to SystemV init. Most of the rest of systemd varies from unremarkable to problematic in my opinion.
One bright spot is systemd-networkd allows one to change quite a few things about interfaces in the way server automation platforms expect to work without doing a network restart. The workaround otherwise on, say, CentOS was always to write the new config file used by future restarts, also run CLI commands to update things in memory, and be sure to tell the service not to trigger a restart on the config file(s) changing. Otherwise if you’re doing something like streaming UDP video your own automation can become a reliability issue.
matheusmoreira 15 hours ago [-]
Nope. Systemd is pretty great. It's pretty well designed, fully featured, very easy to use and quite nice program against. And it's GPL licensed free software.
Systemd bothers people because it's not "the Unix way". In other words, it's not some painful lowest common denominator POSIX nonsense. That's a feature, not a bug. POSIX is garbage and restricting oneself to it is pure masochism.
Every unixlike deviates from POSIX and for good reason. That includes the BSDs, but somehow I don't see people complaining endlessly about all the nifty exclusive features they keep accumulating for themselves. Why is it that only Linux gets singled out?
avadodin 9 hours ago [-]
Your binary spaghetti monstrosity, our carefully designed literate API.
Wait.
matheusmoreira 5 hours ago [-]
Systemd is farther into the "carefully designed" territory than POSIX will ever be. Never forget who gave us signals and locales.
account42 8 hours ago [-]
The definition of a strawman.
defrost 8 hours ago [-]
It's like flogging a straw herring in the foot.
matheusmoreira 5 hours ago [-]
Not at all.
The point was that using systemd is somehow "mandated". It's not, people chose systemd because it's actually better and made life easier compared to some POSIX nonsense.
The point was that this non-existent "mandate" caused a "bifurcation" from "standards-based" software to Linux-specific. If anything is being "mandated" here, it's the POSIX compliance. Nobody is obligated to follow this like it's some sort of religion. The standard is garbage and should be forgotten.
The point was that systemd was "the bane" of FLOSS. Systemd is itself FLOSS, it's literally GPL'd. And pretty good FLOSS at that. It's just not "standards compliant" which makes it heretical or something. Total nonsense.
There are no "strawmen" here. Just downvote silently if you disagree and don't want to argue.
kscarlet 20 hours ago [-]
I think the Common Lisp ecosystem sets a good example of how a dozen of implementations move ahead together. Implementations experiment with extensions, the really useful ones get implemented multiple times, and some portability library emerges as de-facto standard if it's good enough. You can watch the result in https://portability.cl/, the language is evolving like never before even if the standard committee has dissolved nearly 40 years ago!
eska 11 hours ago [-]
Isn’t this only possible in lisp due to the strong foundations of meta programming allowing the implementation of language features as user libraries?
kscarlet 23 seconds ago [-]
Not directly. Every "extensions" listed above cannot be implemented as user libraries, that's why these back and forth process between implementation extensions and portability user libraries need to happen to reach a de-facto standard. Otherwise the user libraries become de-facto standard themselves, like ASDF the build system, Trivia the pattern matcher...
But I think the power dynamics is crucial. In the Lisp ecosystem the users have great power, (and there are dozens of implementations,) so it's not like one or two implementation decides what everyone is gonna use and everyone just lives with it.
cestith 4 hours ago [-]
I don’t know that it’s impossible without that. It’s certainly easier with it.
fuhsnn 1 days ago [-]
For those who are making indie C compilers that don't pretend to be __GNUC__ but want to compile real world projects, slimcc's test script[1] and platform header hacks[2] might save you some time.
[1] https://github.com/fuhsnn/slimcc/blob/main/scripts/linux_thi...
- Game projects default to using SIMD so for example SDL and STB you always need to pass -DSDL_DISABLE_IMMINTRIN_H and -DSTB_NO_SIMD
- math.h's NAN usually fall back to (0.0f / 0.0f), which will print "-nan" with printf, some projects test suite fail because of it (they expected "nan").
- NetBSD's sys/cdefs.h straight up #error's if you don't pretend to be GCC or PCC.
- Some projects can't compile without __attribute__((always_inline)) because they use it on non-static functions.
- Many projects probe -fvisibility in the build system and pass -fvisibility=hidden to compile, but in the headers they gate __attribute__((visibility(default))) behind __GNUC__ checks, so you'll get missing symbols.
- Some projects use if(0) { undefined_function() } to fake static_assert(), there is even a bug report from QEMU to Clang because it failed to optimize in -O0 a certain `if` written this way.
- Even if you define __STDC_NO_VLA__, projects might fall back to alloca() code path that's untested and broken (python and jemalloc both had this problem, already reported)
- Valkey has broken __builtin_ctzll fallback nobody noticed (reported).
- Zig's C bootstrap path expects the compiler to have GCC/Clang-tier optimization and stack overflows if you don't (reported).
- I contributed stdatomic.h code path for Ruby just to compile it with slimcc, pretty sure it's still the only user of the code path.
- I implemented __has_extension in the hope that projects can use it to query gnu_asm; but SQLite broke because they use __has_extension(c_atomic) to query GNU atomics builtin, but c_atomic actually is meant for C11 _Atomic (IMO they should use __has_builtin)
upvotrsuper 20 hours ago [-]
Although I don't use slimcc, I follow its development because I learn so much about C - even though I've been using C and C++ for over 30 years. https://github.com/fuhsnn/slimcc/blob/main/scripts/linux_thi... is an incredible piece of work. I can't imagine how many hours it took to assemble this collection. If slimcc can pass that project list torture test, then surely it's bulletproof.
fuhsnn 3 hours ago [-]
It did take many hours, but I learnt a lot in the process, found some bugs to report, and watched plenty of series concurrently. Overall it's a nice and worthwhile hobby!
I have no knowledge of this specific "why", but my general experience shows that feature flags, while almost universally better than checks for the specific software version in hope that it has proper support for a feature, appear only as a replacement to platform / software detection, after a few years of struggle.
It's probably just natural for software developers (myself included), whenever only FooZoid v5 supports frobnicate(), say "#ifdef FOOZOID_V5" and go back to your business, rather than introducing "FROBNICATE_SUPPORTED".
Also, when you try to ask for a feature flag in the code review, people will throw YAGNI at you, and they might be not wrong, at least for the first few years. After that, it's a costly refactor.
fc417fc802 21 hours ago [-]
The ideal isn't feature flags (ie FOO_SUPPORTED) but rather feature tests (ie COMPILES( foo( int ) ) ). Yet another reason why languages with proper metaprogramming capabilities are better.
MereInterest 4 hours ago [-]
The problem with feature tests is that you then rely on the test code being correct. A typo in the feature test can erroneously be interpreted as lack of that feature.
One step of the 2024 supply-chain attack on xz utils was to disable a security feature by introducing a feature test with an intentional typo. Even knowing that this commit[0] contains an intentional typo, I had to re-read the diff a few times to actually find it.
The problem is that COMPILES( foo( int ) ) is not the same as DOES_WHAT_I_WANT_IT_TO( foo( int ) ).
fc417fc802 8 hours ago [-]
Naturally you can also implement DOES_WHAT_I_WANT_IT_TO( foo( x ) ) as a follow on. For example I have some code that relies on specific IEEE floating point properties; rather than hope for the best I explicitly test the behavior at program initialization. I also have lots of compile time tests of the form constexpr does_what_I_want() { ... } static_assert( does_what_I_want() ).
rurban 1 days ago [-]
I just implemented a fast small compiler rcc to compete against tcc, and these glibc header quirks were simply fixed in the same way clang does it. By defining all gcc predefines and implementing all gcc extensions. Needed a day. And my headers are clean compared to glibc. The others in this league are slimcc, kefir and cproc. No other compilers can parse glibc headers. tcc has this special exception.
lelanthran 1 days ago [-]
Back in my youth I implemented a C compiler that was almost impressive.
Dealing with the preprocessor (essentially a different, crippled language) was too much headache at the start so I just used `cpp`, and at the end, I was just too lazy to implement it, so continued using `cpp`.
(BTW: Anyone else here ever used the Cosmic C Compiler for Motorola microcontrollers? Amongst other idiosyncrasies, it had only one datatype - `byte` - and I had to implement macros to do 16-bit arithmetic operations. That project was easily the worst development experience of my life.)
einpoklum 24 hours ago [-]
If the codebase is small, and the dependencies are minimal, you might look into trying to integrate your rcc in "bootstrapping" flows, which currently often rely on tcc as a stepping stone towards gcc. And perhaps even being able to skip gcc 4.7 in favor of your compiler, if it's capable of, say, compiling a modern gcc to work even suboptimally.
rurban 23 hours ago [-]
tcc is pretty good for this.
What I want to explore is cheap and fast optimizations, without SSA and data flow tracking. I have huge sources files compiled to 25MB .o files, which should need to be compiled in less than 5m. So far only tcc can do that. But I have now consteval and deadcode elimination for free. Which tcc cannot do.
arikrahman 16 hours ago [-]
I'm in the middle of targeting Dart C FFI for Jank lang. The Zig toolchain has been helpful for simplifying the complexity, similar to how Bun simplified JS devwork. This article is relevant as some libraries have to be considered in building the jank package with glib libraries on a Nix flake.
ndesaulniers 18 hours ago [-]
> it took significant effort to e.g. get clang to compile the Linux kernel (needing patches in both projects).
Tell me about it. :-)
user2342 10 hours ago [-]
> For example, clang defines __GNUC__=4 (and __GNUC_MINOR__=2, __GNUC_PATCHLEVEL__=1) to claim compatibility with GCC 4.2.1.
Is this because Apple at some point stopped updating GCC because of the GPL license change? I think GCC 4.2.x was the last GCC licensed under GPLv2. Could be for compatibility reasons for Mac software.
gritzko 1 days ago [-]
What is the feasible way to test code against the matrix of compilers/oses?
btrettel 1 days ago [-]
One approach for testing with multiple compilers that I use on some Fortran projects (where testing against multiple compilers seems more common than in C) is to use a variable from the command line to specify the compiler, for example:
make FC=ifx check
On my Fortran projects, that will run the tests with Intel's Fortran compiler. The Makefile has logic to automatically change compiler flags as appropriate. I default to the GNU Fortran compiler, so `FC` isn't required.
I have made a script to run through a series of compilers by alternating between `make check` and `make clean`.
I have separate Makefiles for GNU Make and NMAKE/jom. My Fortran code works fine on various Linux distributions and Windows, though I'll add that achieving that is probably easier with Fortran than C. I've also tried a BSD Make that worked (on Ubuntu at least). My Makefiles are pretty close to the intersection of POSIX and NMAKE, so the main differences between the different Make versions are the conditional statements needed to handle the different compiler flags and the include statements (as I put the compiler flags in separate files).
aDyslecticCrow 1 days ago [-]
And architectures. Probably a bunch of build servers or a swarm of docker, qemu, and VMs, with a good test coverage to detect behaviour differences.
In practice, the compiler is an often an omitted dependency of any c code.
gritzko 1 days ago [-]
I think I did not get to that level yet where I trust Claude to create its own VMs. But one day I will.
pocksuppet 1 days ago [-]
Realistically, you don't aim to support every platform. You have a finite set of platforms you want to support. As the size of that set goes up, so does the probability it'll work on platforms unknown to you, but it's never 100%. Did you know some platforms have 32-bit char?
account42 8 hours ago [-]
For open source? Test on your platform, release the code, and then wait for the bug reports/patches. Not even kidding.
dapperdrake 19 hours ago [-]
Also try musl libc and cosmopolitan libc. And try tcc. This helps clean up a lot of stuff that I got wrong.
gritzko 11 hours ago [-]
I live on alpine, in fact.
einpoklum 24 hours ago [-]
> Anyone who's written C knows that full ISO C standard-adhering code is an impractical rarity.
I've written quite a bit of C code and do not know that to be a rarity. Especially when it comes to libraries rather than applications, and FOSS as opposed to proprietary code.
> Most real world C code out there relies on non-standard behaviors and language extensions to varying extents
Maybe it depends on which domain you're working in. At companies whose target platform is not a PC, relying on idiosycratic behavior, or extensions, is difficult: The compiler for the target device may simply not support the bells and whistles of GCC or whatever, so you stick to C99, (or even C89, ugh) to be on the safe side. And even then there will be things which are standard, but... well, I would be wary of relying on them being supported robustly enough, e.g. variable-length arrays.
And of course, once your code does not target just one single machine then you're forced to have to worry about portability and standard compliance etc.
kouosi 24 hours ago [-]
> And of course, once your code does not target just one single machine then you're forced to have to worry about portability and standard compliance etc.
https://github.com/dlang/dmd/blob/master/druntime/src/import...
https://github.com/dlang/dmd/blob/master/druntime/src/__impo...
The article highlights a typical piece:
There is no reason that !defined check to not include a check for __attribute__ already being defined (a custom compiler author could then force an define for __attribute__ that translates to an internal __mycompiler__attribute__ replacement by default).But outside of that, just trying to compile on FreeBSD you often run into systemd dependencies or other non-posix behaviors (Not to mention on Windows but I'm not here to bring on flamewars so I'll leave that part).
Windows users singling out Linux users for not catering to their platform. How the times change...
> you often run into systemd dependencies or other non-posix behaviors
Not a problem. POSIX is irrelevant, systemd is great and we should all be using Linux to its fullest extent. Linux has great features and there is absolutely no reason not to use them all. Nobody complains about the fact BSDs have cool things like kqueue and unveil.
This goes back to the days I was browsing freshmeat and saw some interesting command line tool or otherwise non-UI tool from some hopeful developer for something useful. Node had significant traction but didn't really blow up until it became really cross-platform.
And perhaps is less of an issue these days since so many people use Mac's as their primary, so less Linux-isms survive once in context with osX.
> Not a problem. POSIX is irrelevant, systemd is great and we should all be using Linux to its fullest extent. Linux has great features and there is absolutely no reason not to use them all. Nobody complains about the fact BSDs have cool things like kqueue and unveil.
From following it over the year it was not entirely welcomed even in the linux community (and some of the security issues made one shudder). Mostly it's the monolithic nature that's makes it a questionable, is it Gnu/Linux these days or Systemd/Linux ?
kqueue is just an api, just like epoll, io_uring or even iocp on windows. And yes, it's a special case for high-perf servers where posix becomes less relevant (and while I can appreciate some lower-perf fallback to be able to develop/port to another platform like a console I do see that some programs are inherently platform bound).
I think one thing lost in my original comment was that I was often encountering things like this with "simple" CLI tools or lower level format libraries, and honestly projects like that also had a tendency to break over time without updates as they often relied on specific versions of libraries the maintainers had installed via Linux package managers, in the same fashion as npm has caused churn in the JS community. (npm at least has version pinning so old cli tools can often be run as long as node hasn't deprecated api's).
Yeah, and then we get "osX-isms" instead. Before node, there was rubygems which contained lots of macOS specific software.
Nothing particularly wrong with that. People should use their preferred platforms to the fullest. Why make it a point to single us out for "linux-isms" though? Makes absolutely no sense. BSD-isms, Win32-isms, macOS-isms are just as abundant.
> From following it over the year it was not entirely welcomed even in the linux community (and some of the security issues made one shudder).
It's definitely welcomed now. There's plenty of legitimate criticism against systemd but lack of standards compliance, incompatibility with other platforms or lack of devotion to some nebulous "unix way" religion aren't among them. The whole point of systemd is to use Linux kernel features like cgroups to the fullest extent, and it does so to great effect.
> Mostly it's the monolithic nature that's makes it a questionable, is it Gnu/Linux these days or Systemd/Linux ?
It's just "Linux".
GNU is not in any way special either. GNU, systemd, they're all just random user space stuff you can put on top of Linux. You can boot Linux directly into your software if you'd like.
It's strictly less monolithic than BSDs which ship a kernel and a whole bunch of system components and user space libraries you can never ever bypass because they explicitly don't guarantee ABI stability like Linux does. To say nothing of macOS which becomes more of a walled garden every day that passes.
In my experience this was a problem over 25 years ago when I developed for Solaris and other non-Linux operating systems.
So I suppose it does have a marketing benefit in that I now use Linux.
Surprised about FreeBSD. My experience is that porting Linux software is usually pretty easy as long as it's not using some Linux-only feature (io_uring for instance).
I'm not sure why you're surprised, the parent of you comment clearly stated
"on FreeBSD you often run into systemd dependencies or other non-posix behaviors"
which means, software written for Linux often uses "Linux-only features" such as systemd and other non-posix dependencies that are foreign to the BSDs and traditional UNIX. Thus, it shouldn't be surprising that Linux software is hard to port to the BSDs.
Linux used to be a pretty good UNIX, I'm not sure what it is now.
And BSDs are just as happy to accumulate nifty features like kqueue, unveil and whatever else it is that they have. These features are all just as foreign to Linux as io_uring is to them, and just as non-POSIX compliant.
Yet somehow I just don't see people complaining about them endlessly the way people complain about "linux-isms". When I see such features I am very impressed because I think they're amazing innovations, and my only reaction is to wonder when Linux will gain the same features so it can be just as great as they are.
Linux has become Linux, it's own thing that as often as not says "yeah, that old Unix stuff is fine for you boomers and other fossils...we're going to be over here doing our own thing". Which is probably fine, I guess, because all the old Unix versions did the same thing to some extent and the computing world had changed over a dozen times since Unix showed up. Unless you were on one of the minimally massaged System V reference ports, going from one vendor to another was anything between "lots of annoying differences that make life less fun than it could be" to "WTF said this was Unix and why did you make me touch it?". Ultrix, SCO and UTek (among many others) weren't awful. Solaris and HP/UX had some vendor-only things that were hard to replicate. AIX made you question your life choices, especially if you wandered off into one of the mainframe versions; you had clearly angered the gods.
There used to be Windows, Unix, and everything else. Now there's Windows, Linux, and everything else, with Unix (BSD mostly) being part of everything else. Times change, shit happens, and there's only so much that impotently shaking your fist at the unjust universe will fix.
https://learn.microsoft.com/en-us/cpp/build/reference/zc-pre...
I don't expect anyone writing GUI tools or more high-perf servers to spend their time porting to other platforms (trying to compile GTK on Windows wasn't for the faint of heart).
“All the world's a VAX”
https://groups.google.com/g/comp.lang.c/c/CYgWkWdWCcQ/m/thMt...
https://www.lysator.liu.se/c/ten-commandments.html
2: You could easily compile Samba yourself for FreeBSD in the past, last time I tried a new version it broke in what I remember being due to linux-isms (yes there is ports, but being reliant on older versions if ports maintainers can't keep up isn't a good thing).
3: The only "fairly basic" stuff that's hugely different is mostly the absence/reliance on shell-scripts (when building), but that has little to do with the actual code function (Personally I often used Node scripts in those scenarios, Python scripts would probably be an improvement since there's no reason it couldn't be everywhere).
I used to use Tremor to decode Ogg audio (no UI needs, just binary data in, arrays of primitive values in audio buffers out), early versions were easy to compile under Windows but building later versions were buried in shell scripts generating headers,etc for no real good reason (maybe to help port when working on a Linux workstation to other embedded devices but made the code less easily compilable by default), the core functionality only really needed a C compiler as early versions showed.
I can agree that something with advanced UI's like Blender (that relies on GL/3d rendering for UI) might not be easily portable, but when algortihm libraries often requires heavy reworking it's not a good thing (Here I think Github has helped since people has had an easier time to contribute, it's a sad thing that people are moving away due to the AI-crap).
In the end, it's not about _actual_ differences but more of a superiority complex of Linux users that is the main roadblock.
How many times have we been told that we're entitled freeloaders for expecting Linux compatibility work from others? Insulted by people who use dominant platforms that get all the commercial support while we get literally nothing? Reduced to reverse engineering stuff with no documentation and zero help?
Pretty wild to watch this unfold. Now that Linux is finally coming out ahead, as it should, because people are finally writing software for it... Suddenly we're the bullies.
I worked in gamedev, consoles, etc. Linux support was often discussed but the whole mess of different libraries on various distros vs static library linkage legality, evolving audio api's,etc was real blockers (Valve just defaulting on Wine and Win32 binaries for steamdecks could be discussed at length).
Honestly, could even be posited that the rise of the Web as a delivery platform, Java and Node,etc is in large part DUE to the fragmented story of much of C/C++ code platform-tiedness, Linux just happened to move ahead due to it's momentum as the "free" option (quotation marks due to Android).
You have the source code and it's literally free software. What else do you need?
It's honestly pretty incredible to hear complaints like "it didn't compile on my preferred platform unchanged".
> the whole mess of different libraries on various distros
All the various Berkeley Software Distributions out there don't have different systems and libraries of their own?
This is a user space problem anyway. Linux kernel is actually better here. Linux actually lets you bypass system libraries and talk to the kernel directly. You can write Linux applications in freestanding C and they will work. BSDs will eventually break ABI and your program if you do that.
> static library linkage legality
Nothing illegal about it. Just gotta follow the terms of the GPL. Whether you're willing to do it is a completely separate matter.
> Valve just defaulting on Wine and Win32 binaries for steamdecks could be discussed at length
Don't think there's any discussion to be had here. It's just the pragmatic choice that buys us access to vast amounts of existing software that will never be ported. Linux kernel is even gaining NT functionality now just to support this. Nothing wrong with it.
You can totally get Linux versions of games in the Steam Deck, it's just that they're often second class ports, outdated and generally forgotten by all including the developers. There is no reason whatsoever to sit around waiting for things that will never come.
Where have you been for the last quarter century?
In the late 90s-early 00s we had SystemV, Linux, BSD, macOS and the market begged for standards like POSIX and to an extent CDE and many other proposed ones. As the largest player, Linux always had an attitude.
Now, after winning the Server, embracing, extending and extinguishing the Workstation/Desktop(WSL, Valve), and with a foothold in mobile(Android) Linux is the de-facto standard.
The BSDs have declared POSIX dead and gone their own way while supporting Linux(SystemD, Wayland) APIs even if they are more half-baked than POSIX in order to benefit from what is now virtually a Linux ecosystem.
I don't like this any more than you but it is what it is.
Then there's portability between compilers, which, as the article notes, glibc is also completely hostile to (except for anointed compilers) for no good reason whatsoever.
This is neither true nor claimed by the article.
It doesn't work. For no good reason. Because there are a few anointed compilers.
That it wasn't on purpose doesn't make it not hostile.
Which is at least better than with MSVC, where they did everything differently, and only half of it.
That said - I think a rule-of-thumb one can follow is that any inclusion of a file with a directory prefix, especially `<sys/whatever>`, needs a guarantee-of-availability in your build configuration phase, e.g. CMake `find_package()`, or or at least `check_include_file()` and such. That way, you might be more likely to fail to build, but at least you'll be telling the user "I expect these things to be present".
I don't like systemd but it is a lesser evil.
Meanwhile people still have issues on turning off their machines.
There are quite a few init systems: The venerable sysvinit, runit, s6, openrc and others. You don't like upstart? Ok, choose another one, there are many. Here is a comparison table by the Gentoo folks:
https://wiki.gentoo.org/wiki/Comparison_of_init_systems
As for the claim of "almost all sysvinit scripts contained several bugs" - that's both hyperbole and false. Plus, you seem to be implying that systemd has not been troubled by bugs, which of course it has (and that does not disqualify it; the fundamental design and organizational nature as a project are the disqualifiers).
One bright spot is systemd-networkd allows one to change quite a few things about interfaces in the way server automation platforms expect to work without doing a network restart. The workaround otherwise on, say, CentOS was always to write the new config file used by future restarts, also run CLI commands to update things in memory, and be sure to tell the service not to trigger a restart on the config file(s) changing. Otherwise if you’re doing something like streaming UDP video your own automation can become a reliability issue.
Systemd bothers people because it's not "the Unix way". In other words, it's not some painful lowest common denominator POSIX nonsense. That's a feature, not a bug. POSIX is garbage and restricting oneself to it is pure masochism.
Every unixlike deviates from POSIX and for good reason. That includes the BSDs, but somehow I don't see people complaining endlessly about all the nifty exclusive features they keep accumulating for themselves. Why is it that only Linux gets singled out?
Wait.
The point was that using systemd is somehow "mandated". It's not, people chose systemd because it's actually better and made life easier compared to some POSIX nonsense.
The point was that this non-existent "mandate" caused a "bifurcation" from "standards-based" software to Linux-specific. If anything is being "mandated" here, it's the POSIX compliance. Nobody is obligated to follow this like it's some sort of religion. The standard is garbage and should be forgotten.
The point was that systemd was "the bane" of FLOSS. Systemd is itself FLOSS, it's literally GPL'd. And pretty good FLOSS at that. It's just not "standards compliant" which makes it heretical or something. Total nonsense.
There are no "strawmen" here. Just downvote silently if you disagree and don't want to argue.
But I think the power dynamics is crucial. In the Lisp ecosystem the users have great power, (and there are dozens of implementations,) so it's not like one or two implementation decides what everyone is gonna use and everyone just lives with it.
[2] https://github.com/fuhsnn/slimcc/blob/main/slimcc_headers/pl...
Some more fun stories:
- Game projects default to using SIMD so for example SDL and STB you always need to pass -DSDL_DISABLE_IMMINTRIN_H and -DSTB_NO_SIMD
- math.h's NAN usually fall back to (0.0f / 0.0f), which will print "-nan" with printf, some projects test suite fail because of it (they expected "nan").
- NetBSD's sys/cdefs.h straight up #error's if you don't pretend to be GCC or PCC.
- Some projects can't compile without __attribute__((always_inline)) because they use it on non-static functions.
- Many projects probe -fvisibility in the build system and pass -fvisibility=hidden to compile, but in the headers they gate __attribute__((visibility(default))) behind __GNUC__ checks, so you'll get missing symbols.
- Some projects use if(0) { undefined_function() } to fake static_assert(), there is even a bug report from QEMU to Clang because it failed to optimize in -O0 a certain `if` written this way.
- Even if you define __STDC_NO_VLA__, projects might fall back to alloca() code path that's untested and broken (python and jemalloc both had this problem, already reported)
- Valkey has broken __builtin_ctzll fallback nobody noticed (reported).
- Zig's C bootstrap path expects the compiler to have GCC/Clang-tier optimization and stack overflows if you don't (reported).
- I contributed stdatomic.h code path for Ruby just to compile it with slimcc, pretty sure it's still the only user of the code path.
- I implemented __has_extension in the hope that projects can use it to query gnu_asm; but SQLite broke because they use __has_extension(c_atomic) to query GNU atomics builtin, but c_atomic actually is meant for C11 _Atomic (IMO they should use __has_builtin)
Considering such checks are fairly conventional in downstream C++ libraries based on compilers (for example checking OS platform or compiler, e.g. [Boost.Config](https://www.boost.org/doc/libs/latest/libs/config/). Modern C++ even went ahead and standardized this somewhat https://en.cppreference.com/cpp/utility/feature_test )
It's probably just natural for software developers (myself included), whenever only FooZoid v5 supports frobnicate(), say "#ifdef FOOZOID_V5" and go back to your business, rather than introducing "FROBNICATE_SUPPORTED".
Also, when you try to ask for a feature flag in the code review, people will throw YAGNI at you, and they might be not wrong, at least for the first few years. After that, it's a costly refactor.
One step of the 2024 supply-chain attack on xz utils was to disable a security feature by introducing a feature test with an intentional typo. Even knowing that this commit[0] contains an intentional typo, I had to re-read the diff a few times to actually find it.
[0] https://git.tukaani.org/?p=xz.git;a=commitdiff;h=a100f9111c8...
Dealing with the preprocessor (essentially a different, crippled language) was too much headache at the start so I just used `cpp`, and at the end, I was just too lazy to implement it, so continued using `cpp`.
(BTW: Anyone else here ever used the Cosmic C Compiler for Motorola microcontrollers? Amongst other idiosyncrasies, it had only one datatype - `byte` - and I had to implement macros to do 16-bit arithmetic operations. That project was easily the worst development experience of my life.)
What I want to explore is cheap and fast optimizations, without SSA and data flow tracking. I have huge sources files compiled to 25MB .o files, which should need to be compiled in less than 5m. So far only tcc can do that. But I have now consteval and deadcode elimination for free. Which tcc cannot do.
Tell me about it. :-)
Is this because Apple at some point stopped updating GCC because of the GPL license change? I think GCC 4.2.x was the last GCC licensed under GPLv2. Could be for compatibility reasons for Mac software.
I have made a script to run through a series of compilers by alternating between `make check` and `make clean`.
I have separate Makefiles for GNU Make and NMAKE/jom. My Fortran code works fine on various Linux distributions and Windows, though I'll add that achieving that is probably easier with Fortran than C. I've also tried a BSD Make that worked (on Ubuntu at least). My Makefiles are pretty close to the intersection of POSIX and NMAKE, so the main differences between the different Make versions are the conditional statements needed to handle the different compiler flags and the include statements (as I put the compiler flags in separate files).
In practice, the compiler is an often an omitted dependency of any c code.
I've written quite a bit of C code and do not know that to be a rarity. Especially when it comes to libraries rather than applications, and FOSS as opposed to proprietary code.
> Most real world C code out there relies on non-standard behaviors and language extensions to varying extents
Maybe it depends on which domain you're working in. At companies whose target platform is not a PC, relying on idiosycratic behavior, or extensions, is difficult: The compiler for the target device may simply not support the bells and whistles of GCC or whatever, so you stick to C99, (or even C89, ugh) to be on the safe side. And even then there will be things which are standard, but... well, I would be wary of relying on them being supported robustly enough, e.g. variable-length arrays.
And of course, once your code does not target just one single machine then you're forced to have to worry about portability and standard compliance etc.
Well linux exclusively usages gcc to compile.
Clang happens to implement gnu11, I think it's the only non-GCC compiler to do so.
For a long time only Android Linux kernel downstream supported it.
We need more betterC compilers, we have one (five if you count C3, ZenC, SafeC and Zig but they are not betterC)
And we need more assemblers.