Too many programming languages?

[legacy]

Like I said, highlighting all tabs in Gedit/Pluma (by searching for \t with backslash escapes enabled in the search dialog) makes the tabs visible.

Nice trick 

I wrote a text editor years ago. It looks like "nano", it's very simple and features limited; after your comment, yesterday I implemented a way to highlight all tabs. So now they are visible.

[blacksheeplogic]

avionic rule #13: "{ }" must always be preceded by if() | else | do | while() | switch() | for() | function()

Be interesting to know why that got written into the code standard. I'm guessing someone abused it to work around a scope issue and in typical corporate fashion all problems are fixed by updates to the documentation.

[legacy]

Be interesting to know why that got written into the code standard

Mostly because it simplifies the team working activities. Especially in the testing squad.
It's a de-facto benefit.

[westfw]

[many ways of expressing an empty while loop. almost all for C/C++]

Ok, now I'm curious.  The empty while loop is a staple of embedded programming.Does anyone have a newer favorite language that has a syntax that they like BETTER than their favorite C syntax?

I implemented a way to highlight all tabs.

I have an EMACS hack that continually highlight tabs, and any trailing whitespace on a line (dark gray instead of a black background.)It's handy (especially since tailing spaces can break things "mysteriously" if you don't see them.)

[Cerebus]

Ok, now I'm curious.  The empty while loop is a staple of embedded programming.Does anyone have a newer favorite language that has a syntax that they like BETTER than their favorite C syntax?

To me the obvious construct to use is an explicit no-op of some sort. C doesn't have one, just the implicit null statement, which is what leads to difficult to read code.

Ironically, older languages than C had explicit no-ops (Algol-68: SKIP, FORTRAN: CONTINUE) but you've asked for newer languages. Some example of explicit no-ops from newer languages, not exhaustive: Ada - null, Python - pass. I'm sure the list is longer but I can't be bothered to scrape my memory/the net for other examples.

I've no problem with something like this (in C) that is effectively making up an explicit no-op (Which, let's face it, is part of the grand tradition of extending C in ad-hoc ways, but at least I haven't #def'd a made up SPIN_WHILE() operator.):

Code: [Select]

void spin_no_op ()
{
    /* As well as usefully doing nothing, acting as a marker for a no-op and probably getting optimized away, writing */
    /* this as a procedure also has the advantage that, if the particular platform we are on has a wait-for-interrupt */
    /* instruction or something similar that reduces power consumption in a busy-wait loop we can drop it in here     */
    /* and automatically get it used by any code that calls here. e.g.: */
#if defined(GNUC) & defined(__x86_64__)
    asm volatile ("PAUSE");
#endif
}

void do_work()
{
// ...
extern volatile int waiting_for_interrupt_from_turboencabulator;
// ...
    while (waiting_for_interrupt_from_turboencabulator) spin_no_op();
}


[brucehoult]

I have an EMACS hack that continually highlight tabs, and any trailing whitespace on a line (dark gray instead of a black background.)It's handy (especially since tailing spaces can break things "mysteriously" if you don't see them.)

M-x whitespace-mode

.. will basically do that. It doesn't interfere with your editing mode, and you can toggle it on and off at will.

By default it shows spaces as a . on light yellow background, tabs as >> on a khaki background, and trailing whitespace as angry red. But you can tune that to your heart's content, changing styles or what elements are highlighted at all e.g. "don't show me spaces"

[blacksheeplogic]

Mostly because it simplifies the team working activities. Especially in the testing squad.
It's a de-facto benefit.

Companies I've worked out change occurs because one of 5,000 people working on the product does something not considered kosher by some opinionated bastard so we all get punished by a process update. I don't recall off-hand anything being done for beneficial reasons.

[GeorgeOfTheJungle]

[...] something not considered kosher by some opinionated bastard [...]

This is how Linus does it: https://github.com/git/git/blob/29d76d4b05bc537ac59fd1e6f849ab3386c01502/rev-tree.c#L141-L146

Code: [Select]

static unsigned long parse_commit_date(const char *buf)
{
  if (memcmp(buf, "author", 6))
    return 0;
  while (*buf++ != '\n')
    /* nada */;
  if (memcmp(buf, "committer", 9))
    return 0;
  while (*buf++ != '>')
    /* nada */;
  return parse_time(buf);
}

[Mechatrommer]

that is a kind of poor or lazy programming practise (if not taken with cautious) that gave C/C++ a bad name, who wrote that? it expects correctly formatted buf input, otherwise the famous buffer overrun... ps: added/corrected.

[brucehoult]

that is a kind of poor or lazy programming that gave C/C++ a bad name, who wrote that? it expects correctly formatted buf input, otherwise the famous buffer overrun...

That code is unchanged since April 2005.

I guess you could craft a malicious commit blob, but what are you going to achieve on your own machine, in your local git repo? I don't think that would survive packing, which happens before sending to a server.

[Mechatrommer]

that is a kind of poor or lazy programming that gave C/C++ a bad name, who wrote that? it expects correctly formatted buf input, otherwise the famous buffer overrun...

That code is unchanged since April 2005.

doesnt mean its a good practice (added/corrected my previous msg) esp to those who dont know what they are doing. will open up opportunity to some interesting exercises for those who are interested (crackers) i dont care its not my business. for this reason, coupled with negative zero days or whaever hat color exploits news... some swore by things such as ADA, Python or whatever so called safe programming (without they knowing boundary checks are performed in every single lines of memory access). however, this (no boundary check) practice can be intentional by some serious analysts to trade for performance, this is also usually missed by those "safe programming" fanboyz, meh because we can and you cant, anyway.. ignorance is the enemy

[GeorgeOfTheJungle]

That is a kind of poor or lazy programming [...] who wrote that?

Some ignorant git it seems: https://github.com/git/git/commit/40e88b95cdce955059e94d288e8ebdb7d1e9fa88   

[brucehoult]

that is a kind of poor or lazy programming that gave C/C++ a bad name, who wrote that? it expects correctly formatted buf input, otherwise the famous buffer overrun...

That code is unchanged since April 2005.

Opps, my mistake. I didn't look closely and that's actually a snapshot from April 2005. I don't even know where the equivalent code is now.

doesnt mean its a good practice (added/corrected my previous msg) esp to those who dont know what they are doing. will open up opportunity to some interesting exercises for those who are interested (crackers) i dont care its not my business. for this reason, coupled with negative zero days or whaever hat color exploits news... some swore by things such as ADA, Python or whatever so called safe programming (without they knowing boundary checks are performed in every single lines of memory access). however, this (no boundary check) practice can be intentional by some serious analysts to trade for performance, this is also usually missed by those "safe programming" fanboyz, meh because we can and you cant, anyway.. ignorance is the enemy

I don't disagree that it's bad practice. I'd personally write it more safely, even as a q&d prototype, and I'd ask for changes before commit if I was reviewing the code.

The calling parse_commit() code actually gets the length of the input back from read_sha1_file, and then *ignores* it.

I'd change the arguments to parse_commit_date(buffer) so it would be called as parse_commit_date(buffer, limit) (where limit would be earlier calculated as (char*)buffer+size.

And then:

Code: [Select]

static unsigned long parse_commit_date(const char *buf, const char *limit)
{
if (buf > limit-6 || memcmp(buf, "author", 6))
return 0;
while (buf < limit && *buf++ != '\n')
/* nada */;
if (buf > limit-9 || memcmp(buf, "committer", 9))
return 0;
while (buf < limit && *buf++ != '>')
/* nada */;
return parse_time(buf, limit);
}

I'd challenge anyone to notice any speed difference.

But more likely I'd save myself a lot of typing and write it using some auxiliary functions.

[GeorgeOfTheJungle]

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

Code: [Select]

while (*p && *p++ != '\n')
  continue;https://gitlab.com/xk/quickjs/blob/master/quickjs.c?expanded=true&viewer=simple#L26930-26931

=>

Fabrice Bellard:

Code: [Select]

while (condition) continue;
Linus Torvalds:

Code: [Select]

while (condition) /* nada */;
I like both! (And kudos to @Nominal Animal for proposing Torvalds' style above in this thread)

I don't disagree that it's bad practice. I'd personally write it more safely

The rule you guys are trying to apply doesn't apply here. One thing is not to trust anything you've got from somebody/somewhere else (especially the net), => be extra careful, and another thing is not to trust the data you're creating yourself, that's silly! If you know you've put something in a string, you can rest assured it's there unless the computer is broken.

[brucehoult]

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

Code: [Select]

while (*p && *p++ != '\n')
  continue;https://gitlab.com/xk/quickjs/blob/master/quickjs.c?expanded=true&viewer=simple#L26930-26931

Yes, good. Checking for terminating null or limit pointer are pretty much as good as each other.

I don't disagree that it's bad practice. I'd personally write it more safely

The rule you guys are trying to apply doesn't apply here. One thing is not to trust anything you've got from somebody/somewhere else (especially the net), => be extra careful, and another thing is not to trust the data you're creating yourself, that's silly! If you know you've put something in a string, you can rest assured it's there unless the computer is broken.

Or, if the code you yourself wrote to create it is broken. It's good to be defensive.

In the git case it's parsing disk files that are normally created by git, but it's perfectly possible for other software to create them or even to do it by hand -- there are tutorials for that.

[SiliconWizard]

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.

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

Code: [Select]

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

Isn't that much easier to read and not needing any kind of empty statement?

[Mechatrommer]

That is a kind of poor or lazy programming [...] who wrote that?

Some ignorant git it seems: https://github.com/git/git/commit/40e88b95cdce955059e94d288e8ebdb7d1e9fa88   

i kind of know the answer before i asked the question, so dont take it personally, that was a partial joke, its kind of troll feed for "safe program" fanboysm. thats why i said some "serious analysts" did that deliberately, its just the noobs who follows the style can get into problems.

[Nominal Animal]

IMO, proper style is utterly context-dependent.

If it is an existing project, then the style it uses (hopefully consistently) is the proper one.

If you are teaching new programmers, or showing new programmers how to do things, you want to use a style that helps them get the correct intuitive grasp of things.  They will eventually shift away from that initial/learning style, and that's perfectly okay too.

If you write example code for someone coming from another programming language, you can use examples written in their "intuitive" style and an in some other style that is context-appropriate, to help them understand the differences between the languages.  You can even use styles you personally detest here, to positive effect.

So, I really don't see the purpose of comparing styles outside a specific context.

[GeorgeOfTheJungle]

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

That's fine, you can write C your own way . But in my book, Torvalds and Bellard are among the best C programmers in the world.

[Mechatrommer]

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

That's fine, you can write C your own way . But in my book, Torvalds and Bellard are among the best C programmers in the world.

i never interested to have a look at his code before, but to my surprised, he's the first guy i think to use "my" style of coding ie..

Code: [Select]

while() {
  // codes here
}
instead of...

Code: [Select]

while()
{
  // codes here
}

so we must have something in common somewhere (at least we both have 2 eyes) but whats not in common is he still use the "old" style on function name

Code: [Select]

func()
{
  // codes here
}
instead of...

Code: [Select]

func() {
  // codes here
}

so i must be more "uniformed" (consistent) in term of coding style

[legacy]

That's fine, you can write C your own way . But in my book, Torvalds and Bellard are among the best C programmers in the world.

Torvalds?   

[legacy]

serious analysts to trade for performance, this is also usually missed by those "safe programming" fanboyz, meh because we can and you cant, anyway.. ignorance is the enemy

"safe C" aka "avionic C" is mostly a ruleset to facilitate "code instrumentation" for (e.g.) dynamic coverage analysis.  Performance comes into consideration after this, and it's code running not in instrumented mode (it runs in profiling mode), nor in debug mode (under ICE).

[brucehoult]

That's fine, you can write C your own way . But in my book, Torvalds and Bellard are among the best C programmers in the world.

Torvalds?   

Torvalds has prototyped several very influential ideas/projects, but I'd say his main talent is then managing contributions by others.

Fabrice Bellard has done a ton of very cool stuff solo. I mean ... three time winner of the Obfuscated C contest, breaking the record for digits of Pi, FFMPEG, QEMU, and other emulators, such as ones that run in a web browser eg RISC-V Fedora Linux in your browser here:

https://bellard.org/jslinux/vm.html?cpu=riscv64&url=https://bellard.org/jslinux/fedora29-riscv-2.cfg&mem=256

Or, a version with X GUI here (takes longer to start):

https://bellard.org/jslinux/vm.html?cpu=riscv64&url=https://bellard.org/jslinux/fedora29-riscv-xwin.cfg&graphic=1&mem=256


Other candidates for top programmer based on multiple amazing projects include:

Andrew Tridgell: rsync, samba, SourcePuller (the reason indirectly that Torvalds started git lol), huge improvements to ArduPilot.

Julian Seward : bzip2, valgrind

[legacy]

Torvalds has prototyped several very influential ideas/projects, but I'd say his main talent is then managing contributions by others.

Precisely. Torvalds is definitively not good for his code-style(1), and his monolithic kernel is a very bad idea in the long term. But his main talent is managing contributions by others, and his GIT is a very great tool.


(1) last time we analyzed the possibility of certifying Linux for avionics ( and I am talking about DO178B level E, the lowest ), even due to his code-style, it would have cost more money than rewriting it from scratch.

[obiwanjacobi]

Code: [Select]

while() {
  // codes here
}
instead of...

Code: [Select]

while()
{
  // codes here
}


See, if you would use indents (ala Python) you would not be having this discussion in the first place!