I'm interested in finding out what people's experiences with standard usernames is. I've always been in places that used {firstInitial}{lastname} (sometimes with a length-limit). Now I've users that want {firstname}.{lastname} - and now it comes up that the period may cause problems.
Specifically:
- What is the best username length limit to use to maintain compatibility across all uses?
- What characters should be avoided?
UPDATE: The reason I didn't mention specifics is that I wanted to be general enough to handle anything that might come up in the future. However, that may be too general of a requirement (anything can happen, right?).
This is our environment: Ubuntu Server Lucid Lynx 10.04 LTS, Red Hat Enterprise Linux 5.6 and up, Windows Server 2003 and Windows 2000 Server (with Active Directory in Windows 2000 Native Mode), Zimbra 7.x for mail, and OpenLDAP in the near future.
UPDATE: I should mention (for completeness) that I saw this question (though it didn't answer my asked question) and also this web post, both of which were very informative.
This is a chronic problem with large Identity Management systems attempting to glue together heterogeneous systems. Invariably, you'll be limited to the lowest common denominator, which all too often is an 8-character ASCII-alpha-numeric limit thanks to some (probably legacy) Unix-like system somewhere in the bowels of the datacenter. Those fancy modern systems can take arbitrary length UTF8 usernames are unlikely to get used.
I spent 7 years at an institution of higher education where we had to figure out 8-character usernames for 5000 new students every year. We had managed to come up with unique names for 15 years of students by the time I left. This can be done, Mr. smitj510
Things that will make your life immeasurably easier:
firstname.lastnameor anything else that might come up.Which is to say, treat it like a databasing problem because that's what it is. Pick a primary key for maximum compatibility with your systems (likely 8 characters), build a lookup-table to allow systems to translate local ID's to the primary key, and engineer your data synchronization systems to handle various IDs.
Your questions specifically:
There's no such thing. There's only "your" uses, which may include your future uses. We have no idea what those are.
This will depend on what computer systems you're dealing with. Windows, for example, has no problems with a period in the username. In fact, the UPN is formatted like an email address, which allows a period.
My further thoughts:
My experience has been that, for a sufficiently large enterprise, any decision you make will always have problems. Even if it works today, there's always the system you implement tomorrow that has problems with the prior standard (length issues, character problems, etc).
Be sure to find out if the push for Firstname.Lastname relates to email and not necessarily login names. I'd find it hard to believe that the user wants to type "John.Smith" instead of "jsmith" when logging-on, but I'm much more sold on the idea that he wants "[email protected]" as his email address. As @Mfinni points out, there's always the option for users to have mutliple email aliases, forwards, etc. Just letting users know that the option exists to de-couple their username from their email address can change the dynamic of the request.
For Unix and Linux systems, {firstInitial}{lastname} is clearly ideal.
...
for reasons that should be obvious from the name associated with this account.
One thing to be aware of when setting naming standards across platforms is a particular cosmetic issue in ps in Linux (and possibly other Unix OSes). You may or may not care about this (but it can be alarming to someone who isn't expecting it ... I've had security folks twitch on this one).
The UID column will only display up to 8 characters of a username. If the username is longer than 8 characters, it will switch over to printing the actual numeric UID. You CAN get around this by having a custom ps column format that contains the USER field, but ONLY if USER is the last column (from my empirical testing).
Most people probably do not care about this, but if you're doing some sort of processing of ps output and expecting the real usernames to appear, you should be careful with your name lengths (otherwise, you'll be putting hacks in your code to make ps do the Right Thing).
For example:
Here's the default column format for the full format listing. Note that my uid is in numerical format because my username is > 8 characters.
Let's recreate it using a custom column format. Note that I've added the USER column. Note that it's also in numerical format.
Let's move USER to the end of the line. It gets expanded to the "right" output.
But, as soon as we add something new to the end of the column list, it reverts back to numerical form.
Well, from an Operations, Administration, and Maintenance (OAM) point of view, the username needs to be easily distinguished. However, from a business point of view, the username (a/k/a email alias) has to be easily be remembered or recalled by others.
It can be like:
[some letters from firstname][some letters from lastname][nnn]
foreg: If name is Bill Gates, you can use ' biga00 ' or bilgat000
if next bill gates comes , it shall be 'biga01' or bilgat001' for him