Triple Tech posted:

Often, the source of these horrors is someone trying to do something brilliant, even proper, but not knowing or having a succint/correct way of expressing it.

Ryouga Inverse posted:

No, Duff's Device is brilliant in every way.

MrMoo posted:

The performance can actually be terrible as the increment is quite expensive, I found this out with a basic vector add & multiply. Array offsets work better ([n+1], [n+2], ...).

MrMoo posted:

The array offsets are free on Intel processors.

Victor posted:

Clearly the input should be s and the output should be ret.

Victor posted:

I reserve r for Regex instances.

shopvac4christ posted:

An enumeration I found, the values of which are used in a database table.

code:

    public enum FooType 
    {
        Foo = 0,
        Bar = 1,
        Baz = 3,
        Bip = 5,
        Bob = 10,
        Jam = 20
    }

They tried to come up with numbers that they could add together for a combination of options.

argolithm posted:

But... well:

code:

for(int i = 0; !false && i < word.length(); i++)

This appeared from a class-mate in my data structures class. The constant call of length() isn't a problem at all-- that's insignificant enough to let people do it, I don't care about that.

tef posted:

Here is a bit of a security coding horror:

6174 posted:

What I find interesting from that links.org post is a lot of people are railing on Debian for not contributing the patch upstream, or at least asking upstream if it was an issue. Yet in the comments there is a link to a openssl-dev thread (http://marc.info/?t=114651088900003&r=1&w=2) where they did precisely that and no one mentioned it was a bad idea, and one of the responders, Ulf Möller (listed as a dev team member on http://openssl.org/about/) said he was in favor of removing the calls. Seems to me that at least some of the blame for this should be on OpenSSL.

MrMoo posted:

Well don't these operators map into the extra math symbols, we have =, ≡, and ≣, so you could have === (≡) as data equality, and ==== (≣) for class equality.

I don't have a degree in maths, when would you use "identical to" === (≡) and "strictly equivalent to" ==== (≣)? I just found this for possible usage in OOP:

http://weblog.raganwald.com/2008/04/is-strictly-equivalent-to.html

Scaevolus posted:

I bet he means an APL keyboard.

Additional characters:

\ _ ¨ ¯ × ÷ ← ↑ → ↓ ∆ ∇ ∘ ∣ ∧ ∨
∩ ∪ ∼ ≠ ≤ ≥ ≬ ⊂ ⊃ ⌈ ⌊ ⊤ ⊥ ⋆ ⌶ ⌷
⌸ ⌹ ⌺ ⌻ ⌼ ⌽ ⌾ ⌿ ⍀ ⍁ ⍂ ⍃ ⍄ ⍅ ⍆ ⍇
⍈ ⍉ ⍊ ⍋ ⍌ ⍍ ⍎ ⍏ ⍐ ⍑ ⍒ ⍓ ⍔ ⍕ ⍖ ⍗
⍘ ⍙ ⍚ ⍛ ⍜ ⍝ ⍞ ⍟ ⍠ ⍡ ⍢ ⍣ ⍤ ⍥ ⍦ ⍧
⍨ ⍩ ⍪ ⍫ ⍬ ⍭ ⍮ ⍯ ⍰ ⍱ ⍲ ⍳ ⍴ ⍵ ⍶ ⍷
⍸ ⍹ ⍺ ⎕ ○

Let's stick to ASCII.

deimos posted:

Python would like a word with you.

That Turkey Story posted:

Whoa, whoa, backup. Are you saying Java isn't a lovely language?

Evis posted:

That's pretty cool. I take it that it would have to be a type conversion or something? Could you post an example?

Mr. Herlihy posted:

System.String is sealed in the .NET Framework.

fansipans posted:

Ugh... why is this page taking forever to load?!?!?


Click here for the full 800x587 image.

oh ..... dammit.

JediGandalf posted:

Probably not exactly hungarian notation but it's along the same lines. I present you our old table and column naming scheme.

code:

select
	c.brand, c.caffeineContent
from
	tblCoffee c with(nolock)
join
	tblCoffeeType ct with(nolock)
	on c.fkCoffeeTypeId = ct.pkCoffeeTypeId
where
	ct.pkCoffeeTypeId = 5 --Decaf

My current lead engineer hates this style. I agree with him. For foreign keys I think [TableName]ID is good enough.

Edit: Missing code tag.

ashgromnies posted:

code:

$color = 'bgcolor="#F' . ($n++ % 2 ? "C9" : "") . '"';

Who wants to go golfing?

BigRedDot posted:

Seriously, what is attempting to iterate past the end of a sequence, if not an exceptional circumstance?

Flobbster posted:

the Java compiler is smart enough (that's a phrase you don't hear too often!)

Painless posted:

GCJ Can't Java

beuges posted:

Painless posted:

Yesterday, I was asked "do you know why this crashes?" based on an "application has done terrible things and must die" dialog. I looked at the source, and it looked like this:

code:

int main( void )
{
  #include "initstuff.h"
  //#include "dostuff1.h"
  //#include "dostuff2.h"
  //#include "dostuff3.h"
  #include "dostuff4.h"
  //#include "dostuff5.h"
  //you get the idea, repeat about 50 commented dostuffxx.hs
  #include "shutdown.h"
}

I pressed "debug" and noticed that the main function overflowed the stack. Turns out, the dostuffxy.h that was not commented allocated some enormous arrays on stack. I "fixed" the problem by increasing the initial thread stack reserve size and wept silently.

weaaddar posted:

I suppose my thread here: http://forums.somethingawful.com/showthread.php?threadid=3061838
Deserves an honorable mention.

To get around the strict typing of C# and to have flexible functions I have to basically work in lowest common denominator (func<object,object> & object) to implement the basics of church numerals.

Here is a sample of some of the "pretty code"

code:

			Func<object, object> PredForSub = (Func<object, object>)(n =>
				Car((ConsPair<Func<object, object>>)Apply((Func<object, object>)n)(z =>
					Cons(Cadr((ConsPair<Func<object, object>>)z),
						Cons(Succ(Cadr((ConsPair<Func<object, object>>)z)), null)))
							(Cons(ChurchZero, Cons(ChurchZero, null)))));

tripwire posted:

There is no god

McGlockenshire posted:

code:

(int)60D

What?

No, really, my Java is rusty, and I have no idea what in the flying hell this means or is doing. He's casting "60D" to an int. But what the hell is 60D? A constant? I didn't think any sane programming language let you start constants with numbers, though that would also explain the "22D"... and that scares me.

Did this guy learn to code in BASICA, and just never got over insane variables?

McGlockenshire posted:

But... if it's being created as a double, why is he immediately casting it to an int? And since when have primitive non-decimal numbers been anything but ints? This assumes that the coder thought of this. This code makes my head hurt.

UberJumper posted:

Sigh, is there a better way to do this? I cant stop it from destroying this page.

Mill Town posted:

Right, but the class still needs to be defined somewhere. Can you do that with reflection, too? I'd like to know! (I like reflection)

j4cbo posted:

For what it's worth, even C isn't Turing complete...

rjmccall posted:

C is Turing-complete. Turing-completeness does not require that an unbounded amount of memory be simultaneously addressable; after all, that is not true of Turing machines themselves.

rjmccall posted:

Unbounded, not infinite. If you formalize C as running on a theoretical machine with finite memory, then yes, your statement is correct; but if you formalize it as running on a machine with the full capabilities of, say, an IBM PC AT, then its space is theoretically unbounded, because if it runs out of space locally it can pause execution and say "Insert a new disk in drive A:".

TheSpook posted:

After five minutes of trying to remember lambda calculus . . . can you explain this?

Lexical Unit posted:

That was surely their intention, but w/o use strict the bare text false becomes a string literal which evaluates to true

Shaggar posted:

any language that starts with p is terrible.

Janin posted:

our VCS doesn't have atomic commits, so any bug fixes are an all-or-nothing affair