COLIBRI Studio is the implementation of the top layer of the COLIBRI platform. It provides the visual builder tools required to generate CBR systems without dealing directly with the source code. It is built on top of the jCOLIBRI framework and enables the composition of its CBR components. COLIBRI Studio is integrated into the popular Eclipse IDE. This way it takes advantage of the facilities provided to manage projects and Java source code. It enables the generation of “CBR projects” where required libraries are automatically configured. These libraries conform a new release of the jCOLIBRI framework numbered as jCOLIBRI 2.3. It is just an adaptation of the previous version 2.1 to work with the configuration tools. From the functionality point of view there is no difference between jCOLIBRI 2.1 and 2.3. It is used to compile and run the source code generated by the tools in COLIBRI Studio.

The main feature of the development process proposed in COLIBRI is reuse (somehow inherent in a CBR framework). We propose the reuse of both system designs and their components. The platform provides a catalog of already implemented CBR systems and lets users select the most suitable system and adapt it to the concrete requirements of the target application. It is a kind of CBR process for developing CBR systems (See this paper for details).

It is natural to think that pre-designed systems should be generated by “expert” users. This is the first role in our development process: expert users are mainly concerned in designing new CBR applications.
These designs are called templates in our platform. A template is a high level representation of a CBR system where several tasks are linked together to define the desired behaviour.

In a general way, the templates of the jCOLIBRI library are composed of tasks that identify the steps of the CBR system. A system (or executable template) is a template where each task is solved by a component. Our design tool retrieves templates from the catalog and lets users adapt them to create new CBR systems.

Here the actors are not only CBR experts: developers, teachers, students, or inexperienced researchers will perform this process. This main use case is referred to as the Template Base Design (TBD) which consists mainly of retrieving a template and selecting a suitable component that implements the behaviour dictated by each task in that template.

To aid users in the retrieval of a template that fits her requirements we have developed an Eclipse’s wizard that implements a recommender system of templates. This recommender follows an approach named “retrieval by trying” where templates are associated to a real implementation that lets users test the behaviour of the CBR system once implemented (in a testbed domain).

To configure the templates by selecting a suitable component for each task, COLIBRI Studio provides, the system editor tool. This tool implements the TBD itself by enabling the configuration of templates with components available in the jCOLIBRI framework. On the left side it displays the internal variables used to configure the data-flow between components. On the bottom side the tool reports the errors found in the composition being created by the user (unassigned inputs or outputs, incompatible assignations, etc.).
Once the composition has no errors it generates the source code of the application, that can be directly compiled and executed.

Here an important issue arises: how do we know what tasks a component can solve? In other words, we have to link the methods in the bottom layer of the COLIBRI platform -the jCOLIBRI framework- with the tools in the top layer. To address this issue we have developed an approach based on Annotations. Annotations represent meta-information in the source code and allow us to document classes, methods or even variables. Then there are several ways to process and extract this information. The most popular example of annotations is the JavaDoc tool, which generates HTML documentation of the source code from simple tags.
jCOLIBRI 2.3 uses this mechanism to annotate every component with information about its behaviour. That is the only difference between jCOLIBRI v2.1 and v2.3. In this way, composition tools can automatically analyse the source code and obtain the components able to solve a concrete task.

The design of these components is very related to the research field as they will implement the different
algorithms developed by researchers. Therefore, this is the second main task of expert researchers. However, we don’t expect that expert researchers will implement the components. This task will be delegated to users in a “developer” role. We also contemplate the role of “junior researcher” that could design and even implement his own experimental components. Then, these components could be shared to the community by means of the COLIBRI platform.

The main advantage of the TBD process is that it provides an easy to use experimental environment to test new designs and components. This feature is also very interesting for teaching. Lecturers can use our tools to prepare assignments with existing (or even new templates) and let students configure different systems and evaluate their performance.

Up to now we have left aside the non-academic uses of the platform. As we will see in the following sections, the TBD tools let users generate automatically most of the code that implements their CBR application. Therefore, it could be used by development teams in commercial companies to increase their productivity when generating such systems. Here, experienced (head) developers will have a similar role to expert researchers, and they will be in charge of supervising the implementation of the required components, which will be performed by regular developers.

Summarizing, the COLIBRI Development Process consists of:

  • Expert users design new templates that define the behaviour of a CBR system by means of tasks.
  • Users are able to find and retrieve the most suitable template according to the prerequisites of the CBR application they wish to build.
  • Users configure the retrieved template by selecting the components that provide the behaviour required by each task in the template.
  • Once the configuration is completed our graphical environment generates the source code of the application.
  • Complementary tools let users compile, execute and evaluate the generated application.
  • The components required to instantiate the templates are generated by developers.

We have created a video showing the features of COLIBRI Studio. It shows the tools, wizards and the Template-Based Design process.

Los comentarios están cerrados.