Product-configuration systems usually provide graphical user interfaces for product modeling, that is, for describing the configurable aspects of a product. This is fine as long as you offer only a few relatively simple products. But it does not scale well if your products are more complex or if you have many products and product components on offer. Many of your products are based on similar concepts. With the usual modeling interfaces you have to implement these concepts over and over again for each product, wich is both tedious and error-prone, and frequently leads to inconsistent configurators.
ConfigModeler uses a high-level language tailored to your business and provides an integrated development environment (IDE) for creating and maintaining product models conveniently. This allows you to use the concepts behind your products directly in your product models. These high-level models are then translated automatically into the format required by your configuration system.
With ConfigModeler you avoid repetitive work and mistakes, your models are easier to understand and to maintain, even by non-technical users, and your configurators will be more consistent. Furthermore, since models are (human-readable) text, you can use a plethora of modern tools working on text files.
The following example is based on a configurator from one of our customers using ConfigModeler, but has been simplified for explanation purposes.
Assume you are offering switches for telecommunication backbones. A carrier-grade network switch has multiple slots, which can be equipped with cards. A card provides network interfaces, called ports.
Transceivers convert the electrical signals from ports into the optical signals used in glass fibers and back.
While all products follow this basic structure, there are various restrictions for components to fit together, for example:
class C12345 extends Card {
property slot_type = "long"
optional property port1: SFP_plus_transceiver
...
optional property port8: SFP_plus_transceiver
optional property port9: SFP_transceiver
...
optional property port24: SFP_transceiver
computed property power_consumption =
35 + port1.power_consumption
+ ...
+ port24.power_consumption
}
With the modeling capabilities of a standard configuration system, which has no understanding of the application domain, one would have to describe products in terms of generic concepts such as classes, objects, and properties. A particular card providing 8 ports for transceivers of type "SFP" and 16 ports for transceivers of type "SFP+" might be described as in the attached box.
This language is hypothetical and used here for explanatory purposes only. With many product-configuration systems this information would have to be entered by lots of clicking in a graphical user interface. But notice that webXcerpt provides textual languages on this level for the SAP Variant Configurator and for PROS Cameleon CPQ.
card C12345 [long] {
ports 8 * SFP+
ports 16 * SFP
power 35 W
}
With ConfigModeler the same card could simply be described in a high-level modeling language for this kind of products. This makes use of the fact that modeling language, IDE, and translation support the following problem-domain concepts:
From the example it should be clear that with ConfigModeler
In the following two sections you find
Certain operations on text files are provided by standard editors and other tools and do not even require these tools to have any understanding of the modeling language. Of course, these operations are also supported by the ConfigModeler IDE.
Finally, and perhaps most importantly, a textual representation makes it much easier to communicate about models. You can easily add (parts of) a model to an e-mail or a presentation slide. And if you wish, you can even print it out.
A high-level language does not only allow for concise models, but it also allows the IDE to provide more informed support for the modeler. For our example domain the IDE can
ConfigModeler is only used for modeling products, not during the actual configuration process. The translated models are handed over to your configuration system. End users of your configuration system will therefore not interact with ConfigModeler when configuring products. It is not even necessary to have ConfigModeler running at that time.
Another issue is that you might already have several product models in place. These models might follow certain modeling conventions (e.g., conventions for naming identifiers or preferred approaches if there are multiple ways to model certain aspects) and use a library of utility code. ConfigModeler's translation process can be adapted so that the generated models adhere to your conventions and fit seamlessly into your existing framework.
As an added bonus, the translation process can also be adapted to changes in your configuration system (version upgrades, changes to the utility library, or even replacing the configuration system with a completely different system from another vendor). ConfigModeler can greatly simplify the migration process, often requiring no changes at all to your high-level models.
ConfigModeler is implemented as a set of plugins for the Eclipse IDE based on the Xtext language development tool, the Eclipse Modeling Framework (EMF), and the Xtend programming language. This does not only allow Java programmers to make use of their Eclipse experience, but even allows to integrate ConfigModeler with the Java IDE, which you may use for implementing your utility code.
webXcerpt has implemented variations of ConfigModeler for several customers. We have particular experience with the target configuration systems SAP LO-VC/IPC (using VClipse), PROS Cameleon CPQ, and openCPQ, but models for other configuration systems can be generated as well.
The presentations below have been given at various conferences of the SAP Configuration Workgroup (CWG). As they are by now a few years old, they might not precisely describe the current state of the tools. However, the basic ideas remain the same.
We did not yet publicly present the high-level product modeling environment we built for PROS Cameleon CPQ for a customer. Please contact us in case you are interested.
Configuration Workgroup (CWG) European Conference, Cologne, May 2011
This presentation introduces the idea of creating an Eclipse-based IDE for the SAP Variant Configurator which supports product modeling on different levels of abstraction (ConfigModeler and VClipse).
Configuration Workgroup (CWG) European Conference, Berlin, May 2012
This presentation compares product modeling with programming and applies ideas from Model-Driven Software Development to product modeling. It shows how to extend VClipse to create new product-modeling functionality. Furthermore, it discusses aspects of building a ConfigModeler-like high-level product-modeling environment.
Configuration Workgroup (CWG) European Conference, Berlin, May 2012
Test-driven product modeling is a methodology of product modeling which leads to quick development of high-quality product models. Automatizable test case(s) are written before the product model is implemented. Subsequently the product model is modified until no test cases fail. With subsequent refactoring steps the design and implementation is improved.
With an integration of the ConfigScan test engine into ConfigModeler and VClipse test-driven product modeling will become feasible.
webXcerpt provides consulting and custom development related to ConfigModeler. Here are some examples of what we can do for you:
Please contact us to discuss what we can do for you or just for a demonstration of ConfigModeler.