The Next Best Thing

If you do not have the authority or power to convince the company that a single database is optimal, you will be forced to create a library database that will work within the confines of the design group.

We'll start with the conclusion first - use L9 Library Manager!

L9 Library Manager is well suited for component library management due to its intuitive user interface and flexibility.

Let's look at the progression that all of us have taken or will take that led us to this conclusion.

Beyond a one person library

Oddly enough, EDA tool makers generally put us on the wrong path at the very start! Why? They created an environment that was based on a single user. The user was given an editor to draw parts. At the end of the day, it was up to the designer to maintain a library.

We at Nine Dot Connects refer to this method as a "component-centric library." It has to do with the fact that we draw a schematic symbol because we need that first to proceed with a schematic. From there, we add intelligent information about the part and, eventually, a PCB footprint.

Granted, projects may be laid out by a single user; however, there is no reason to withhold other team members' components. Isn't "design reuse" the overused catchphrase? When a component takes over an hour to design, we would be foolish not to make this available to our colleagues!

The component-centric method isn't designed to handle 2 or more users. One person can only open the file at a time for edits. If the other designers start copying the master file, the branching issue comes into play. Unfortunately, this requires a manual comparison of the changes to reunite the libraries in a graphical environment. The longer this split exists, the more difficult it will be to unite them. Creating library parts is never static - this reconciliation of libraries becomes extremely difficult when many designers work on projects and create components. Even if the designers were out of the office while this reconciling took place, the problem would again reoccur when the designers returned!

Granted, there are ways to handle this; however, none are truly foolproof. Keeping the master library files in a version control system is a step in the right direction. At least there is a tracking of events.

By the way, do not confuse library placement in a version-control system with version-controlled libraries. They are very different. For more information, please read our commentary on this:

Version Controlled Library

Also, it generally requires the use of a full-time librarian who acts as the gatekeeper to the library, does not allow anyone access to the master files, and provides the files to the users as they see fit to use them. Unfortunately, this mechanism does not prevent designers from creating libraries from these distributed libraries from the librarian. In many cases, the designers are forced to create components independently to keep the design moving forward. As a result, there still will be branching and reconciling.

Database Libraries

It is not apparent to a new designer; however, the most efficient library methodology is the database method. By its nature, the database can be accessed by 2 or more people. Also, it allows for the symbol, parameter, footprint, and 3D model reuse. For example, if someone requires a resistor that matches another resistor in a similar library, it is straightforward to copy the component's record and make a few minor changes to the value.

However, we do not entirely escape the process issues of symbol-centric libraries. If a librarian heavily guards the database, there will be a backlog of components. As a result, the same situation will occur - designers will create their own libraries to keep their projects moving along.

In a database library accessible to all, we risk information not being entered or entered correctly. Granted, if one took some time to look at prior entries, they would see a pattern; however, it would be a mess if no pattern existed from the start. Of course, designers will be in a rush, so it is unrealistic to assume they will properly enter the information.

Point of entry = Point of failure

Our observation is that the point of entry for a new component is where the problems start. It comes down to 'guidance.' What we mean by the guidance are features of an interface that can help with the data entry and make it very easy to enter. It is this ease of entry that prevents designers from creating their own libraries. As a matter of fact, a good interface allows designers to contribute to the library from the very start. Granted, a librarian should still review the components; however, it takes a significant burden off the librarian!

All too often, the designer is given nothing more than a blank text box. Open text boxes allow for any response (or, in many cases, no response at all!) If there is nothing to guide the designer, they will take the path of least resistance. Unfortunately, the longer this component lingers without proper or correct information in the library, the more difficult it will be to correct it if found its way into the designs.

The elements of a good interface include, but are certainly not limited to:

A log that shows who's touched what

A serial number that can be easily assigned without chasing down another external list

Formats for information that are readily known through examples that exist or by comments that are provided in the user interface window

Enumerated lists that are created, where applicable

Mandatory fields that are clearly marked

Concatenation features that can build and format cell information based on other entries.

Therefore, a sound library has a robust point of entry that provides guidance. Doing this requires someone with experience in database and web programming to allow each user a point of access, component library management, and a decent knowledge of the EDA tool. Let's face it - that's not easy to come by!

That is where L9 Library comes into play since it provides such an interface. It is an elegant solution for those who are:

Looking to use a database to serve their group

Not wanting to write an interface

Seeking a process that can minimize the errors that are so common when adding components to a database.