What annoys you

What annoys you the most to see in someones code?
What annoys you the msot in a programming language?
Mention all the programming related annoyances.

- Shitty English
- Shitty coding style
- Shitty shit
- Shit

- Python.
- Forced indentation of code.

Oh, and people prematurely declaring threads are over.  Thread over.

Anyone stop to wonder why we act like idiots or repeat meaningless memes?


for(int i=0;i<CONST+5;i++){
   dosomething(param,param2,param3);
}

Over (ab)using Singeltons and only argumenting with "it's convenient"

>>1
What annoys you the most to see in someones code?
- Lack of indentation.
- Lack of or wrong whitespace. if( x==3 ) should be if (x == 3) , and f (x) should be f(x).
- Stupidity, which "web designers" are a great source of, such as (PHP, quoting with braces) { "" . (int) $a . "" } or { if (empty($a) == 1) }.
- Stupid overstructuring/overengineering/overgeneralization/stupid shit from stupid Java programmers, such as a function which just wraps another in case the other could change in the future and all that shit which you shouldn't ever need to do if your language has proper namespaces/module support anyways.
- shitCase. Use either CamelCase or lazy_case, but not shitCase. Don't come with that verbs in lowercase bullshit, a one-word shitCased name looks like a lowercased name which may be used for a different thing or type.
- Non-K&R braces.

What annoys you the msot in a programming language?
- Insane syntax full of "(Q#/%/289)=("#%/)="(/. Regexes are cool; I'm concerned about shitty sintax outside regex. Being able to omit parens when calling a function annoys me beyond measure. And of course Perl is the best example.
- new PrintWriter(new BufferedOutputWriter(new AnnoyanceDecorator(new MessageWriter(JavaIsADoucheBag.getInstance().withShittyCaseToo())))
- Lack of proper Unicode support. Almost no language/implementation has proper Unicode support for my definition of proper. My definition of proper means there's ONLY Unicode, no shitty conversions occur behind the scenes, there's a collating comparison function that uses the Unicode Collation Algorithm ONLY, ALL the fucking characters are properly supported and handled (included those outside the BMP), etc.
- Lack of first-class functions and closures, this makes programming boring
- Lack of proper string and list management, this makes programming shitty
- Wasting my time defining types
- Shitty automatic type conversions "1" + 1 == 2 && "0" == 0 && "" == 0 && "0" != "" OH SHI- . These are considered great features by "designers".
- Braindead features which make it easy for idiots (esp. "designers") to write code that's a piece of shit, insecure, and frequently both.

I don't see what's so good about K&R braces. I prefer this style, it's much clearer:

while(x<=>y)
{
    x /= y;
    y = modify(y);
    if (y<0)
    {
        x = x + y;
    }
}

>>What annoys you the most to see in someones code?

- imperative code

>>What annoys you the msot in a programming language?

- lack of powerful type system.
- OOP
- curly braces & semicolons. THIS ISN'T 1950 ANYMORE!

>>5
Because it's funny, faggot.

>>10
Python fag

Non-Haskell languages.

>>9
It hurts the eyes, it does. Also, why the fuck do you have a space after if but not after while?

What annoys you the most to see in someones code?
- Inconsistent whitespacing (see >>9).
- Unnecessary "clarifications", such as if (x == false) instead of just fucking writing if (!x); but the most annoying of all in this category are people who eliminate pre- or post-increments from code because they're "confusing". I want to kill these people.
- Incomplete use of constants, i.e. defining LOOPCOUNT=5, then using it some places and just using 5 elsewhere. Then the program segfaults when you change LOOPCOUNT.
- Hungarian notation.
- Mixed use of tabs and spaces. Actually scratch that, just "tabs" in general annoy me. As far as I'm concerned, tabs should be abolished.

What annoys you the msot in a programming language?
- Unenforced file naming scheme. I fucking *hate* having to grep "class Class" *|less just to find which goddamn cpp file a class is in. This is one of the few things Java did right. I don't care if a helper class has 6 lines, put it in its own fucking file.

I could add like 50 things here about Fortran, since I'm in science and have to use it for a lot of things. But it's not worth it.

Add to this pretty much everything >>8 said, except the complaint about shitCase. Class/Struct declarations should be in CamelCase, variable names and function names in shitCase, and #defines and enumerations in ALL_CAPS. This is above all consistent, and immediately tells you what a thing is just by looking at it. Note also that nothing uses strict lowercase or lazy_case, so there is no ambiguity in one word variables or functions.

whatsThis() ? Why that's a function.
WHATS_THIS ? Why that's a constant (either #define or enum)
whatsThis ? Why that's a variable.
WhatsThis ? Why that's a class or struct.
intWhatsThis ? Why that's a Visual Basic Programmer.

I find this notation gives the nicest looking code:

Box* box;
Ball::Ball(Box* box) {
    this->box = box;
    box->addBall(this);
}

Prefixing member variables with an underscore.

>>8
s/sintax/syntax/and_kill_me(with_fire) #new in Perl 6

>>9
How's that cleeaner? If anything, it's less clean, because you don't see as clearly how a loop starts (the next line is indented at the same position as the while), and you're wasting one line per loop, minimizing the amount of code you can see without scrolling.

Also, you fail at spacing.

>>13
Lol

>>14
Unnecessary "clarifications", such as if (x == false) ... people who eliminate pre- or post-increments from code because they're "confusing"
Ah, web designers!

Hungarian notation
I forgot Hungarian notation! It's pretty fucking annoying.

Fortran, since I'm in science and have to use it for a lot of things
SCCCCIIIIIIEEEEEEEEENNNNNNNNNCNCCCCCCCCCCCE!!!!!!!!

variable names and function names in shitCase
whatsThis() ? Why that's a function.
whatsThis ? Why that's a variable.
That's because you are using a language that fails badly. Let me explain:

Why do you make a difference between variables, functions, classes and structs? All should be objects bound to variables. (Structs are normal objects or dictionaries, not much different from value 3 or value "hello".) Then you have certain variables bound to objects which happen to be applicable, such as functions and classes (classes return new objects when applied). Sometimes, you apply applicable objects, such as f(). Other times, you store them somewhere, pass them to somebody, etc., like g(f) (where g would be an applicable object which, at some point, applies an applicable object f). Since applicable objects are objects, but they have an important property for functional programming, I want to tell them apart from other objects, so I name applicable objects with CamelCase, and non-applicable objects with lower_case. If I used shitCase for applicable objects which I don't call "classes", I would have trouble telling whether lol is applicable or not. (Yes, I'm a Python fag, a Scheme wanker, and a dynamic language weenie.)

>>7
I'd change your statement to "Using singletons".

>>16
Why do you make a difference between variables, functions, classes and structs?

Because I am not the computer. I am the programmer. Yes, I can assign functions to variables, and to name a function pointer I would use shitCase; this reminds me of the fact that it's not a hardcoded function, but it's something that is modified during runtime.

I make a visible difference between these things for the same reason you format ANYTHING in your code. Why do you use whitespace? The computer doesn't care how your code is formatted... but you do. It helps you debug and maintain your code.

Even if your language allows you to do exotic things like change hardcoded classes or functions at runtime, you still should make a distinction between those you will change at runtime and those you won't.

If I used shitCase for applicable objects which I don't call "classes", I would have trouble telling whether lol is applicable or not.
The reason for this ambiguity is just because you use lower_case. lower_case and camelCase are mutually exclusive because of the ambiguity with single words.

lower_case fucking SUCKS. It's hard to type, hard to read, and generally makes code look shit ugly. Try using shitCase instead of lower_case.

Really, I wouldn't so much mind your naming scheme if you used shitCase wherever you currently use lower_case. As long as it's consistent and doesn't use fucking underscores (aside from #define and const of course, because underscores work quite well in ALL_CAPS).

>>18
trolling is better if you're not quite so obvious about it.

lack of proper abstractions (esp. lack of closures) for no reason at all except "it would make the language more simple". Dumbing down languages may be ok for languages like KPL but please, stop there. Java fucking sucks.

>>6 pretty much summed it all.

to name a function pointer I would use shitCase; this reminds me of the fact that it's not a hardcoded function, but it's something that is modified during runtime.
I don't think this difference is big enough to deserve a different naming convention, but it's a matter of style.

I make a visible difference between these things for the same reason you format ANYTHING in your code. Why do you use whitespace? The computer doesn't care how your code is formatted... but you do. It helps you debug and maintain your code.
Good point, but it's a matter of style. If you prefer so much differentiation, why not use Hungarian notation?

Even if your language allows you to do exotic things like change hardcoded classes or functions at runtime, you still should make a distinction between those you will change at runtime and those you won't.
Why? I'm not saying I shouldn't, just asking why. I never thought objects being created at run-time are so different from objects created at write-time. Think of it as the difference between i = 2 and i = 1 + 1.

The reason for this ambiguity is just because you use lower_case. lower_case and camelCase are mutually exclusive because of the ambiguity with single words.
I use lower_case, CamelCase and UPPER_CASE, which are perfectly compatible (since I don't declare UPPER_CASE constants only one character long).

lower_case fucking SUCKS. It's hard to type, hard to read, and generally makes code look shit ugly.
I think exactly that of shitCase, not lower_case.

Also, if you're annoyed by underscores, edit your keyboard layout to add them to an unshifted key. Or use Lisp; you can use just a minus sign in lisp.

It annoys me that I have to explicitly tell SQL which column I want to retrieve when I've just JOIN'd them on equality.

e.g. This isn't valid:

select prikey from A join B on A.prikey = B.prikey

I have to use this instead:

select A.prikey from A join B on A.prikey = B.prikey

or this:

select B.prikey from A join B on A.prikey = B.prikey

But they're exactly the same!

SQL is retarded. I don't get why someone somewhere hasn't made something better yet

>>23
Haven't you heard of XQuery?
I access all my databases with XQuery because it is... you know XML!

I have and it's ENTERPRISE

http://vidxite.com

>>24
Is it Touring-complete though?

>>27
No.

>>21
Why? I'm not saying I shouldn't, just asking why. I never thought objects being created at run-time are so different from objects created at write-time.
I guess I don't really have a good answer to that. Personal preference I guess.

Regarding Hungarian notation, it detracts from the readability and maintainability of the code far more than it adds to it; it's usually obvious from the context what type something is, and Hungarian notation breaks down with polymorphism in OO languages anyway. That's why I don't use it.

>> The reason for this ambiguity is just because you use lower_case. lower_case and camelCase are mutually exclusive because of the ambiguity with single words.
I use lower_case, CamelCase and UPPER_CASE, which are perfectly compatible (since I don't declare UPPER_CASE constants only one character long).
Oops, that should read lower_case and shitCase are mutually exclusive. Obviously lower_case and CamelCase are not mutually exclusive.

I like shitCase and CamelCase because they look very similar, but the capitalization of the first letter is very obvious. Suppose I have a multi-word class, like MultiWordObject. I might declare a pointer it like so:

MultiWordObject* multiWordObject;

To me that looks a lot more consistent than:

MultiWordObject* multi_word_object;

In your coding style, where you don't make a clear distinction between variables and classes, you can't even use the same name for the class and the instance of it.

really pisses me off is BLEH NLAH FORCED INDENTION, I wish that faggot would fuck off.

>>29
Regarding Hungarian notation [...] it's usually obvious
My view on this matter is that if the type of the object a variable is bound to is not evident, you need a better name for the variable.

MultiWordObject* multiWordObject;
To me that looks a lot more consistent than:
MultiWordObject* multi_word_object;
Indeed, but I'd have named them like:

MultiWord *obj;
(obj is fine for a short function related exclusively to a MultiWorld, but obj should get a better name in all other cases)

In your coding style, where you don't make a clear distinction between variables and classes, you can't even use the same name for the class and the instance of it.
Indeed, but I don't do that; I reserve the big important type-defining names for classes.

I would do:

MultiWordObject* mwo;

As it's less typing later on when I need to use it, and it looks nicer anyway.

MultiWordObject* MWOobject;
MWOobect = new MultiWordObject;
mWObjeect dl

LISP

Don't change these.

Name:		Email:
Entire Thread Thread List