CamelCase

WhoTheFuckThoughtThisIsAGoodIdea?

It's an unreadable mess. No real programmer would use that shit.

>>36
No, actually it is better to declare it before the loop, since it won't be redeclared every iteration.

>>28
if I even need words
I hate your kind so so much. You are what makes maintenance of old code so fucking difficult. Please never program for anyone other than yourself. Don't even add your code to open source projects.

>>37
What?!

I am definitely being trolled here. And it's working.

>>38
Declaring it outside the loop saves a constructor call if the copy constructor is declared explicit. Please refer to the C++ FAQ.

>>33
Happen to have one for people who don't like PIG DISGUSTING syntax such as the one you display?

>>37
I lol'd, nice one ;)

>>39
I've been searching the C++ FAQ for a while now, and I can't find something like that. Plus, it's better to keep the iterator only in the scope of the loop since it shouldn't be used anywhere else.

Regardless, even if you were right, it certainly isn't being ``redeclared every iteration'' like >>37-san said.

>>42
Hello! I've noticed that you are using faggot quotes. ^{Please refrain} _{from this practice.}

>>43
``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote''
``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote''
``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote''
``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote''
``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote''
``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote''
``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote''
``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote'' ``Quote''

No thanks, I enjoy my ``proper quotes''.

>>44
IHBT

Code should be understandable to someone reading it for the first time.  No one should have to move to a different file to understand what "db_con_fn" is.  "db" is generally understood to be database, but the rest is terrible.  dbConnectionFile, db_connection_file, databaseConnectionFile, etc. are understood by anyone reading it.  If it isn't completely legible, a comment explaining what it is should be made at the first instance of using it in any function.  For looping, "i,j,k" are understood iterators.  fileName[i] is understood as the current file name in this loop.  If more than one iterator is used, "i,j,k" are fine as long as comments explain what each variable represents.

80 character limits were abandoned many years ago.  Today, people have monitors with over 800x600 resolution.  If you use a program that limits you to 80, you need a new program.  Try any text editor made in the last 20 years.  It should work just fine.

80 character limits are perfectly reasonable and work well with literate programming. If you're having trouble staying under 80 characters:
1) you're using C++ and should pick a decent language
2) you need to refactor
3) your variable names are too descriptive, try commenting some time.

>>47

Rationale: If the code is often incapable of explaining itself, then perhaps it should be written in a more expressive language. This may mean using a different programming language altogether, or, since we are talking about Lisp, it may mean simply building a combinator language or a macro language for the purpose. `Literate programming' is the logical conclusion of languages incapable of explaining themselves; it is a direct concession of the inexpressiveness of the computer language implementing the program, to the extent that the only way a human can understand the program is by having it rewritten in a human language.

>>44
RFEAQGUGIORTE SQ UFOETWEESR

Version 2.0, released under the Noncommercial Creative Commons License.

>>47
Good point, definitely a good point.

Suck this
http://pastebin.com/m175ed6e1

>>51
It's good practice to keep a precise difference between function declaration and function call.

>>6,12
How about NO. I fucking *hate* when editors do this, and most of the new ones do. It's easy to instantly count the number of letters in a subword or identifiers in a line, so I can easily jump wherever with #l and #w in vi; conversely it takes a lot more time to count the subwords + non-identifier symbols. And it takes even longer if you just tap whatever your fucking skip word button is over and over until you get where you want to be.

>>18
Why do people care about line lengths so much? Don't you have monitors from this century? Not one person here has given a good reason for having such incredibly short lines. Honestly now, what is the advantage of a line length 1/3 the width of your screen?

I often break the 120-character limit in sepples, and the 160-character limit on objective-C *shudder*. I greatly prefer to read code that is highly compressed vertically. You've got at least 120 characters per line; why not use 'em?

For example, if I write a one-line (or sometimes even two line) function with obvious behaviour, it is usually compressed entirely on one line (including the declaration and postfix comment via //!<), inline in the class definition (yes for convenience, I don't give a fuck if it's faster or slower or bigger or smaller), and it is grouped together with similar functions without any blank lines (except a blank line above and below the whole block). For this I mean functions with obvious behaviour: trivial accessors/mutators, operator wrappers, very simple constructors, etc. This to me looks very nice, and it's very obvious what is happening. Your eye can skip right over the block if you're not interested in it (instead of scrolling through pages of spaced out garbage), and you still get proper doxygen comments, etc.

In particular I *hate* extra word pollution (typedefs, temporaries, etc) just for the sake of breaking up lines, as in >>29. It makes sense if you're going to use the type/value multiple times, but once? With a temporary you're deliberately breaking apart the logical flow of the program, storing an arbitrary value in a named identifier outside the actual place where it is being used. Even if you buy the argument that it's easier to read (I don't), it certainly makes it harder to understand.

>>47
1) you're using C++ and should pick a decent language
We aren't all working on toy projects; some of us have jobs, and those jobs require us to use certain languages.

>>53
I smell a troll

>>51
Why should I orient my code style around faggots who use ancient terminals?

I agree.

>>55
*homosexuals
*legacy terminals

I just break apart my code base on what it's doing. I keep it under 80 most of the time so I don't piss any one else off.

Well I see character line length limits as like speed limits. I mean only faggots keep it  under 80 on the freeway. real men do 100 no problem, and 120 if the conditions are right.

All I can say to this is lol. This is basically the exact experience that I have had with the post-secondary institutions within the United States. I can honestly say that for the majority that professors and the institution wish to stifle creativity and independent thought. The narrow minded answers they want completely disregard the plethora of other choices that would reveal the correct answer. Whether or not the story is true, this is the attitude of the American educational institute, for those that think outside the box continue to. Revolutionist, non-conventionalist, and the blatant disregard for normalcy are the fundamentals to continuing our species in the area of science.

>>60
Hello FrozenVoid ;)

>>59
EXPERT MAT DICKIE

>>62
Can't be Mat Dickie. Mat Dickie talks about himself a lot and also ends everything he writes with an ellipsis...

>>55
Because sometimes you must work on sucky technologies or communicate with different worlds.

Of course you are the typical windows programmer (or user?) stuck on bullshit sold by microsoft. Your entire world is a PC with microsoft windows, so you continue producing your management accounting software, interfacing it with m$ access and producing code which cannot be handled by anything except your fricken IDE.

If you need to communicate with someone else you have to riduce to the lowest common factor.

Do you guys browse the web by sending a mail to your daemon which will then fetch the page at a later time, too?

>>1
I believe you mean camelCase and whoTheFuckThoughtThisWasAgoodIdea (two capital letters in a row are not allowed)

>>65
Why are you asking?

>>65
Not since 1994. Prior to that I had to do something quite similar much of the time.

rEVERSEcAMELcASEiSsUPERIOR

>>69
that would be /pROG/cASE

>>67
Hmm, I wonder.

“For personal reasons, I do not browse the web from my computer. (I also have not net connection much of the time.) To look at page I send mail to a demon which runs wget and mails the page back to me. It is very efficient use of my time, but it is slow in real time.”
http://stallman.org/small-RMS.png

>>72
Doesn't he still need a web browser to render the returned page?
Or is it ´´very efficient use of [his] time`` to skim through the html manually?

For extra efficiency, maybe he could write a program that takes a URL as input, sends the email, waits for a response, then strips the html and prints it to stdout.

>>73
One word text mode web browser thread over.

>>74
THAT'S STILL A WEB BROWSER

>>73
Why don't you ask him: mailto:rms@gnu.org

>>76
For personal reasons, I do not send email from my computer.  Does he have a web form by which I might submit my questions?

ugg

>>33
This must be why all of you faggots hate C++. You try to fit it all under 80 columns and the result is ass. So you think the language is ass, instead of realizing that 80 columns is ass.

>She is super cute!she so beauty!!!
She is super ugguu~