Nicozan-Blog

Knowledge Seeking

BPMN : Process Modeling Conformance February 26, 2013

Filed under: Uncategorized — nicozan @ 1:11 am

After reading the BPMN2.0 specification you need to remember the following in order to understand how JBPM is built and works.


The Process Modeling Conformance packages that MUST be in our BPM tool are:

BPMN Core Elements: Infrastructure, Foundation, Common and Services Packages.

Process Diagrams: Process, Activities, Data and Human interaction Packages.

Collaboration Diagrams: Pools and Message Flow.

Conversation Diagrams: Pools, Conversation and Conversation Links.


Then we have have ALTERNATIVE Process Modeling Conformance sub-Classes:

Descriptive: Containing Visible Elements and Attributes used in High level Modeling.

Analytic: Containing all of the Descriptive and some more.

Common Executable: The sub-class focuses on what is needed for executable Process Models.


Now going a little deeper into the BPMN Process Elements. The Process Modeling Conformance TYPE SET consists of collaboration and Process diagram elements:

Descriptive Conformance Sub-Class Elements: Task, Service Task, User Task, Data Object, Sequence Flow, Message Flow, Start / End Events…

Analytic Conformance Sub-Class Elements: Contains all the elements of the Descriptive sub-class and…, Send Task, Receive Task, Looping Activity, signal Start / End Event…

Common Executable Conformance Sub-Class: It’s used for modeling tools that can emit executable models:

  • Definition language MUST be XML Schema.
  • Service interface definition MUST be WSDL
  • Data access language MUST be XPath.



After taking note of the MUSTs of the Common Executable Conformance Sub-class here I leave you with some cool links:

WSDL:

XPATH:

 

BPMN2.0 : my way to get back to good things. February 15, 2013

Filed under: Uncategorized — nicozan @ 12:59 pm

Hi Everyone,

It’s been a while since I wrote my last post, but well if Arnold Schwarzenegger returned to the movie business why shouldn’t I return to my blog.

This post will be short as I am a little rusty, but here I leave you the link to the BPMN2 specs:

BPMN2.0

That documentation is pretty extensive. So I recommend you to read especially the section that references BPEL Process Execution Conformance. 

After reading that we’ll have the basic knowledge to get into the Good Thing, that is JBPM5.

Stay tuned for future posts regarding this topics😀

 

Traditional SW VS Intelligent SW June 27, 2011

Filed under: AI — nicozan @ 4:52 pm
Tags:


Introduction

By reading the title , you might think : “Wait a minute. Is there any Stupid SW?”. Please don’t think that, the idea of the post is to show you that there is type of software which aims to emulate Human Intelligence.

When it is time to build Intelligent SW?

Not all problems look alike. There are some problems that can be solved by implementing a set of steps. These kind of problems have an algorithmic solution. On the other hand we have problems that can’t be solve by an algorithmic solution. These are the ones that need Intelligent SW to solve them.
There is more than one Intelligent SW that can be build. Some of them are listed in the table below.

INTELLIGENT SOFTWARE

TYPE OF PROBLEM

Expert Systems (With knowledge Base) Problem that requires human expertise.
Genetic Algorithms Optimization problems
Artificial Neuronal Network Pattern recognition

From all these, I will choose the Expert System  to compare with the Traditional Software.

Comparison between Traditional SW and Expert Systems

Traditional SW Expert System
Data Objects, variables, Constants Rules and Facts
Elements Programs and Data Rules, Facts and Inference
Engineering Area related to the build of them. Software Engineering Knowledge Engineering
SW Life Cycles based on Spiral Model IDEAL Methodology

Some aspects need to be explained. The IDEAL methodology is based on the Spiral Model of the Software Engineering. With the difference that the IDEAL methodology considers the corrective maintenance of the knowledge base.

Another thing to keep in mind is that SW Engineering and the Knowledge Engineering complement with each other. Usually an Expert System is a module of a Software      Engineering project.

Conclusion

– Not all problems can be solved by an algorithmic solution.
-SW Engineering and the Knowledge Engineering can live together.

 

Drools Expert – Quick Start Screencast May 30, 2011

Filed under: Drools — nicozan @ 2:43 pm

Hi,
This is a short screencast that I have recorded to explain in a few minutes some of the features and concepts related to Drools Expert. Inside this screencast you will find a simple example that it will help you to understand some of the basics of an Expert System.
Please click the image to watch the screencast…

I hope it helps🙂.

 

Drools and Gwt – Small Post, Big Issue May 11, 2011

Filed under: Drools,GWT — nicozan @ 3:47 pm
Tags: , , ,

Short Approach…

It’s an excellent idea to combine 2 two technologies such as Drools and GWT to build Intelligent Web Applications. But there is a little bit of a problem at the moment to integrate them. Because Drools and GWT include the org.eclipse.jdt classes but with different JDT version. And when you run your application (mvn gwt:run) you will have an error like this:

Unable to parse module: com.google.gwt.user.User
java.lang.NoSuchMethodError: org.eclipse.jdt.internal.compiler.CompilationResult.getErrors()
[Lorg/eclipse/jdt/core/compiler/IProblem;
at com.google.gwt.dev.jdt.AbstractCompiler$ICompilerRequestorImpl.
acceptResult(AbstractCompiler.java:213)
at org.eclipse.jdt.internal.compiler.Compiler.compile
(Compiler.java:417)
...

Solution…

So to solve this problem you need to add an exclusion to your dependecy (that has the Drools-Core dependency) added in your Maven Gwt Application pom.xml. The exclusion in your pom should look like this:

<dependencies>
    [...]
<dependency>
           <groupId>com.wordpress.nicozan</groupId>
           <artifactId>dependency-with-drools-core</artifactId>
           <version>1.0</version>
           <exclusions>
                   <exclusion>
                           <groupId>org.eclipse.jdt.core.compiler</groupId>
                           <artifactId>ecj</artifactId>
                   </exclusion>
           </exclusions>
</dependency>
    [...]
</dependencies>

Short but helpful😉

 

Knowledge Elicitation – Using Protocol Analysis April 19, 2011

Introduction

As you might remember in previous posts I have talked about Knowledge Engineering, Expert Systems and Rule Based Systems. Today I’ll get back to those concepts and explain you the Protocol Analysis Method to do Knowledge Elicitation.

Protocol Analysis

Before we begin, I would like to highlight that there are other methods to elicit knowledge such as interviews, questionnaires and repertory grids.
This method have several steps, obviously lets start we the first one :

1- The Idea is to search and capture ,and then study, everything the expert says while he is solving a problem. That’s why we record the experts explanation with a tape recorder during his task. In other words, the expert have to explain what he is thinking.

2- After we record our experts explanation (Protocol),we have to write down the recorded audio and divide the text into segments. Please have a look at the next simple example:
Protocol: “As we can see the Porsche 911 is a very comfortable and fast car, so it is expensive”
Transcription:

Line

Text

1

As we can see

2

the Porsche 911

3

is a very comfortable

4

and fast car

5

so it is

6 expensive

In the example protocol,  the expert was explaining what makes a car expensive, thats this ob

3- Now it’s time to identify concepts, characteristics, values, relations and operators. Considering the Drools Expert tool: Concepts are facts, characteristics are the facts properties and values are the values of the properties.
The operators are elements use by the expert to move from a state of the problem to an other state closer to the final solution.
Let’s see the next classification table:

Element

ID

As we can see

Relation

Porsche 911

Concept
very comfortable

Value

fast

Value

so it is

Operator

expensive

Concept

The states in our problem can be Concepts or Characteristics, but not both at the same time. In this case I’ll choose Concepts as states of the problem.
In the table that follows we’ll specify the explicit relations:

Concepts

Characteristics Values
Porsche 911 (Comfort)

very comfortable

(Speed)

fast

Expensive

A value must be always related to a characteristic. If there is an explicit value in the text but there isn’t the explicit characteristic, we have to write the implicit one between parenthesis like the example above.
Now we represent the implicit relations, that are always between concepts.

After this schema, we draw, what is called,  a “Search Identification”:

4- Now that we have done our search identification it is time to write the rule associated to it. Obviously we’ll be using the DRL syntax of Drools Expert.

rule "It's an expensive car"
when
  $porsche : Porsche911( speed  == "Fast", comfort == “Very Comfortable” )
then
  System.out.println( “Car: ”  + $porsche.getName() + “ is an expensive car” );
end

Well, this short explanation would be enough for you to start your first knowledge elicitation and get closer to the knowledge engineering.

 

GWT- Time to Refactor means Async Interfaces Issue April 7, 2011

Filed under: GWT,Java — nicozan @ 4:43 pm
Tags: , , , ,

Introduction

When you first create a GWT App, the project is divided ,usually, into three packages: client,shared and server. In this post we’ll consider the next packages names:
-com.wordpress.nicozan.client
-com.wordpress.nicozan.shared
-com.wordpress.nicozan.server

Refactoring Services

Let’s consider that in the package com.wordpress.nicozan.client we have the interface bankService and we have too the interface bankServiceAsync. This Async-interface help us to communicate with the server side of our application. The server side is in the package com.wordpress.nicozan.server and contains an implementation named bankServiceImpl.
Up to now everything seems nice and simple, but if your application starts to grow and improve, you’ll probably have many services. This means that your client package we’ll have several service interfaces mixed with your widgets and utility classes.
So to avoid having everything mixed up, you decide to create the next packages:
-com.wordpress.nicozan.client.util
-com.wordpress.nicozan.client.widgets
-com.wordpress.nicozan.client.services

This post will focus in the services package. Inside this package we’ll put the service interfaces that are related to the Async interfaces.
At the moment we compile (mvn clean install ), an error will appear. The error will say that the Async interfaces cannot be found. This problem is because by default the gwt-maven-plugin generates the Async interfaces from the service interfaces located in the client package, and it doesn’t look inside the client sub-packages. The way to solve this problem is by adding 2 tags to the plugin configuration inside the pom.xml:

...
<!-- GWT Maven Plugin -->
 <plugin>
       <groupId>org.codehaus.mojo</groupId>
       <artifactId>gwt-maven-plugin</artifactId>
       <version>2.1.0-1</version>
           <executions>
                 <execution>
                       <goals>
                             <goal>compile</goal>
                             <goal>test</goal>
                             <goal>i18n</goal>
                             <goal>generateAsync</goal>
                       </goals>
                 </execution>
           </executions>
       <!-- Plugin configuration. There are many available options, see
         gwt-maven-plugin documentation at codehaus.org -->
      <configuration>
         <runTarget>MyWebApp.html</runTarget>
         <hostedWebapp>${webappDirectory}</hostedWebapp>
          <i18nMessagesBundle>com.wordpress.nicozan.client.Messages</i18nMessagesBundle>  
         <servicePattern>**/client/services/*Service.java</servicePattern>
         <inplace>true</inplace>
       </configuration>
 </plugin>
...

In the code snippet above, the two important tags are servicePattern and inplace. In the first one, we specify a relative path to where service interfaces are. The second tag, specifies that the generated Async interface have to be located in the same package as its analog service interface.

 

 
Follow

Get every new post delivered to your Inbox.