Avoiding Pitfalls for an Object Type Library (OTL)

An Object Type Library (OTL) is a standardized framework that improves communication between different parties and their software systems, making data exchange easier. 

While there are many benefits, you need to model an OTL correctly to use them for their intended purpose. This requires the right people, tools, and resources.

This article discusses pitfalls that can impact the success of OTL modeling and how Laces helps you prevent them.

Purpose of Object Type Libraries

There are different use cases for adopting Object Type Libraries. The first is to facilitate data exchange between companies and teams. Secondly, to improve communication by providing consistent definitions for assets or activities in processes.

All OTLs share the common trait of offering a standardized understanding of abstract concepts that are not yet individually identifiable in our surroundings. They are usually modeled for people who need to use and share data about assets across projects, such as engineers designing assets. 

That said, we believe that people who benefit from OTLs the most should also be able to model them or at least decide what to register. Unfortunately, in practice, we often see that companies do not involve end-users or involve them too late within OTL programs.

Common pitfalls

OTLs often contain a high degree of complexity or require deep IT knowledge. This is mainly due to the common pitfalls we encounter when modeling Object Type Libraries. 

1 – Making the modeling too complex
We utilize Object Type Libraries (OTLs) to handle unstructured data that can be difficult to interpret and use. However, without a clear architecture and modeling principles for registering and structuring information, one may take too much liberty and create a needlessly complex OTL. 

While freedom and flexibility are essential to designing OTLs that cater to specific use cases, this freedom is often misused to try and fit different structures into a single OTL. This results in an overly complicated OTL that is challenging to apply in practice and does not contribute to the goal of structuring data.

2 – Trying to model the world
When modeling Object Type Libraries (OTL), it is necessary to start with a clear purpose and identify the actual information needs. This approach ensures that the OTL can solve the organization’s specific challenges. However, it can also make the process difficult. 

Organizations often attempt to cover multiple conflicting goals in a single OTL or fail to consider them upfront. This can lead to an overly complicated OTL that is no longer suitable for any of those information needs.

You must remember that it is impossible to model the entire world. Instead, we recommend beginning with a lower level of detail per asset or a smaller scale and gradually building up the content level. This approach will enable the utilization of a uniform structure for modeling purposes.

3 – Not connecting the end user
As mentioned, we model object-type libraries to support people in practice. Therefore, you want those working with it (domain experts) to co-determine what is you need to capture in that library’s object type. 

We often find that they are not involved in the modeling process. They are either unaware of its existence, stuck in their work, or because IT specialists are solely responsible for developing object type libraries. 

To ensure that you model an object type library successfully, it is crucial to have people with domain expertise working on its content. This helps maintain a connection with the domain and ensures the library is tailored to meet the end-users’ needs as closely as possible.

4 – Using wrong or non-interoperable tools
Object type libraries are often difficult to implement into an application landscape due to their connection to proprietary formats, unsuitable tools, or academic tooling that requires technical skills. This makes it challenging to use and share object type libraries across applications and their users, hindering their intended purpose. 

Moreover, the tools available are often too basic or technical, catering only to IT specialists rather than domain experts. This lack of accessibility makes it challenging to integrate object type libraries into business processes and project application landscapes.

How Laces helps

At Laces, we believe that simplicity is essential for object type libraries. Our software simplifies creating and managing object type libraries while keeping technical aspects to a minimum. Here’s how Laces helps you deal with this:

1 – IT in the background
Laces allows domain experts to take ownership of their assets and model them while it handles the technical linked data part. This means you don’t need IT specialists without the specific domain knowledge to manage your OTL.

2 – Resolve modeling mistakes
Instead of creating one big model that tries to cover everything, Laces software ensures that your OTL fits the purpose. This simplifies the process and reduces the likelihood of mistakes.

3 – Offer guard rails
Laces adheres to industry standards. This means that it structures information in a way that is understood by everyone, keeping you on track. This may limit your freedom to register and structure information but guarantees the correct structuring of your OTL.

4 – Built on the principles of Linked Data
Laces offers interoperability, allowing you to share and reuse data across multiple software and organizations. With Linked Data, you can create a connected web of data that can be navigated by both humans and machines.

Remember, creating an OTL takes time, so investing in a solution will make your life easier. If you’re experiencing the negative effects of these OTL pitfalls, schedule a demo to see how you can avoid them.