One-garian Notation
-
That goes about against every .NET guideline there is. Nested classes/enums should NOT be public. They're hard to discover and annoying to use. Move the enum out of the class if it needs to be public. Flag-style enums use plural names while normal enums use singular names. There's no need for any prefix.
-
No no no. Defines and enums in UPPERCASE. Consts and vaars just named properly. 'Name' is obviously a string, 'Count' is a number. and are nouns. And funcitons/methods are verbs. Easy. The code reads like english.
Morality is indistinguishable from social proscription
Seconded.
“Follow your bliss.” – Joseph Campbell
-
Beware all those who read the following, they are the irreverent ramblings of a heretic ... Religious beliefs are so tricky. For the true believer no alternatives can be possible. Their minds are closed. I was once a devout believer of Hungarian notation. Charles Simonyi was my guiding light. My strings were all szDecorated, and I was at peace with the world. But, as with all religions, there were those who would not accept the one true way. Hedonistic forces held sway at Microsoft, and .Net naming conventions repudiated Hungarian notation! I was thrown into confusion, and my world disintegrated around me! Had I been led astray? Were my beliefs really so faulty? All those years, for nothing? And then I noticed something incredibly suspect about the preachings of the anti-Hungarian notationalists. Despite their adamant claim that Hungarian notation was evil, they in reality espoused a corrupted form of Hungarian notation themselves! Yes, it is true, the anti-Hungarian notationalists are inconsistent! They call for the abolition of Hungarian notation, while preaching the following doctrine: - The names of interfaces must start with the letter I. - The names of types must start with the letter T. Why was this? How could they ask me to give up one faith for a new one that contradicted itself? And then one day my turmoil was resolved! In a moment of revelation the great nerd in the sky spoke to me: "Do not follow the preaching of others! Create your own religion, be true to yourself, and say to hell with the forces of conformity. It will be a rocky road, and you will be held in contempt, but you will discover an inner peace that not even Hungarian notation gave you." I call my new religion "one-garian notation". It can be considered to be a further development (or corruption, if you will) of the .Net naming conventions, where not just the names of interfaces and types have specific one-character prefixes, but the following as well: - The names of constants must start with the letter C. - The names of delegates must start with the letter D. - The names of enumerators must start with the letter E. That's it. One-garian notation (named because it is based on one-character prefixes) is the same as .Net naming conventions, plus the use of three additional one-character rules, for a total of
The only notation I adhere to religiously is Reverse Polish Notation. No other method of calculation makes any sense whatsoever unless one is limited to balancing checkbooks.
"A Journey of a Thousand Rest Stops Begins with a Single Movement"
-
Beware all those who read the following, they are the irreverent ramblings of a heretic ... Religious beliefs are so tricky. For the true believer no alternatives can be possible. Their minds are closed. I was once a devout believer of Hungarian notation. Charles Simonyi was my guiding light. My strings were all szDecorated, and I was at peace with the world. But, as with all religions, there were those who would not accept the one true way. Hedonistic forces held sway at Microsoft, and .Net naming conventions repudiated Hungarian notation! I was thrown into confusion, and my world disintegrated around me! Had I been led astray? Were my beliefs really so faulty? All those years, for nothing? And then I noticed something incredibly suspect about the preachings of the anti-Hungarian notationalists. Despite their adamant claim that Hungarian notation was evil, they in reality espoused a corrupted form of Hungarian notation themselves! Yes, it is true, the anti-Hungarian notationalists are inconsistent! They call for the abolition of Hungarian notation, while preaching the following doctrine: - The names of interfaces must start with the letter I. - The names of types must start with the letter T. Why was this? How could they ask me to give up one faith for a new one that contradicted itself? And then one day my turmoil was resolved! In a moment of revelation the great nerd in the sky spoke to me: "Do not follow the preaching of others! Create your own religion, be true to yourself, and say to hell with the forces of conformity. It will be a rocky road, and you will be held in contempt, but you will discover an inner peace that not even Hungarian notation gave you." I call my new religion "one-garian notation". It can be considered to be a further development (or corruption, if you will) of the .Net naming conventions, where not just the names of interfaces and types have specific one-character prefixes, but the following as well: - The names of constants must start with the letter C. - The names of delegates must start with the letter D. - The names of enumerators must start with the letter E. That's it. One-garian notation (named because it is based on one-character prefixes) is the same as .Net naming conventions, plus the use of three additional one-character rules, for a total of
A few months ago, I absent-mindedly started a string with "$". It just felt like the thing to do at the time. Fortunately, I managed to delete it before anyone noticed.
I wanna be a eunuchs developer! Pass me a bread knife!
-
Beware all those who read the following, they are the irreverent ramblings of a heretic ... Religious beliefs are so tricky. For the true believer no alternatives can be possible. Their minds are closed. I was once a devout believer of Hungarian notation. Charles Simonyi was my guiding light. My strings were all szDecorated, and I was at peace with the world. But, as with all religions, there were those who would not accept the one true way. Hedonistic forces held sway at Microsoft, and .Net naming conventions repudiated Hungarian notation! I was thrown into confusion, and my world disintegrated around me! Had I been led astray? Were my beliefs really so faulty? All those years, for nothing? And then I noticed something incredibly suspect about the preachings of the anti-Hungarian notationalists. Despite their adamant claim that Hungarian notation was evil, they in reality espoused a corrupted form of Hungarian notation themselves! Yes, it is true, the anti-Hungarian notationalists are inconsistent! They call for the abolition of Hungarian notation, while preaching the following doctrine: - The names of interfaces must start with the letter I. - The names of types must start with the letter T. Why was this? How could they ask me to give up one faith for a new one that contradicted itself? And then one day my turmoil was resolved! In a moment of revelation the great nerd in the sky spoke to me: "Do not follow the preaching of others! Create your own religion, be true to yourself, and say to hell with the forces of conformity. It will be a rocky road, and you will be held in contempt, but you will discover an inner peace that not even Hungarian notation gave you." I call my new religion "one-garian notation". It can be considered to be a further development (or corruption, if you will) of the .Net naming conventions, where not just the names of interfaces and types have specific one-character prefixes, but the following as well: - The names of constants must start with the letter C. - The names of delegates must start with the letter D. - The names of enumerators must start with the letter E. That's it. One-garian notation (named because it is based on one-character prefixes) is the same as .Net naming conventions, plus the use of three additional one-character rules, for a total of
-
Wow, lots of comments! :) But I'd like to ask if anyone has any opinion regarding my suggesions, which I'm actually quite serious about, despite the humorous tone of my posting? - The names of constants must start with the letter C. - The names of delegates must start with the letter D. - The names of enumerators must start with the letter E. Justifications: - Previous standard for constants was THE_UPPERCASE_SCREAMING style, because constants are different. So I want to still emphasise that constants are different, and adding the C does that. - I often have a delegate declaration that is for a specific method, so it makes sense to use the name of the method with the D added to the front. - The use of enumerators often involves declaring a usage of the enumerator that naturally would have the same name as the enumerator itself, which isn't allowed. So by saying the enumerator name starts with E then the usage can have the same name without the E. Just like with INames for interfaces and TNames for types, these three things are sufficiently different from run-of-the-mill items that I like the idea of giving them special names.
We were just discussing this the other day. I'm old enough to remember why naming conventions were thought important. When you're poring through stacks of paper source code, trying to identify what type of variable this is, or how it's initialized, mistakes are lessened if we all follow a pattern (whatever it is). Those days are long gone. With the advent of useful IDEs (Go to Definition), tracing the name is much more trivial and less error-prone. Now, that's not to say we shouldn't have standards; it's good to have the at-a-glance indication that the thing I'm viewing is a TextBox, or maybe a member variable of this method, or a property. But if we're spending our time chasing down those things instead of the actual problems in logic, we're doing a bad thing.
-
OriginalGriff wrote:
"but" for buttons
But, but, but... why not "btn"? ;P
OriginalGriff wrote:
"tb" in front of text boxes
I use "txt", but "tb" does make perfect sense too.
aspdotnetdev wrote:
I use "txt", but "tb" does make perfect sense too.
Unless you also have a toolbar on your form ;-)
-
Question: what do you call a char *? char * pntrCharArray = "Char Pointer"; CString cstrString;
TopCoder23 wrote:
Question: what do you call a char *? char * pntrCharArray = "Char Pointer"; CString cstrString;
// if the pointer will not be used for any other strings LPCTSTR typeName = _T("Char Pointer") ;
-
Wow, lots of comments! :) But I'd like to ask if anyone has any opinion regarding my suggesions, which I'm actually quite serious about, despite the humorous tone of my posting? - The names of constants must start with the letter C. - The names of delegates must start with the letter D. - The names of enumerators must start with the letter E. Justifications: - Previous standard for constants was THE_UPPERCASE_SCREAMING style, because constants are different. So I want to still emphasise that constants are different, and adding the C does that. - I often have a delegate declaration that is for a specific method, so it makes sense to use the name of the method with the D added to the front. - The use of enumerators often involves declaring a usage of the enumerator that naturally would have the same name as the enumerator itself, which isn't allowed. So by saying the enumerator name starts with E then the usage can have the same name without the E. Just like with INames for interfaces and TNames for types, these three things are sufficiently different from run-of-the-mill items that I like the idea of giving them special names.
Hungarian fails not only because in the world of modern IDEs it has less intrinsic value but it also makes it a pain to maintain code. Before deploying any convention ask if it really adds any value and what pain could it cause in the future? If these conventions make sense for you to adopt then go for it ! I, however, will probably not be following your pioneering lead. At least in the near term.
-
Beware all those who read the following, they are the irreverent ramblings of a heretic ... Religious beliefs are so tricky. For the true believer no alternatives can be possible. Their minds are closed. I was once a devout believer of Hungarian notation. Charles Simonyi was my guiding light. My strings were all szDecorated, and I was at peace with the world. But, as with all religions, there were those who would not accept the one true way. Hedonistic forces held sway at Microsoft, and .Net naming conventions repudiated Hungarian notation! I was thrown into confusion, and my world disintegrated around me! Had I been led astray? Were my beliefs really so faulty? All those years, for nothing? And then I noticed something incredibly suspect about the preachings of the anti-Hungarian notationalists. Despite their adamant claim that Hungarian notation was evil, they in reality espoused a corrupted form of Hungarian notation themselves! Yes, it is true, the anti-Hungarian notationalists are inconsistent! They call for the abolition of Hungarian notation, while preaching the following doctrine: - The names of interfaces must start with the letter I. - The names of types must start with the letter T. Why was this? How could they ask me to give up one faith for a new one that contradicted itself? And then one day my turmoil was resolved! In a moment of revelation the great nerd in the sky spoke to me: "Do not follow the preaching of others! Create your own religion, be true to yourself, and say to hell with the forces of conformity. It will be a rocky road, and you will be held in contempt, but you will discover an inner peace that not even Hungarian notation gave you." I call my new religion "one-garian notation". It can be considered to be a further development (or corruption, if you will) of the .Net naming conventions, where not just the names of interfaces and types have specific one-character prefixes, but the following as well: - The names of constants must start with the letter C. - The names of delegates must start with the letter D. - The names of enumerators must start with the letter E. That's it. One-garian notation (named because it is based on one-character prefixes) is the same as .Net naming conventions, plus the use of three additional one-character rules, for a total of