Hello,

These weeks we have been working on the DTIM framework. We already have some functionalities implemented and we're working on the others.

At the beginning it was a little bit complicated to understand how the framework orchestrates the clients requests and the how the modules are coupled to it. The main issue of this framework is the lack of documentation related to developing modules. After a good amount of hours we finally comprehended what we add to do in order to implement our modules.

At this moment the projects are going in-schedule and if it continues like this we pretend to finish the modules as planned.

The complexity-analysis plug-ins are still in stand-by. We don't have the fifth metric and still don't know which other language to implement.

The B2BISS is over but we will work on it in the Semantic Web course lectured by our advisor. We'll make real business requests in RosetaNet and ebXML. After finishing those examples we will apply them to B2BISS and verify its behavior in real examples.

Progress Report

Hello,

We've been writing our progress report that had to be delivered in this first week of February.

It is entitled "Advanced Applications for Management, Integration and Analysis of Medium/Small Companies". You can consult it here.

Having the progress report done, now its time to start working at 100% in the DTIM project. In the next months we will be giving all our efforts to this project.

Our time is starting to become shorter since we will return to classes the 15th this month, so we need to start moving faster around the projects.

In the B2BISS site you can find a new release of the tool. We've made some changes to fix a few bugs that our advisor found.

B2BISS WebSite

From now on you can use the recently created B2BISS website to stay tuned to the tool.

It can be accessed from http://apus.uma.pt/~b2biss

There you have a complete download section.

Cheers.

B2BISS is complete!

Finally we've finished our first tool in the Final Project.

We made some changes on the interface as the elements of the SEED team advised us. We also added FTP and Socket Services to the framework. We added a statistics section so the user might be able to analyze the percentages of the incoming files types.

You can see some screenshots of the application bellow:

screenshot1

screenshot2

screenshot3

screenshot4

screenshot5

screenshot6

screenshot7

screenshot8

screenshot9

We also redesigned the XMLSender so it now supports the send over Socket. You can see a screenshot and download it in the Links section on the right.

Concerning to the business process metrics plug-ins, we've made some changes on them, nothing really important, basically we just changed some names. At this point we are waiting for one metric (Modularity) and still don't know what will be the third language to implement. We'll have to wait patiently for it…

On DTIM, we are already working on the Design phase, and started reading some material about PHP O.O. programming and MVC design patter usage. Unfortunately, we are not spending the time that we expected for DTIM, but in the next 2 or 3 months we pretend to give 100% of dedication to this project, since it is the main one.

The next weeks we have to start writing our intermediate report because it has to be delivered in the first week of February.

B2BISS

It's been a while since our last post...

We've been working hard on all three projects and we've made quite good advances on them.

First, let's talk about the JXML2OWL. From now on it will be called B2BISS (Business 2 Business Integration Using Semantic-to-Semantic Mappings ).

We've been designing the interface and started programming it. Bellow you can see some simple screenshots of the interface.

ScreenShot1

ScrenShot2

ScreenShot3

ScreenShot4

We've also created the XMLSender – a simple tool that sends the xml files to be received by the B2BISS.

You can see a screenshot here.

And the download can be done from here.

Relatively to the business process metrics, we have some news. First, we won't be implementing them for BPEL and YAWL because the ProM framework does not have an API for those languages and therefore we cannot manipulate the structures in order to calculate the complexity. So, we'll search for other languages that have a suitable API and implement the metrics for one or two of them.

Apart from that, we have a new metric – Coupling – and we've already implemented it for EPCs and Petri Nets. At this point we have 4 metrics – Size, Control Flow, Density and Coupling – implemented for both EPCS and Petri Nets. We are waiting for a fifth metric called Modularity which might arrive in 2 or 3 months.

You can see some screenshots of the plugins here: EPC PetriNets

Concerning to the DTIM project, it is behind schedule which are good news. This week we delivered the Requirements Specification and started working on the Architecture. After that we have Design, Coding and Testing.

Defining if a Specific XSLT was Created for a Given XML

As we described last week, we will implement a tool that receives an XML file and verify the existence of a XSLT file that is able to perform the transformation on the XML.

In order to fully define the different situations, we had to take some assumptions. The assumptions are taken in the basis that a XSLT file only transforms a XML when all of its requested XPaths exist in the XML.

Having this basis, we define that the XSLT and XML have a complete match when their XPath sets are equal, as you can see in the picture bellow.This means that for each XML XPath there is a XSLT transformation, and therefore, the mapping already exists and the complete transformation can be done.

If, for any given reason, the XSLT XPath set has, at least, an element that does not belong to the XML XPath set, then we consider that there is no match. We assume this because the XSLT would never be able to do his 'job' - the transformation - if all the elements he refers don't exist on the XML. The specific cases are shown in the pictures bellow.

In these cases, the mapping will be done manually by the user.
Finally, we assume that there is a partial match between a XML and a XSLT if all the elements in the XSLT XPath set exist in the XML XPath set. This assumption is taken in the cases like the one in the picture bellow.Wen we have the partial match, the user gets the chance to select which XSLT file should be used for the transformation.
We intend to divide the incoming files in one of the types mentioned above.

XML File Receiver Archiecture

As we referred in earlier posts we will create a tool that receives XML files and then compare them to XSLTs to see if there is a match.

If exists an XSLT file that transforms the received XML, then we use a tool that already exists to make the mapping.

If not, we use another tool that asks user to make the mapping manually. We will also create a simple tool to send those XML files, so our user can use it to send the files to our program.

You can see the architecture in the image bellow:

At the moment we are starting to implement this architecture.

Petri Nets in Business Process Management

Petri nets were invented in 1962 by Carl Adam Petri in his Ph.D thesis.

The classical Petri net is a directed bipartite graph

In these nets there are three types of elements: Places, Transitions and Arcs

Arcs run between places and transitions - not between places and places or transitions and transitions.

The places from which an arc run to a transition are called the input places of the transition; the places to which arcs run from a transition are called the output places of the transition.

Places are represented by circles.

Transitions are represented by rectangles.

Places and Transitions are connected via direct arcs.

Places may contain any number of tokens. A distribution of tokens over the places of a net is called a marking. Transitions act on input tokens by a process known as firing. A transition is enabled if it can fire, i.e., there are tokens in every input place. When a transition fires, it consumes the tokens from its input places, performs some processing task, and places a specified number of tokens into each of its output places. It does this atomically, i.e. in one single non-preemptible step.

In the process dimension, it is specified which tasks need to be executed and in what order. Modeling a workflow process definition in terms of a Petri net is rather straightforward: tasks are modeled by transitions, conditions are modeled by places, and cases are modeled by tokens.

There is a good paper about workflow management written by W.M.P. van der Aalst called "The Application of Petri Nets to Workflow Management".

There is also a complete definition in Wikipedia.