Too many programming languages?

[Berni]

Well this code style argument really escalated quickly.

There is no ONE right way to format C code. Different styles have different benefits that might be more relevant for the particular use case, hence why you find so many styles of C code. These "style politics" happens in all languages but C seams to have very diverse styles due to the syntax not being too picky where things are and the popularity of the C language in general.

However the practice of cramming as much functionality as possible into one line benefits nobody. It's mostly just showing off programing skills for the sake of feeling superior. Having a big ego is usually a bad thing in programming, especially when multiple people work on the same project where this one guy forces his own ideas on everyone. Compacting code using lesser known features not only makes it difficult to understand for a programmer not familiar with that exact feature, but it also can trip up a experienced programmer that could understand it wrong from a quick glance (because they are used to using that feature is a slightly different way that causes a different effect). It can slow down people reading the code as you actually have to actively think what is going on in that line rather than just glancing at it. Your brain gets wired for your particular style of code, be nice to the people who have brains wired for a slightly different style by writing clear concise code.

I'm NOT saying to never use any fancy features in a language. Just use them with appropriate moderation. This is especially true for larger languages like C++, C#, Java...etc that have so many features. At the same time programmers go object crazy and make objects for every little piece of crap while naming those objects confusingly.

[brucehoult]

However the practice of cramming as much functionality as possible into one line benefits nobody. It's mostly just showing off programing skills for the sake of feeling superior.

I would certainly hope that anyone who calls themselves a C programmer would understand a very common idiom such as Bellard's ...

Code: [Select]

while (*p && *p++ != '\n')
  continue;

... at a glance.

What do you need to understand?

- what *p and *p++ do
- that text data is often terminated with a 0 byte
- that '\n' is a newline
- that in C 0 is false and everything else is true
- how a short-circuit operator such as && works
- what continue and break do in loops

C is a very small language and those are all completely fundamental things.

C++ is a completely different matter. I think I understood pretty much all of C++ around 1989 and up to and including C++98. What we've got now though is an absolute horror of complexity and interactions and just Too Many Features.

[Berni]

I would certainly hope that anyone who calls themselves a C programmer would understand a very common idiom such as Bellard's ...

Code: [Select]

while (*p && *p++ != '\n')
  continue;

... at a glance.

What do you need to understand?

- what *p and *p++ do
- that text data is often terminated with a 0 byte
- that '\n' is a newline
- that in C 0 is false and everything else is true
- how a short-circuit operator such as && works
- what continue and break do in loops

C is a very small language and those are all completely fundamental things.

C++ is a completely different matter. I think I understood pretty much all of C++ around 1989 and up to and including C++98. What we've got now though is an absolute horror of complexity and interactions and just Too Many Features.

This particular snippet of code is not that bad. Id say its about as far as one would want to go with code compaction.

If i was to write this code i would have probably done something like this:

Code: [Select]

while (*p != 0 && *p != '\n')
   p++;
My reasoning behind this that the while condition is only checking the condition while the body of the loop is what is actually doing the work. So that when i look at it i go "So this loop is incrementing p, repeating it until p is zero or linefeed". But again that's just how my particular brain works. Yes i know the part with "!= 0" is completely unnecessary, but it just looks more sensible to me because I'm looking for the zero character. If i am looping until a unsigned variable x decrements to zero i might use instead "while(x > 0)" even tho again the "> 0" does nothing. But if i have something used as a flag and i don't care about its value i might just go "if(isEmpty)" Its like commenting your code without actually using a comment.

I have seen code much worse than this where for example the loop condition is a 40 character long, contains of all sorts of things including function calls. Some thing inside there might be made using #define directives, but that #define contains 3 other #defines that each go 5 levels deep resulting in hunting all over the place to even figure out what that top #define is even doing...and this is before we even got to what that loop condition is doing.

[GeorgeOfTheJungle]

Code: [Select]

while (*p && *p++ != '\n') continue;


If i was to write this code i would have probably done something like this:

Code: [Select]

while (*p != 0 && *p != '\n') p++;


But yours doesn't do the same thing... 

Code: [Select]

#include <stdio.h>

int main () {
  char s[]= "abc\n";
  char* p= s;
  char* q= s;
  while (*p && *p++ != '\n') continue;
  while (*q && *q != '\n') q++;
  printf("%u\n", p == q);
}
=> 0

[Berni]

But yours doesn't do the same thing... 

Sorry. I see i missed the fact that the original code has a special case for line feed characters where it skips over the first occurrence of a line feed.

This is exactly my point in why it is not a good idea to cram as much functionality as possible into a line of code. The special case is embedded among all the other logic and is easy to miss. Okay i might not exactly be an expert in C (I'm a hardware engineer that only does programing when i have no other choice) but this is something that could have also easily gone unnoticed by a much more experienced programmer.

In such a case i would add "if(*p == '\n') p++;" on the end of my loop so that its clear to anyone reading this that \n is treated differently and also make it clear in what way it is treated differently. A extra line or two of code is a small price to pay for having your code be clear in its intentions and difficult to interpret the wrong way at a glance. Code is written to be read by humans, not machines (They would prefer it if you just gave them machine code rather than this inefficient ascii stuff)

[GeorgeOfTheJungle]

and his monolithic kernel is a very bad idea in the long term.

You sound like Andy Tanenbaum :-) https://www.oreilly.com/openbook/opensources/book/appa.html . But time has proven he wrong. The most desirable feature of microkernels is modularity, and Linux got loadable kernel modules ages ago: modprobe, lsmod, insmod, etc.

I believe you have some valid points, although I am not sure that a
microkernel is necessarily better. It might make more sense to allow some
combination of the two. As part of the IPC code I'm writting for Linux I am
going to include code that will allow device drivers and file systems to run
as user processes. These will be significantly slower though, and I believe it
would be a mistake to move everything outside the kernel (TCP/IP will be
internal).
 
Actually my main problem with OS theorists is that they have never tested
there ideas!

[legacy]

But time has proven he wrong.

no, he was not wrong.

Do you know how big is k5.4 on my HPPA2? ____24 MB___ 
(with all modules static compiled)

Monolithic kernels are a pain in the ass to be debugged, if there is a bug here, or there, the whole kernel crashes, and I know it not because I read a book, but rather because I am tired to deal with Linux on my SGI/IP30 (on which ... there is no ejtag port, hence I do have to debug via kgdb, on a hacked thing attached to the PCI behind a XIO port).

Macrokernel "were" good only because they minimize the costs of context switches to bundle system calls in batches. This was a must-have for the previous hardware, but times have changed in the last twenty years, and nowadays modern hardware does not need this compromise, and this means it's the end of Linux.

[brucehoult]

But yours doesn't do the same thing... 

Sorry. I see i missed the fact that the original code has a special case for line feed characters where it skips over the first occurrence of a line feed.

This is exactly my point in why it is not a good idea to cram as much functionality as possible into a line of code. The special case is embedded among all the other logic and is easy to miss.

But it's not a special case! The whole point of this code is to skip to the start of the next line of text, including skipping over the newline.

Hopefully you'd find it clear as:

Code: [Select]

while(*p++ != '\n') continue;

The "*p &&" is there just to prevent sailing on past the end of the input string as a whole.

It's really, I would say, totally normal and idiomatic C and not in the least bit "tricky".

In such a case i would add "if(*p == '\n') p++;" on the end of my loop so that its clear to anyone reading this that \n is treated differently and also make it clear in what way it is treated differently. A extra line or two of code is a small price to pay for having your code be clear in its intentions and difficult to interpret the wrong way at a glance. Code is written to be read by humans, not machines (They would prefer it if you just gave them machine code rather than this inefficient ascii stuff)

Ugh. That's just unnecessarily bulking up the amount of stuff to be read. And the amount of machine code generated.

If it was my code I'd be doing it a little differently. I'd make a function "skipToNextLine(char **p), with a comment or two, and maybe marked as "inline" (or maybe leave that up to the compiler).

[Berni]

But it's not a special case! The whole point of this code is to skip to the start of the next line of text, including skipping over the newline.

Hopefully you'd find it clear as:

Code: [Select]

while(*p++ != '\n') continue;

The "*p &&" is there just to prevent sailing on past the end of the input string as a whole.

It's really, I would say, totally normal and idiomatic C and not in the least bit "tricky".

Yes but i was looking at the code out of context just looking at what that one loop is doing. Not thinking about what it does for more than a few seconds or actually trying to run it.

I could also be used to find the length of some input string later on by subtracting away the original pointer and in that case you generally would not include newlines.

Ugh. That's just unnecessarily bulking up the amount of stuff to be read. And the amount of machine code generated.

If it was my code I'd be doing it a little differently. I'd make a function "skipToNextLine(char **p), with a comment or two, and maybe marked as "inline" (or maybe leave that up to the compiler).

Yep doing it as a named function is also a good way to make it clear what it is doing as long as the name is descriptive like that. Way too often i see too abbreviated names for functions and variables in C code. Like for example naming this function "nextln(char **p)" in what case it only makes things worse.

This move to next line code sounds like it might be used in a lot of places so it makes sense to have a function for it. But if its used only once, then i think just putting a comment "\\ Skip pointer to start of next line" in front of the loop is a nice way to do it.

To be honest i don't always comment my code as well as i think i should. But i try to have a single line comment in front any significant loops or large nested "if" statement blocks. I might also add comments to single lines of code if the action has an effect down the line but has no obvious purpose within this function (Like setting some unrelated flag in a bufferClear() function that is needed to make sure that some other part of the program doesn't fall on its face because the buffer it was using suddenly disapered).

I just try to be as nice as possible to whoever reads my code, chances are that someone is going to be me in >5 years from now trying to quickly fix a bug or tweak some functionality while having forgot everything about how this thing even works.

[Kjelt]

Macrokernel "were" good only because they minimize the costs of context switches to bundle system calls in batches. This was a must-have for the previous hardware, but times have changed in the last twenty years, and nowadays modern hardware does not need this compromise, and this means it's the end of Linux.

I might misread your statement and it could be you are talking about the cloud for instance. But on the larger IoT devices I only see more embedded Linux systems running on SoCs popping up actually.
Could you elaborate on the non OS alternatives you see ?

[Tepe]

We've seen Torvalds' style. Let's see Fabrice Bellard's:

Code: [Select]

while (*p && *p++ != '\n')
  continue;

Yeah, altough I still find the above typical of bad C style.

It is, except for the superfluous "continue" (which is actually cool), idiomatic C.

I would write the above as, for instance, such:

Code: [Select]

while (*p != '\0')
{
    if (*p++ == '\n')
        break;
}


And this is not.

[Tepe]

... just putting a comment "\\ Skip pointer to start of next line" in front of the loop is a nice way to do it.

That's not a comment 
(I have always wondered how some people manage to mix up forward and backward slashes)

[brucehoult]

... just putting a comment "\\ Skip pointer to start of next line" in front of the loop is a nice way to do it.

That's not a comment 
(I have always wondered how some people manage to mix up forward and backward slashes)

One of the tenets of the "Extreme Programming" people back around 2000 was "no comments -- the variable and function names should make the code self-explanatory"

I've actually worked at a place that didn't go quite that far, but had the rule "No comments except possibly one before a function explaining the purpose of the function". A corollary of that was "If you feel you need to add a comment to explain a block of code then extract it into its own function".

[GeorgeOfTheJungle]

Yeah, the style "books" are full of dogmas. E.g. JSLint, a famous JavaScript linter by a famous JavaScript guru, that ~ nobody uses. The ones everybody use are configurable, so you can cherry pick only the dogmas you like/want. To each his own.

[GeorgeOfTheJungle]

But time has proven he wrong.

no, he was not wrong.

Do you know how big is k5.4 on my HPPA2? ____24 MB___ 
(with all modules static compiled)

Now try with make allnoconfig ... then add one by one only the things you really need.

and this means it's the end of Linux.

Sorry, but I don't see the end of Linux anytime soon. By the way, AST, the minix guy, 20 years later got a 2.5 million grant from the EU and made minix 3:

https://wiki.minix3.org/doku.php?id=www:documentation:features



https://www.youtube.com/channel/UCGE79COc35OCPu7UQJYILQw/videos

[legacy]

Now try with make allnoconfig ... then add one by one only the things you really need.

it was not the point, and on machines like rb532, when the minimal config of the kernel (minimal means you cannot remove anything else) takes more 8Mbyte you are completely unable to use the machine because the firmware says "out of range" and refuses to load the kernel.  There are a lot of examples of this kind. My old C1xxx Japanese PDA? yet again the firmware cannot load a kernel bigger than 5Mbyte, and I have to use a 2.4 kernel to load a 2.6.* kernel, which introduces a lot of problems, which make impossible to load a kernel 4.*, and the machine is doomed to be unable to run a modern rootfs du to the kernel obsolescence.

This sucks.

But THE point was: kernel modules are a pain in the ass to be debugged this way, because you have to assume the storage is working, and in certain cases neither the network (NFS? forget it), nor the SATA, PATA, SCSI, whatever does work. On machines like SGI/IP30 this means you have to waste a lot of time, trying and retrying in the darkness, and it takes more time than with microkernel where you can add things progressively at the sunlight.

Besides, if the kernel is so big, your ICE also needs more ram to emulate it. Do you know how much does it cost an ICE with 8Mbyte of ram RealTime? Do you know how much money does it cost 64Mbyte?

For my HPPA2, I don't want to even look at the price list, and if you do not have the ICE or a debugger cable, you are f***d up. Indeed, after 20 years of hacking, the SGI/IP30 is still unable to properly use the PCI.

[GeorgeOfTheJungle]

What I don't get is, if you don't like it, why are you trying to shoehorn it into those vintage machines? There are not any microkernel alternatives?

[legacy]

Sorry, but I don't see the end of Linux anytime soon

last 5.* have a lot of code-regressions. This must mean something. Starting from "devs" (like AlanCox, and Miller) are tired, to ... nobody is probably no more willing to go ahead with the increased level of complexity stuffed monolithically into the kernel.

Even Linus.T. stood up and admitted it - "Linux is too bloated" - he said, yes, it is.

[GeorgeOfTheJungle]

Sorry, but I don't see the end of Linux anytime soon

last 5.* have a lot of code-regressions. This must mean something. Starting from "devs" (like AlanCox, and Miller) are tired, to ... nobody is probably no more willing to go ahead with the increased level of complexity stuffed monolithically into the kernel.

Who said that "reports of my death were greatly exaggerated" ?

Even Linus.T. stood up and admitted it - "Linux is too bloated" - he said, yes, it is.

I googled that, and see what I stumbled upon

One thing that I forgot to mention, but which is critical to the success of Linux, is that there really is no such thing as monolithic "Linux." Linux is highly modular and can be trimmed down/beefed up to fit a wide variety of applications...on the developers' terms, not Red Hat's, Novell's, Canonical's, etc.

So, unlike Windows, which can only be what Microsoft dictates, Linux can truly be all things to all people, as "fat" or as "skinny" as the developer wants it to be. Ubuntu is obese compared to sub-100 KB uClinux distributions, for example. Both serve different, and useful, purposes.

https://www.cnet.com/news/linus-torvalds-linux-is-bloated/

[Cerebus]

Sorry, but I don't see the end of Linux anytime soon

last 5.* have a lot of code-regressions. This must mean something. Starting from "devs" (like AlanCox, and Miller) are tired, to ... nobody is probably no more willing to go ahead with the increased level of complexity stuffed monolithically into the kernel.

When a particular codebase has been around long enough, and has had enough changes made to it over they years, there comes a moment when it is time to rip it up and start again. This applies to anything: accounting software, monolithic os kernels, microkernels, you name it. It has nothing to do with the application at hand, the methodology used or any other similar variable. It's just one of the great unwritten laws of software. The cost of comprehending and maintaining, and the risks of additional changes to, the accumulated cruft outweighs the cost and risks of starting afresh.

There's always a list of reasons, often spurious, why this shouldn't/can't be done - sunk costs, backward compatibility, etc. - but every competent developer knows that all codebases eventually reach the point where it's time to take it around the back of the barn with a shotgun and get a new codebase.

Whether the linux kernel has reached this point is another question; but it's a question of when, not if, it becomes true.

I googled that, and see what I stumbled upon

One thing that I forgot to mention, but which is critical to the success of Linux, is that there really is no such thing as monolithic "Linux." Linux is highly modular and can be trimmed down/beefed up to fit a wide variety of applications...on the developers' terms, not Red Hat's, Novell's, Canonical's, etc.

So, unlike Windows, which can only be what Microsoft dictates, Linux can truly be all things to all people, as "fat" or as "skinny" as the developer wants it to be. Ubuntu is obese compared to sub-100 KB uClinux distributions, for example. Both serve different, and useful, purposes.

https://www.cnet.com/news/linus-torvalds-linux-is-bloated/

I think you're misinterpreting that. To me that reads as talking about a complete linux distribution/implementation, not just the kernel.

Changing tack:

I would not characterise the linux kernel as modular. Yes, it has some modules, but that's not the same thing as being properly modular.

Can you do a build of the current kernel and remove all individual arbitrary features to loadable modules or eliminate then entirely? If you can then that feature is modular, if you can't and it has spread its tentacles into other features, then it is not modular. Unless you can do with with all features I don't think you can characterise it as properly modular, just as having (some) modules.

Whether the distinction (fully modular/has modules)  is a useful distinction depends on where something is on the scale between monolithic...has modules...fully modular and what you're doing with it.

In particular, can you exclude all the features that you're not going to be using from a particular kernel build? If you can't, and you end up with a kernel that is, for your purposes, carrying unwanted baggage then it is a useful distinction.

Again, if you're developing a kernel feature, then the ability to exclude all other features is a useful distinction, as it allows you to test your code in as much isolation as possible, or in controlled combination with other features, one at a time, to see what breaks what.

If you're trying to shoehorn a minimal kernel onto a microcontroller where every extra useless byte of code is an imposition then it clearly is a useful distinction.

If you're using the kernel on a general purpose computer for general purpose uses then it's probably not a useful distinction. There I think you'll be perfectly happy with sufficient modularity that the kernel doesn't get bloated with device drivers for devices you don't have.

[brucehoult]

What I don't get is, if you don't like it, why are you trying to shoehorn it into those vintage machines? There are not any microkernel alternatives?

"Microkernel" is a technical term which means that as little as possible code runs with elevated privileges and everything else talks to it and each other via the kernel. It doesn't make the total RAM impact smaller. Probably it makes it bigger.

[GeorgeOfTheJungle]

What I don't get is, if you don't like it, why are you trying to shoehorn it into those vintage machines? There are not any microkernel alternatives?

"Microkernel" is a technical term which means that as little as possible code runs with elevated privileges and everything else talks to it and each other via the kernel. It doesn't make the total RAM impact smaller. Probably it makes it bigger.

Bigger, clumsier and slower, yes. But I'm not the one who criticizes Linux and advocates for microkernels.

[GeorgeOfTheJungle]

If anybody wants to play with an awesome, tiny and fast microkernel for embedded, FreeRTOS it is. For $5 any esp32 comes with it for you to try. The kernel is about 6kB or so. With two cpu cores and SMP!

https://grouper.freertos.org/features.html

[bpiphany]

On subject I feel this thing is worth some flaunting. I can't vouch for it's correctness - I haven't compiled the compiler. But allegedly it solves the first day's problem in this year's Advent of Code

From knowing some programming, it is kind of not completely impossible to interpret the general idea of most of the constructs. I think it serves as a nice reminder of how foreign programming probably is to someone outside the profession/hobby.

Code: [Select]

Sadness is loneliness
The programmer was anticipating
Advent is extraordinary
The rush is uncomparable

Christmas takes joy and kindness
    Your spirit is incredible
    While joy is as high as kindness
        Build your spirit up
        Let joy be without kindness

    Give back your spirit

AdventOfCode takes time (but it's plenty of fun)
    Let fun be Christmas taking time, and Advent without the rush
    If fun is as low as sadness
        Give back sadness

    Give back fun with AdventOfCode taking fun

The elves are thoughtful
Santa is overseeing
The time is now
While the time is right
    Listen to the jingles
    If the jingles ain't ok
        Break it down

    Let the jingles be without sadness
    Let the elves be with Christmas taking the jingles, and Advent without the rush
    Let Santa be with AdventOfCode taking the jingles

Shout the elves
Shout Santa
https://github.com/vstrimaitis/aoc-2019/blob/master/day1/sol_formatted.rock

Rockstar Lang

[SiliconWizard]

On subject I feel this thing is worth some flaunting. I can't vouch for it's correctness - I haven't compiled the compiler. But allegedly it solves the first day's problem in this year's Advent of Code

From knowing some programming, it is kind of not completely impossible to interpret the general idea of most of the constructs. I think it serves as a nice reminder of how foreign programming probably is to someone outside the profession/hobby.

Ahah, nice one!

I wonder what Boeing's MCAS code would look like in Rockstar.