I never had a problem asking for help with code I didn't understand.

I really wish I hadn't this time...

When looking at some very old code to set the location of a graphical annotation, I ended up talking to one of our senior developers.

The conversation:

"Oh, yeah.  I remember the guy who wrote that. See--here's the thing...He has a very...different style of coding.
I like it, granted, but it's definitely different. I think he was influenced by Pascal.  He likes to flip things
around back and forth until he gets them the way he wants them."

//The code in question
int senseCount = nNintersections + nEdges + nVertexParams;

bool flip = false;

for (int ii=0;  ii!= senseCount; ++ii)
{
    flip = !flip;
}

Doesn't seem so weird to me..  I make use of this paradigm all the time.

int is_neg(long n)
{
    // tells if a number is negative or positive

    for (;;) {
        n++;

        if (n == 0) {
            return 1;
        } else if (n == 2147483647) {
            return 0;
        }
    }
}

long multi_add(int x, int y)
{
    // takes the first number and finds out how much it is
    // added to itself the number of times specified by the second

    long result = 0;

    for(int i = 0; i < y; i++) {
        result += x;
    }

    return result;
}

morbiuswilters:

Satanic code

morbiuswilters:

I have come here to chew memory..

and processor time.. 

ZippoLag:

morbiuswilters:

I have come here to chew memory..

 

and processor time.. 

Are you joking?  is_neg can determine that 5 is positive in less than 10 seconds on my computer.  I'd like to see you now-it-alls do better. 

morbiuswilters:

ZippoLag:

morbiuswilters:

I have come here to chew memory..

 

and processor time.. 

Are you joking?  is_neg can determine that 5 is positive in less than 10 seconds on my computer.  I'd like to see you now-it-alls do better. 

int is_neg(long n)
{
    // tells if a number is negative or positive

    for (;;) {
        n /= 2;

        if (n == 1) {
            return 1;
        } else if (n == -1) {
            return 0;
        }
    }
}

 Stick around, maybe I'll teach you a thing or two about good programming.

bstorer:

Fine, here you go

bstorer:

 Stick around, maybe I'll teach you a thing or two about good programming.

Nice hustle, but is_neg(0) causes my machine to get stuck in an infinite loop.  Better luck next time, rookie. 

morbiuswilters:

bstorer:

 Stick around, maybe I'll teach you a thing or two about good programming.

Nice hustle, but is_neg(0) causes my machine to get stuck in an infinite loop.  Better luck next time, rookie. 

I'm feeling dizzy.. 

bstorer:

You can't figure out if 0 is negative without using a computer?  Pathetic.

Listen, that kind of attitude may pass the mustard in your academic ivory tower.  But here in the real world we have to deal with user data data data.  And part of that means sometimes there are zeroes and you can't use your "elegant" solutions and you just have to Jam it!

morbiuswilters:

bstorer:

You can't figure out if 0 is negative without using a computer?  Pathetic.

Listen, that kind of attitude may pass the mustard in your academic ivory tower.  But here in the real world we have to deal with user data data data.  And part of that means sometimes there are zeroes and you can't use your "elegant" solutions and you just have to Jam it!

int is_neg(long n)
{
    // tells if a number is negative or positive
    int i = 0;
    for (;;) {
        n /= 2;

        if (n == 1) {
            return 1;
        } else if (n == -1) {
            return 0;
        }
	++i;
	if (i == 32)
	  return 1;
    }
}

bstorer:

int i = 0;

What a memory hog.  Hey, I hear there's an opening on the Firefox team -- you might consider joining. 

morbiuswilters:

bstorer:

int i = 0;

What a memory hog.  Hey, I hear there's an opening on the Firefox team -- you might consider joining. 

bstorer:

int is_neg(long n)
{
    // tells if a number is negative or positive
    int i = 0;
    for (;;) {
        n /= 2;

        if (n == 1) {
            return 1;
        } else if (n == -1) {
            return 0;
        }
	++i;
	if (i == 32)
	  return 1;
    }
}

bstorer:

if (i == 32) return 1;

Thanks for the code, I've been using it with great success. I've noticed that large negative numbers are detected as positive numbers though. It seems that the function isn't quite ready for production yet.

Nandurius:

It seems that the function isn't quite ready for production yet.

bstorer:

Nonsense.  All code has been tested and confirmed to work on my production 286.

Unfortunately there's no money for hardware upgrades left in the budget this year.

I managed to fix the issue with large numbers, though, by making multiple passes through the division loop. Since my doubles are twice as long as the standard 32 bit ones, I need at least two passes.. I added another one just to be on the safe side of things.

  static boolean is_neg(long n)
  {
    // tells if a number is negative or positive
    int i = 0;
    int passes = 0;

    for (;;)
    {
      n /= 2;

      if (n == 1)
      {
        return false;
      }
      else if (n == -1)
      {
        return true;
      }
      ++i;
      
      if (i == 32)
        if( passes == 2)
          return true; // return false;
        else {
          passes++;
          i = 0;
        }
    }
  }

Unfortunately there still seems to be an issue with -1, which was returning false. If we redefine 0 to be negative though, and change the last return to true then it works as expected.

Nandurius:

I managed to fix the issue with large numbers, though, by making multiple passes through the division loop.

No, no, no.  Just copy and paste the loop twice, obviously, and reset i to 0.

Nandurius:

Unfortunately there still seems to be an issue with -1, which was returning false.

Simple solution to that, too: just subtract 1 from n before testing it.

Nandurius:

...almost 30 lines of code... 

I swear, today's programmers can't code, even if I hit them on the head with a mallet. Observe, students:

// tells if a number is negative or positive 

static boolean is_neg(long n) {

	for (; n != 0; n /= 2) if (n == -1) return true; return false;

} 

There, just one line, doesn't waste memory for extra variables and correctly handles "0" and "-1".

use threads;

sub universe
{
	my ($number, $direction) = @_;
	while ($number) { $number += $direction; }
	threads->exit();
}

sub is_neg
{
	my $number = shift;
	my $positive_universe = threads->create('universe', $number, 1);
	my $negative_universe = threads->create('universe', $number, -1);
	while (1)
	{
		if (not $positive_universe->is_running())
		{
			$negative_universe->kill('DESTROY');
			return 0;
		}
		if (not $negative_universe->is_running())
		{
			$positive_universe->kill('DESTROY');
			return 1;
		}
	}
}

for (; n != 0; n /= 2)

This is far too complicated for maintainance programmers to understand. What's wrong with do ... while (n /= 2)?

And using an int returning values of 1 and 0 would save a whole load of characters. Really, I don't know how your company can afford to retain people like you who insist on filling up the punched cards with all this verbosity.

Iago:

for (; n != 0; n /= 2)

This is far too complicated for maintainance programmers to understand. What's wrong with do ... while (n /= 2)?

How about...

for(; n; n >>= 1)

Regarding the original post: I know it's just a question of personal taste, but I really dislike when people use ++x instead of x++ in cases where there is no difference between the two (e.g. here in the third part of the 'for' clause). I don't know why, bust I just feel it's plain wrong. Yes, I know it doesn't make any difference, but still, it just looks wrong. Any opinions?

 Edit: Oh yes, sorry, that was a signed integer. Never mind the bit shift then.

DrJokepu:

I know it's just a question of personal taste, but I really dislike when people use ++x instead of x++ in cases where there is no difference between the two (e.g. here in the third part of the 'for' clause). I don't know why, bust I just feel it's plain wrong. Yes, I know it doesn't make any difference, but still, it just looks wrong.

Technically, it is wrong.  x++ creates a temporary variable to store the return value.  Now, most compilers are smart enough to convert it to ++x on the fly, but that doesn't make it right.  Off the top of my head I cannot conceive of a single time when x++ is superior.  A construct like n = ++x is no more expressive -- really, it's actually more muddled -- and less efficient than doing n = x; ++x;

bstorer:

A construct like n = ++x is no more expressive -- really, it's actually more muddled -- and less efficient than doing n = x; ++x;

Now I am far from being a C expert, but isn't n = ++x is more like x = x + 1; n = x; instead of n = x; ++x;? Note the difference between the final values of n.

DrJokepu:

bstorer:

A construct like n = ++x is no more expressive -- really, it's actually more muddled -- and less efficient than doing n = x; ++x;

Now I am far from being a C expert, but isn't n = ++x is more like x = x + 1; n = x; instead of n = x; ++x;? Note the difference between the final values of n.

bstorer:

DrJokepu:

I know it's just a question of personal taste, but I really dislike when people use ++x instead of x++ in cases where there is no difference between the two (e.g. here in the third part of the 'for' clause). I don't know why, bust I just feel it's plain wrong. Yes, I know it doesn't make any difference, but still, it just looks wrong.

Technically, it is wrong.  x++ creates a temporary variable to store the return value. 

 And in C++, when x is an object with overloaded preincrement and postincrement operators, there can be a massive difference in efficiency. The preincrement can just increment the object and return it. The postincrement must copy the object (i.e. create a new one using the copy-constructor), then increment the original and return the copy. That's why people should write ++iterator instead of iterator++. 

mxsscott:

And in C++, when x is an object with overloaded preincrement and postincrement operators, there can be a massive difference in efficiency. The preincrement can just increment the object and return it. The postincrement must copy the object (i.e. create a new one using the copy-constructor), then increment the original and return the copy. That's why people should write ++iterator instead of iterator++.

Or, um, avoid operator overloading altogether. 

morbiuswilters:

mxsscott:

And in C++, when x is an object with overloaded preincrement and postincrement operators, there can be a massive difference in efficiency. The preincrement can just increment the object and return it. The postincrement must copy the object (i.e. create a new one using the copy-constructor), then increment the original and return the copy. That's why people should write ++iterator instead of iterator++.

Or, um, avoid operator overloading altogether. 

bstorer:

morbiuswilters:

mxsscott:

And in C++, when x is an object with overloaded preincrement and postincrement operators, there can be a massive difference in efficiency. The preincrement can just increment the object and return it. The postincrement must copy the object (i.e. create a new one using the copy-constructor), then increment the original and return the copy. That's why people should write ++iterator instead of iterator++.

Or, um, avoid operator overloading altogether. 

Or, um, avoid C++ altogether.

But then there would be no WTFs! 

mxsscott:

But then there would be no WTFs!

mxsscott:

But then there would be no WTFs! 

bstorer:

Technically, it is wrong.  x++ creates a temporary variable to store the return value.  Now, most compilers are smart enough to convert it to ++x on the fly, but that doesn't make it right.

You may be a smart programmer, but you have a lot to learn about programming.  Do all of your fancy books teach you a damn thing about relating to your variables as people?  You see creating a temporary variable as wasteful, I see a variable who is going through a scary change and who might appreciate a friend.  Remember the story of Variable Jesus who allowed his own destructor to be called so that all other variables might have everlasting scope.

ender:

Why would C++ be necessary for WTFs?

C++ doesn't create WTFs, it only attracts them.  The hope is that one day the C++ spec becomes so massive that all WTFs are contained therein and it can then be nuked from orbit. 

bstorer:

Nice hustle, but is_neg(0) causes my machine to get stuck in an infinite loop.  Better luck next time, rookie

here's a fix

int is_neg(long n)
{
    // tells if a number is negative or positive
    if (n == 0) return FILE_NOT_FOUND;
    for (;;) {
        n /= 2;

        if (n == 1) {
            return 1;
        } else if (n == -1) {
            return 0;
        }
    }
}

piptheGeek:

bstorer:

Nice hustle, but is_neg(0) causes my machine to get stuck in an infinite loop.  Better luck next time, rookie

 

learn2quote

That said, your program fails because I always #define FILE_NOT_FOUND to 1 in all of my C headers.  Obviously, is_neg should not return 1 for 0. 

morbiuswilters:

You see creating a temporary variable as wasteful, I see a variable who is going through a scary change and who might appreciate a friend.  Remember the story of Variable Jesus who allowed his own destructor to be called so that all other variables might have everlasting scope.

DrJokepu:

Regarding the original post: I know it's just a question of personal taste, but I really dislike when people use ++x instead of x++ in cases where there is no difference between the two (e.g. here in the third part of the 'for' clause). I don't know why, bust I just feel it's plain wrong. Yes, I know it doesn't make any difference, but still, it just looks wrong. Any opinions?

whats wring with using inline asm instruction - inc? 

Helix:

 

whats wring with using inline asm instruction - inc? 

Mo6eB:

Nandurius:

...almost 30 lines of code... 

I swear, today's programmers can't code, even if I hit them on the head with a mallet. Observe, students:

// tells if a number is negative or positive 

static boolean is_neg(long n) {

	for (; n != 0; n /= 2) if (n == -1) return true; return false;

} 

There, just one line, doesn't waste memory for extra variables and correctly handles "0" and "-1".

This is actually two lines of code so time to learn a little known programming fact "the more lines of code the more expensive it is to maintain".

Additionaly this example shows javas waste of processor cycles, after your byte code has been interpreted, mine is executed without any loops or maths:

int is_neg(long n) {return((n&0x80000000)>>31);} 

Just an AND and SHR on intel

//using 72 as test case

//Arm7TDMI core

bstores solution cycle count = 234

helix solution cycle count = 2

 ~100 times faster code without changing tools

Helix:

 ~100 times faster code without changing tools

I'm not sure you're getting what's going on here... 

upsidedowncreature:

Helix:

 ~100 times faster code without changing tools

 

I'm not sure you're getting what's going on here... 

And my worry is, if you're not getting that everyone is producing inefficient solutions on purpose, that you didn't write:

bool is_neg(long x) { return (x < 0); }

which works for any size of long.

upsidedowncreature:

Helix:

 ~100 times faster code without changing tools

 

I'm not sure you're getting what's going on here... 

I think the original writer of the flipping code deserves a job flipping burgers. 

this cirtainly does not compile any flatter - worse depending on tool.  Also bool is not suggested for use due to vendors c standard implimentation - i prefer to stick with  ISO/IEC 9899:1990 Programming Languages C standard, changed by Amendment 1:1995, Technical corrigendum 1:1994, and Technical corrigendum 2:1996.  That way there is no problems with code migration.

Helix:

whats wring with using inline asm instruction - inc?

Helix:

This is actually two lines of code so time to learn a little known programming fact "the more lines of code the more expensive it is to maintain".

Additionaly this example shows javas waste of processor cycles, after your byte code has been interpreted, mine is executed without any loops or maths:

 

int is_neg(long n) {return((n&0x80000000)>>31);} 

 

Just an AND and SHR on intel

Helix:

That way there is no problems with code migration.

*cough* 

I suggest you try bool is_neg(long x) { return (x < 0); } and  int is_neg(long n) {return((n&0x80000000)>>31);}  in multiple c compilers and archs and let me know the results of processor time and code portability.

The trouble is these days too many posters on TDWTF forums do not run real 'down to the metal code' and just run queries on databases - a bit like the receptionist at the doctors.   

Helix:

this cirtainly does not compile any flatter - worse depending on tool.  Also bool is not suggested for use due to vendors c standard implimentation - i prefer to stick with  ISO/IEC 9899:1990 Programming Languages C standard, changed by Amendment 1:1995, Technical corrigendum 1:1994, and Technical corrigendum 2:1996.  That way there is no problems with code migration.

I was using C++, so bool is fine to use. Agreed that int is better for x-compiler compatibilty with C.

However, it's time for compilation wars:

return (n < 0) compiles as:

0x00001df9  <+0015>  shr    $0x1f,%eax

return (0x8000000 & n) >> 31 compiles as:

0x00001e0d  <+0015>  and    $0x8000000,%eax
0x00001e12  <+0020>  sar    $0x1f,%eax 

This, with gcc 4.0.1 (Xcode 3 on an Intel Mac).

Helix:

I suggest you try bool is_neg(long x) { return (x < 0); } and  int is_neg(long n) {return((n&0x80000000)>>31);}  in multiple c compilers and archs and let me know the results of processor time and code portability.

Are you a complete dumbass or what?  Not only did you somehow miss that this whole thread was a joke, but you took the assignment seriously and actually wrote a function that checks if a number is negative.  I'll let your contradictory, babbling quotes on portability speak for themselves.

Helix:

The trouble is these days too many posters on TDWTF forums do not run real 'down to the metal code' and just run queries on databases - a bit like the receptionist at the doctors.

Apparently that's the only way to keep your sanity.