Variable names, their types and choice of language – a 5 day experiment
TL;DR
- You have to have knowledge of your types, either through tools or through syntax.
- Have different naming conventions for different languages.
- A strongly typed compiled language can have any naming convention but a weekly typed should have the types integrated in the variable names.
LONGER
Should one use Hungarian notation (sName, oCustomer), type suffixing (nameString, customerObject) or leave out the type (name, customer). The Rulez have come full circle and we are now back at keeping it simple so name and customer is what we write in coding standards nowadays. I am a die hard fan of compiled and strongly typed languages and I really don’t care. My compiler, my IDE and my plugin take care of finding misspellings and type mismatches.
But…
In my head I couldn’t get the simplest, and as I see it most modern naming convention (name, customer), to work together with the weekly typed javascript language. Keeping track of types in javascript is a problem and if one doesn’t get any help from the variable names – how does one do?
So I set out on a 5 day experiment.
I wrote some real production code with Aspnet Webforms, Knockout, Underscore, Jquery, Ajax and Web services returning Json.
I chose to name variables and methods in their simplest form.
1 | updateCustomers( customers ) |
which iterates and calls
1 | updateCustomer( customer ) |
and returns a bool if everything worked as expected.
My conclusion is that this is a bad idea.
I spent way too much time debugging and tracing the-object-property-having an-array-of-another-object-type and whether the final property had a plural “s” or not. The example is not contrived; I had a view model object containing an object which contained a list of Customers which contained properties, or a property which was a list.
To add insult to injury – Knockout was involved so I had to trace through method calls which made the debugging even more tedious. (don’t get me wrong – Knockout still does it’s work properly – it is my own objects and their relations and above all naming that trips me)
After this real world experiment I now have a case for having the type in the identifier names.
1 | bUpdateCustomers( aCustomer ) |
which iterates the the parameter and calls
1 | bUpdateCustomer( oCustomer ) |
I am not saying hungarian notation is better than suffixing the type but it makes for shorter names. Which makes for less possibility to mistype.
[ before gong berserk on Hungarian notation – please check into the difference between System and Apps. ]
Tags: compiler, hungarian notation, naming convention, strongly typed language, weekly typed language