You might wonder why I am discussing this here. The reason is simple: nearly every project has a bit different naming conventions, which makes a the life always a bit complicated (for developers, but also setup responsible, and also for consultants). 

Although we always create a document to describe the technical object naming conventions, I have rarely seen a dedicated document  with functional naming conventions. To be precisely, from my stand point, there should always be one global naming definition for an implementation!

Let me discuss some related questions:

• What is the best convention for the customization reference?
• How to name database objects (tables, packages etc.)?
• How to name functional objects like Value Sets, Concurrent Programs, etc.
• How to separate customizations from standard objects best?

What is the best convention for the customization reference?

The customization reference is the key you use to reference your customization from other lists, from the project plan etc. Usually it is something like

• XXHU_CONV_22 (HU=customer abbreviation, CONV=Conversion object #22)
  or
• XXFA_DEPRN_RPT_02 (FA=Fixed Assets, DEPRN=Short object group, here depreciation, RPT=Report, 02=2nd report in this area)

As this is just a reference (not an object name yet), I would prefer the second option.

XX=Customization,
FA=Main EBS Module linked (you may have sometimes more, but FA is the main)
DEPRN_RPT=Short name to specify the customization
02=a unique number

Important here is that the HU isn’t used, because XX is enough to mark a custom object, and the 3rd+4th char can be used by the EBS module short name.

How to name database objects (tables, packages etc.)?

I was leading different developer teams, and I know that one common way is it to take the Customization reference and add more chars behind to classify the object (like _V for view and _T1 for triggers etc.).

The only concern I have with this approach is the reusability. If you name your view XXFA_DEPRN_RPT_02_V, no one will by choice reuse this nice view, as it seams to be specific for this CEMLI. My suggestion is rather to name the view XXFA_DEPRN_PERIODS_V and allow herewith reusability for other CEMLIs (although the view will be deployed primarily with CEMLI package XXFA_DEPRN_RPT_02). (check also one of the following Blogs where I will talk about deployment.)

How to name Value Sets, Concurrent Programs, etc.

For Value Sets I would go with the same convention as for database objects, starting with XX<Module> ….

For Concurrent Programs the situation is a bit different. This “object” is seen and used by a lot of users, and they will search for. In many projects it is common to start again with the company short name, or with XX. My proposal would differ. If you have created your own report and you name it “XX: Invoice Report”, the user has to remember that this report does not start with “I”, it starts with X. Would you like typing an X if you are looking for an Invoice report? No, you wouldn’t!

So my advise would be to name it:   “Invoice Report (XXAP)”. Still we know it is custom (because of the XXAP), but the end user will type the key “i” to get it (and will see similar reports starting also with “i”).

I hope that the general schema behind has now become obvious.

How to separate customizations from standard objects best?

I would not have this section here if the naming would not play an important role. Unfortunately, we can not always link a custom application to our own object, therefore the naming is really important. In the file system structure we use our $XXyy_TOP, in JAVA_TOP it is perhaps also “xx” in front. But in the database itself? Although there are different concepts in place, still many implementations are using the standard “apps” approach, means custom objects are stored in the apps schema (which should not cause any trouble).

Final advise: review the naming conventions regularly, once a month. You may have to add more! And, publish them!

To summarize:

Technical and functional customized objects should always follow a naming convention. This naming convention should be project wide, and only one place shall be used to maintain (like in a Wiki). If the name is for the end user, rather put a customization identifier at the end; if it is an internal name, start with XX…