Friday, August 26, 2011

jBPM5 workshops in Japan and Australia

I'll be doing a set of workshops in September on jBPM5, in Japan and Australia this time. These workshops are a combination of presentations highlighting the various features, combined with practical sessions where you can try it out yourself using simple exercices on your own laptop. A more precise agenda of what will be covered is included in the links below.

Japan:

Australia:

These workshops are free but seats are limited, so be fast and register!

Keith Babo will be doing a SwitchYard workshops on the same locations around the same time, so this might be an ideal opportunity to see both of these projects in action.

Wednesday, August 24, 2011

Text Adventures with Drools

Based on the Adventure in Prolog, over at the Amzi website, http://www.amzi.com/AdventureInProlog/, I started to work on a text adventure game for Drools. They are ideal as they can start off simple and build in complexity and size over time, I think as well they are a nice way to show of declarative relational programming. I know when I first went over the Nani Search text adventure game over at Amzi I thought, that's pretty nifty, true data driven applications.

You can find the latest source in github here, you'll need to be running HEAD or wait for 5.3:
https://github.com/droolsjbpm/drools/tree/master/drools-examples/src/main/resources/org/drools

https://github.com/droolsjbpm/drools/tree/master/drools-examples/src/main/resources/org/drools
You can get the latest HEAD binaries from hudson here:
https://hudson.jboss.org/jenkins/job/drools/lastSuccessfulBuild/artifact/drools-distribution/target/

You can view the 8 minute demonstration and introduction for the example here:

Tuesday, August 23, 2011

Artificial Intelligence Headlines Rules Fest '11

http://hosted.verticalresponse.com/756695/f913bd11ad/1471764023/11698b4526/



rulesfest.org
A conference by developers for developers

Forward this message to a friend

October 24-27, 2011 • Burlingame, CA • Rules Fest 2011

Calling all developers, engineers, programmers, and architects who use reasoning technologies to build products and services





Rules Fest Announces
Dr. Andrew Ng, Director of the Artificial Intelligence Lab at Stanford
& an expert in Machine Learning
will round out the 2011 Rules Fest Conference Agenda



Rules Fest, the International Conference on Reasoning Technologies, was established 3 years ago to present a technical forum by developers, for developers ... the people who are chartered with computational reasoning, the most applied category of artificial intelligence, to further technology development. Given the exhilarating, and sometimes frightening, pace with which technology evolves and its fickle and unpredictable propensity to do so, Rules Fest has diversified its technology portfolio to include powering the semantic web, controlling autonomous agents, and adding intelligence to a myriad of mobile apps. In addition, cloud-based technology offers a value not previously available in the history of computing: data and mechanics are ever-more accessible to developers, making the cloud more practical and efficient. These topics will be presented and discussed -- formally and socially -- at the Rules Fest 2011 conference.

Rules Fest attendees develop Apps That Think.™ Are you one of us?

We invite you to join the Rules Fest Community: the developers, inventors and managers responsible for delivering the innovation and technology that keeps moving the ball forward. In addition to the annual conference held in October, we are developing webinars, papers, virtual boot camps and others tools to share ideas and information within the community.

2011 conference keynotes focus on artificial intelligence
Keynote speakers for Rules Fest 2011 include thought leaders in the area of artificial intelligence: Paul Haley who will present a Roadmap for Rules, Semantics, and Business; Dr. Said Tabet, who will discuss Semantic Technologies and the Cloud: Rules for the Next Generation; and Dr.Andrew Ng, whose Machine Learning and other AI programs presented by Stanford faculty have generated nearly 200,000 registrations this month.

A special early bird package for the October 24-27 conference at the Hyatt Regency Burlingame (just s
Hyatt Regency Burlingameouth of San Francisco) is available for registrants, including:
  • Full conference access: 30 programs, breakfast/lunch/snack each day, free access to the nightly Founders Lounge, free wifi during conference, exhibit, career center access (including posting your resume);
  • One boot camp: technical, hands-on sessions
  • Four nights at the Hyatt Regency Burlingame, including access to the fitness center, Knuckles Sports Lounge, shuttle to shopping and easy access to San Francisco via BART from the airport;
  • Conference shirt (golf or tee)
  • 10% discount off from next year's registration

Register now to take advantage of the early bird discount.

Conference General Admission registration is available for $449 for those who do not need a hotel. Special early pricing for individual boot camps is also available at a cost of $249 per session. A discounted rate of $149/night is offered by the Hyatt Regency Burlingame until September 30, 2011.

Confused about reasoning technologies? Review the wikipedia posting to see where your interests lay or what system types may apply to your requirements.

Join the dialogue:

LinkedIn.com: Groups - Rules Fest
LinkedIn Groups: Rules Fest

Like us on Facebook: Rules Fest
Like us on Facebook: Rules Fest

Follow us on Twitter
Follow us on Twitter: @rulesfest



Rules Fest is a conference for all levels of skills. Unsure about Rules Fest? Need more info? Contact us.


Red Hat|JBoss is a Super Platinum sponsor of Rules Fest 2011

Red Hat|JBoss is a Super Platinum sponsor of Rules Fest 2011



Thursday, August 18, 2011

jBPM Form Builder project follow-up

We're currently working on a series of addins and refactors to make the form builder more user friendly. For starters, the UI was changed a bit to be less of an eyesore, as you can see on this snapshot:



Also, work has started on the following subjects, that have been waiting for a while:

Inserting elements in a layout: You can see this on the screenshot. You don't have to worry any more of getting the elements in the correct order, now you can add an element to any posible position in the current layout (as long as it obeys the laws of that layout. ie, you coulnd't add something to the right or left of an element on a vertical layout)
Work on this subject will continue to allow already dropped UI components to be moved, by right-clicking on it and selecting "Move"
Validation attachment: Validations can be added since a few posts back, but so far, the only validation available to add is "Not empty". Also, there wasn't a representation of these validations, either on client or in server side. These are some of the things that I'll be working on next week.
I18N of labels and such: These aspect of form design is something yet to be properly defined. Most fields on a form will have an explainatory label, and so, will be needing a way to configure that label according to the user's language. For such, a display will be added (and accessible by right clicking on a text and selecting "Internationalize") to show different flags and associate the proper message for each language.
L10N helpers for labels and such: For the same reason as i18n, l10n might be a delicate subject for forms that should show currencies and number punctuations.
Event handlers: Every change and every action a user takes on the form, either in HTML or any other display, will fire different kinds of events. By right-clicking on different ui components and selecting "Event handling", you will be able to manage actions to be taken for such events, that might go from a communication to a server to the full client-side updating of the form.
Using RestyGWT for client server communication: This framework allows developers to create simple Resteasy clients in GWT, and it will provide a much needed cleansing to the client server communication layer of the form builder.

For any doubts or questions, feel free to comment below

Cheers from Argentina

Friday, August 12, 2011

Emergency Services V3: Proposed features

This blog post is to share with the community the roadmap of the emergency service application for the third iteration.
This application was designed to show how to architect an application using Drools and jBPM5. The application demonstrate several features of each project module and we are trying to add and complete the application with more and more features through different iterations.

Proposed Features

This third iteration is focused on adding the following features into the application:

1) Improve the current architecture of the application making the standard procedures more generic and flexible.
2) Add backward chaining features
3) Add planner features

To be able to add all these features in the application we will be first focused in improving the business procedures always adding more features visible to business users. We are adopting this approach to highlight the way of solving problems and architecting applications using the power of the declarative approach proposed by these tools.

Spending time on the technical side of the application is not a priority at this point. We will be changing the design and the components during next iterations, but we encourage the community to helps us on very specific technical problems or giving feedback about the proposed design.

From the business use case side the following procedures and features will be added:

Generic Emergency Procedure

This procedure will be executed for each emergency call that is received at the central offices. For this reason, this procedure will be hosted and empowered by a different set of services to support and execute a generic set of tasks required to deal with every new emergency.

The big change compared with the old version is that now each emergency will have a one-to-one relationship with the information generated by all the internal procedures.

The generic procedure instance will be in charge of maintaining the relationship between all the specifc procedure instances required by the emergency.

Procedures Relationships with Emergencies

Now each specific procedure will be in charge of notifying to the parent generic procedure.

This design change (in contrast with a completely decoupled procedures approach) will help us to keep track of the task that are being executed. Allowing us to have two levels of reports:
1) High Level Report: about the whole service (end-to-end) usually consumed at the end of all the activities
2) Local Report to each specific procedure (localized) usually online

Generic Emergency Procedure

Default Heart Attack Procedure

This procedure covers a heart attack situation that involves an ambulance that needs to be sent to the emergency location. A hospital will be selected based on the situation and the location of the emergency and the ambulance driver will be notified about this selection. The patient vital signs will be monitored in real time to notify the central about the status of the patient.

Default Heart Attack Procedure Single Patient

AD-HOC Procedure

As you may notice the generic emergency procedure allows the company to decide and select which procedures are appropriate for a specific situation in a quick and well defined manner. For doing this selection the contextual information and human interaction is used to quickly deal with the current emergency. But what happens if we want to start a procedure on an ongoing emergency? What happens if we receive information from an external source that affects the company behavior when all the procedures were already started? The company will need a way to Attach and Detach dynamically new procedures to emergencies based on the information that we are receiving from external sources. If we found one if this situations, we don’t want to trigger a complete new emergency and we will not have another phone call that triggers the generic emergency procedure. For this kind of situations we will have the following simple process that will allow us to attach a new procedure to an existing emergency.

Ad-Hoc Procedure

Multi Injured People Emergency Procedure

Similar as the Default Heart Attack Situation we have defined a generic purpose procedure to deal with emergencies that require a set of ambulances to be dispatched to the emergency location.

Multi Injured People Emergency

Start Tracking y Stop Tracking should attach and detach a vehicle to the tracking system.

Multi Fire Truck Emergency Procedure

For emergencies that involve fire we need to coordinate trucks from the firefighters department. The following procedure deals with selecting the number of trucks and monitoring each truck water supply during the emergency.

In this case instead of receiving the patient vital signs we will receive periodical updates about the truck water supply and the fire situation in order to decide if we need to dispatch more trucks or if the situation is under control.

Fire Emergency Multi Truck

Using the ad-hoc procedure we can start as many of this procedures as we want for an emergency.

Generic Bank Robbery Procedure

This very different procedure will be used for bank robbery situations. In this procedure we need to coordinate police cars in order to deal with a bank robbery.

Generic Bank Robbery

Some new components

We need to add to the application infrastructure new components to deal with very specific topics. Some of these modules are very basic but they will helps us to show a realistic application architecture allowing us to show how each of these specific topics can be abstracted from the application infrastructure.

The following list covers most of these new components:

  • CRUD users / Groups
  • Entities Administration
  • Hospital Service
  • Police Department Service
  • Firefighter Service
  • Entities Monitor Service
  • Emergency Tracking/Context component

CRUD Users / Groups

Simple screens and back end service to abstract where the users that can interact with the application will be stored and retrieved.

Entities Administration

Entities can be any external source that bring services that can be coordinated by the emergency service company. Each entity can be defined as Input, Output or Input/Output entity.
This relationship will tell us if we can interact with the external entity or if we will just receive information updates from that entity.
INPUT/OUTPUT entity: Hospital, Police Department, FireFighters Department.
INPUT entity: traffic service, phone number recognition service.

Hospital Service

This service will be in charge of sending us periodical updates about their availability. We will have one instance of this service per hospital that the emergency service is coordinating. This service will also allow us to send request for new patients when we are dealing with an emergency with injured people.

Police Department Service

This entity will allows us to request for police cars to go to a specif location. This service will be also sending updates about the police cars availability that they have. This service will be used in conjunction with the tracking service to attach and detach monitored vehicles.

Firefighters Department Service
This entity will allows us to request for fire trucks to go to a specif location. This service will be also sending updates about the trucks availability that they have. This service will be used in conjunction with the tracking service to attach and detach monitored vehicles.

Entities Monitor Service

Real time monitor to analyze and receive the updates of all the external entities. This will be a Log like console with an alert box that shows us when specific situations are found.

Emergency Tracking/Context Component

This component will be in charge of allowing us to attach different activities and entities to a specific emergency. This tracking component will allows us to scope information for each specific emergency.

Some of the methods that this service will expose are:

ID newEmergency()
ID newProcedure(emergencyId)
void attachProcedure(emergencyId, procedureId)
void detachProcedure(procedureId)
ID newVehicle()
void attachVehicle(procedureId, vehicleId)
ID newServiceChannel(emergencyId)
This service should also bring a domain specific query interface that allows us to retrieve the information for each specific emergency and all the relationships with all the attached entities and services.

Sum up

The new version that we are planning will allow us to build and show more complex scenarios. Exposing all the tools that we need to adapt the application to new use cases and support mixed scenarios where we cannot predefine all the actions that needs to be executed. The main purpose of this post is to show the ideas that we have in the top of our head and encourage the community to contribute adding ideas or things that you want to see in the app. Consider this post as a brainstorm about the things that we will be doing this next month. You can always track our advances and download the code here: https://github.com/Salaboy/emergency-service-drools-app
For more information about the application you can take a look here:
http://salaboy.wordpress.com/2011/05/28/emergency-services-v2-jbpm5-and-drools-blueprint/

Or follow us on twitter: @calcacuervo @ilesteban @salaboy

Thursday, August 11, 2011

OpenNMS integrates Drools for Correlation

http://www.opennms.com/twio-drooling-all-over-your-network/

"Meet the New Drools, Same as the Old Drools

For a long time now, OpenNMS has had a little-known feature for doing event correlation, using the open-source Drools business logic engine. It is little-known because we have gone out of our way not to tell people about it — somewhere in the transition from OpenNMS 1.2 to 1.6, it broke because of a complicated chain of dependencies. Thanks to the work of the enigmatic Seth, Jetty and Drools are once again in agreement on their dependencies, and I’ve confirmed that it’s working as of this morning’s code (which should be available in tomorrow’s nightly snapshots).

The correlation engine lets you do complex workflows and event processing (including detection of flapping). We have a couple of examples of what can be done in the $OPENNMS_HOME/etc/examples/ directory. If you’d like to try them out, just copy the following files into your etc directory:

correlation-engine.xml
Configures the correlation engine daemon. Since the OpenNMS correlation engine is a generic API that could potentially be implemented using multiple business logic implementations, this configuration tells OpenNMS which engines are available. Currently, the only implementation is the Drools engine.
drools-engine.xml
Configures the Drools correlation engine. This file contains the Drools-specific configuration for event correlation. In it you define tags which refer to the code, events, and other variables that are relevant.
LocationMonitorRules.drl
An example Drools correlation rule which can detect flapping outages from remote pollers.
NodeParentRules.drl
An example Drools correlation rule which can do root cause analysis on node outages based on a node parent outage.
nodeParentRules-context.xml
A spring configuration file to provide extra resources to the “node parent” Drools rule.

Then, edit your $OPENNMS_HOME/etc/service-configuration.xml and uncomment the service named “OpenNMS:Name=Correlator” and restart OpenNMS.

Other than that, using Drools is not very well documented yet, but if you are a Java developer, you should be able to work out what’s going on looking at the rules and configuration files."


Use Drools for Home Automation using OpenHAB

http://code.google.com/p/openhab/wiki/Drools

"Introduction

The open Home Automation Bus (openHAB) project aims at providing a universal integration platform for all things around home automation.

It is designed to be absolutely vendor-neutral as well as hardware/protocol-agnostic. openHAB brings together different bus systems, hardware devices and interface protocols by dedicated bindings. These bindings send and receive commands and status updates on the openHAB event bus. This concept allows designing user interfaces with a unique look&feel, but with the possibility to operate devices based on a big number of different technologies. Besides the user interfaces, it also brings the power of automation logics across different system boundaries."

...

"Defining the When clause (LHS)

The when clause (LHS) of a rule should contain conditions based on the objects in the working memory, i.e. items and events.

Here is an example of a when clause:

        $event : StateEvent(itemName=="Rain", changed==true)

$window
: Item(name=="Window", state==OpenClosedType.OPEN)

Tuesday, August 09, 2011

Drools 5.3.0.Beta1 released (including Expert, Fusion, Planner and Guvnor)

We're happy to announce the release of Drools (Expert, Fusion, Planner, Guvnor) 5.3.0.Beta1.
Try it out and give us some feed-back (user list, issue tracker).

Sunday, August 07, 2011

Construction heuristics benchmarks

Drools Planner 5.3.0.Beta1 will include out-of-the-box construction heuristics. Before running metaheuristics (such as tabu search) on a use case, it's important to first run a construction heuristic on it, as that greatly improves the score. These construction heuristics are already implemented for Beta1:
  • First Fit
  • First Fit Decreasing
  • Best Fit
  • Best Fit Decreasing
They are drop-in replacements for your custom StartingSolutionInitializer implementation, which - if you copied the examples - were First Fit Decreasing implementations. Such a StartingSolutionInitializer is pretty difficult to write, pretty long and can easily contain invisible bugs. Now, it's far easier: just configure a construction heuristic instead:

<solver>
  ...
  <constructionheuristic>
    <constructionheuristicType>FIRST_FIT</constructionheuristicType>
  </constructionheuristic>
  <localSearch>
    ...
  </localSearch>
</solver>

That's a lot less code, isn't it? Some construction heuristics (such as FIRST_FIT_DECREASING) do require you to implement a simple difficulty Comparator (more info in the manual).

If you're keen on your custom StartingSolutionInitializer 's boilerplate code, you can still use that too of course. Although it probably doesn't support these features that the construction heuristics implementations do:
  • Immediate termination
  • Start with a partially initialized solution (needed for real-time planning)
    So which construction heuristic is better?
    Well, let's use the Benchmarker to find out. Below are some benchmarks on different examples. Note that construction heuristics should be suffixed with metaheuristics (such as tabu search): these scores are just the starting scores for the more advanced optimization algorithms (metaheuristics), they are not the final scores for these use cases.

    PatientAdmissionSchedule (hospital bed planning)

    Notice that the Best Fit Decreasing (purple) is better than my original StartingSolutionInitializer (red) for at least 2000soft on these 3 datasets. The latter took me a lot longer to implement, yet it's worse. In some cases, tabu search takes over 10 minutes to compensate for that difference in starting score! I 'll talk about that, the importance of phasing, in a later blog.


    Nurse rostering

    In this use case, First Fit and Best Fit win, but it's not significantly better than the StartingSolutionInitializer. In fact, the StartingSolutionInitializer behaves exactly like First Fit Decreasing. The Decreasing variants are university worse than the non-decreasing variants. That's big, fat indication that I should take a look at my difficulty Comparator implementation (which is used by the Decreasing variants an my original StartingSolutionInitializer): it's probably wrong.


    So how long does it take to run these constructions heuristics? Not long, just a few seconds:


    CloudBalance

    In this case, First Fit and Best Fit don't have a feasible solution for the 3th dataset. First Fit Decreasing wins.


    Overall, First Fit Decreasing is better, even though Best Fit and Best Fit Decreasing take a few milliseconds longer:


    Summary

    Using a good construction heuristic is a vital part of getting the better solutions for planning problems. It gives the metaheuristics a head start.

    Declarative agenda and control rules

    From the thread here:
    http://drools.46999.n3.nabble.com/Declarative-Agenda-td3232818.html

    I just got a first cut working for "declarative agenda". The idea here is rules can control which rule can or cannot fire. Because this is highly experimental it is off by default and users must explicitely enable it, it will stay this way until we are happy with the solution. My hope is that it will provide a more declarative approach to execution control; which will enable more readable and maintainable rules compared to using magic salience values and in some circumstances control objects.
    KnowledgeBaseConfiguration kconf = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
    kconf.setOption( DeclarativeAgendaOption.ENABLED );
    KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase( kconf );
    The basic idea is:
    • All matched rule's Activations are inserted into WorkingMemory as facts. So you can now match against an Activation the rules metadata and declarations are available as fields on the Activation object.
    • You can use the kcontext.block( $a ) for the current rule to block the selected activation. Only when that rule becomes false will the activation be elegible for firing. If it is already elebible for firing and is later blocked, it will be removed from the agenda until it is unblocked.
    • An activation may have multiple blockers, all blockers must became false, so they are removed to enable the activation to fire
    • kcontext.unblockAll( $a ) is an over-ride rule that will remove all blockers regardless
    • @activationListener('direct') allows a rule to fire as soon as it's matched, this is to be used for rules that block/unblock activations, it is not desirable for these rules to have side effects that impact else where. The name may change later, this is actually part of the pluggable terminal node handlers I made, which is an "internal" feature for the moment.

    I should be committing this later today, and will send a follow up email once it hits HEAD, but here is a unit test. It uses a control role to stop all rules with metadata declaring the rules to be in the "sales" department. Only when that control rule becomes false can they fire.
    package org.domain.test
    import org.drools.runtime.rule.Activation
    global java.util.List list
    dialect 'mvel'

    rule rule1 @department('sales')
    when
    $s : String( this == 'go1' )
    then
    list.add( kcontext.rule.name + ':' + $s );
    end
    rule rule2 @department('sales')
    when
    $s : String( this == 'go1' )
    then
    list.add( kcontext.rule.name + ':' + $s );
    end
    rule rule3 @department('sales')
    when
    $s : String( this == 'go1' )
    then
    list.add( kcontext.rule.name + ':' + $s );
    end
    rule blockerAllSalesRules @activationListener('direct')
    when
    $s : String( this == 'go2' )
    $i : Activation( department == 'sales' )
    then
    list.add( $i.rule.name + ':' + $s );
    kcontext.block( $i );
    end
    KnowledgeBaseConfiguration kconf =  KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
    kconf.setOption( DeclarativeAgendaOption.ENABLED );
    KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase( kconf );
    kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
    StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();

    List list = new ArrayList();
    ksession.setGlobal( "list", list);
    ksession.insert( "go1" );

    FactHandle go2 = ksession.insert( "go2" );
    ksession.fireAllRules();
    assertEquals( 3, list.size() ); // none of the rules 1-3 fire, as they are blocked.
    assertTrue( list.contains( "rule1:go2" ));
    assertTrue( list.contains( "rule2:go2" ));
    assertTrue( list.contains( "rule3:go2" ));

    list.clear();

    ksession.retract( go2 ); // the blocker rule is nolonger true, so rules 1-3 can now fire.
    ksession.fireAllRules();

    assertEquals( 3, list.size() );
    assertTrue( list.contains( "rule1:go1" ));
    assertTrue( list.contains( "rule2:go1" ));
    assertTrue( list.contains( "rule3:go1" ));

    ksession.dispose();

    Update
    I have now committed this work to master and you can checkout the comphensive tests to see how it works here:
    https://github.com/droolsjbpm/drools/blob/master/drools-compiler/src/test/java/org/drools/integrationtests/DeclarativeAgendaTest.java

    Friday, August 05, 2011

    Why you should learn Drools - Java / Drools 5 Developer - Fixed Income Trading - (rate to 1000/day)

    I saw this job over at Dice, I thought it was a good endorsement as to why you should be learning Drools. Both due to the interesting nature of it's work and the high daily rate involved :)
    ---
    Java / Drools 5 Developer - Fixed Income Trading - to 1000/day corp
    New York, NY


    Top investment bank needs a solid Core Java / Drools 5 Consultant to work on a cutting edge Fixed Income eTrading system. In this position you will be a hands-on developer with responsibility for developing a real time trading system for credit products (CDS, corporate bonds, indexes, etc). This role will require solving challenging software engineering problems, interacting with business users and learning the trading and risk management aspects of the credit business. The ideal candidate will be a strong developer capable of taking on end-to-end responsibility for user-facing system features, and coming up with strategic and tactical architecture/design.

    The client is a top tier investment bank and is looking for exceptional Java development talent. They are willing to consider candidates that do not currently work in the investment banking industry. Bring your solid Core Java, J2EE and Drools 5 skills and they'll teach you the fixed income trading business!

    Required Skills:
    4-7 years of Java/J2EE development experience; 3-5+ years of multi-threading and real-time programming experience; Current or very recent experience with Drools 5 required; Current or very recent investment banking and/or hedge fund experience is a strong plus; Development experience in a Unix/Linux environment; Exposure to the Fixed Income business is a very strong plus; and a Bachelors or Masters degree in a quantitative field preferred

    Contact:
    Forward resumes to cjordan@archertechnology.com and/or call 201-477-8084 for details.

    jBPM Form Builder integration: Make a process work without any code at all!

    Greetings again. It's been a few weeks since my last update, but i bring some very exciting news. The jBPM form builder can finally work integrated with guvnor! You can see in the following video how you can create forms, edit them, and use them almost inmediately:


    jBPM Form Builder integrated

    By editing both the process and the forms associated with that process, we can provide an interface ritch enough to let people define and use executable processes without having to touch any code.

    This will eventually be integrated witht the main build, and there are still some issues to resolve with the form builder. But for the moment, for those eager to try it out, a will make a downloadable demo available pretty soon.

    Hope to hear your comments and everyone have a great weekend!

    Tuesday, August 02, 2011

    Release: Call to Relieve Constraints on AI


    Rules Fest 2011

    PRESS RELEASE

    Forward this message to a friend








    The Need to Relieve Constraints on Artificial Intelligence

    Addressed at Rules Fest 2011

    Veteran AI Leaders Paul Haley and Said Tabet Slated to Address Developers



    San Francisco, CA, August 2, 2011– Organizers today posted the abstracts for keynote speakers for Rules Fest 2011, the International Conference on Reasoning Technologies, a conference by developers for developers scheduled for the San Francisco Bay Area this October 2011.

    In a session titled “Roadmap for Rules, Semantics, and Business,” Paul Haley, who has been working to commercialize artificial intelligence for more than three decades, says understanding the requirements for semantic technology in enterprise vs. the capabilities of rules engines exposes the need for more classic artificial intelligence and reasoning in our technology, more emphasis on knowledge than rules in our services, and more emphasis on knowledge technology strategy in the executive suite. Haley will discuss the challenge that while semantic technology is inevitably mainstream, it remains largely divorced from the activity of knowledge engineering as practiced using business rule engines embedded within business process management or complex event processing systems.

    Semantic technology encodes meanings separately from data and content files, and separately from application code. This enables machines as well as people to understand, share and reason with them at execution time. Semantic technologies make it easy to add, change and implement new relationships or interconnecting programs in a different way. For example, a context-aware, semantically-enabled system is able to distinguish terms that are labeled differently but have the same meaning, as well as terms that share the same label but have entirely different meanings.

    Cloud trust, information governance, risk management, and compliance, distributed systems, mobile applications all offer a unique opportunity to realize the true potential of knowledge technology. These systems are usually covered by service level agreements that are rules-based.

    Dr. Tabet’s discussion, “Semantic Technologies and the Cloud: Rules for the Next Generation,” addresses the major challenges in information management while the business environment also witnesses the drastic shift to cloud computing. Dr. Tabet will address the trend of constraining artificial intelligence and knowledge technologies in legacy environments, and says enterprise knowledge management needs strong semantic technologies, powerful inferencing systems, and advanced machine learning capabilities – not more sophisticated spreadsheets. Dr. Tabet was a co-founder of the RuleML Initiative in 2000, involved in artificial intelligence and its applications for well over a decade. He recently refocused his efforts on RuleML and Business Rules, XML, RDF and the Semantic Web as well as deductive reasoning in financial services.

    Rules Fest, hosted by the non-profit Rules Fest Association, is a technical conference geared toward software developers, engineers, programmers and architects who create solutions to complex computing problems using reasoning technologies: rule-engines, logical reasoners, constraint-solvers, and other such building-blocks of practical artificial intelligence (AI). More than 200 developers, engineers, programmers, and architects
    from around the globe are expected to attend the conference in Burlingame, California.

    The conference will also feature a Career Center to address the war for developer talent in technology companies. Companies seeking advanced programming talent are invited to submit their open positions for posting at no charge.

    Conference Fee and Package Pricing
    The standard fee for the conference is $499. All bootcamps – addressing specific programming challenges and technologies -- are $299. For a limited time, Rules Fest organizers are offering an early bird rate of $1249 including an all-access conference pass, four nights at the Hyatt Regency Burlingame, a boot camp of choice, and 10% off from next year’s conference. This “early bird” rate is available until September 30. Early discounts are also available for general admission and for bootcamps without a hotel stay. To register, attendees should visit the conference registration site on the conference website.

    About Rules Fest
    The non-profit Rules Fest™ Association, Inc. produces the annual Rules Fest conference, the world's only technical conference devoted to the practical application of all reasoning technologies.

    For a better understanding of reasoning systems, visit http://en.wikipedia.org/wiki/Reasoning_System.

    © Copyright 2011. All rights reserved. Rules Fest is a trademark of Rules Fest Association.

    For information, contact info@rulesfest.org
    Media contact: brenda@visionartscommunications.com

    Drools & jBPM5 Sessions Argentina - June 17th 2011

    Hi everyone, I’ve just finished to upload the videos that we get from the last Drools Sessions in Buenos Aires, Argentina. All the talks are in English except mine about the Emergency Services application that is in Spanish.

    All the talks are hosted in Vimeo, so feel free to publish the talks in different sites to spread the word about Drools & jBPM5.

    I will try to write some reviews in my personal blog about each talk highlighting the topics that are covered in each of them.

    Enjoy!



    Drools Workshop Argentina - Expert System Introduction (Mark Proctor) from salaboy on Vimeo.




    Drools Workshop Argentina - Drools Fusion (Edson Tirelli) from salaboy on Vimeo.




    Drools Workshop Argentina - jBPM5 Workflow Overview (Kris Verlaenen) from salaboy on Vimeo.




    Drools Workshop Argentina - Decision Tables Introduction (Michael Anstis) from salaboy on Vimeo.




    Drools Workshop Argentina - Drools Planner (Geoffrey De Smet) from salaboy on Vimeo.




    Drools Workshop Argentina - Emergency Services (Salaboy) from salaboy on Vimeo.

    This talk is in spanish, but you can find more information about the Emergency Services Application here: http://salaboy.wordpress.com/2011/05/28/emergency-services-v2-jbpm5-and-drools-blueprint/




    Drools Workshop Argentina - Imperfect Reasoning (Davide Sottara) from salaboy on Vimeo.




    Drools Workshop Argentina - Drools & Large Data Sets (Alexandre Porcelli) from salaboy on Vimeo.




    Drools Workshop Argentina - Next Gen JBoss Tech (Ray Ploski) from salaboy on Vimeo.






    Original posts:

    http://salaboy.wordpress.com/2011/07/22/drools-workshop-in-argentina-june-17th-2011/

    http://salaboy.wordpress.com/2011/08/03/drools-workshop-in-argentina-june-17th-2011-cont/

    Monday, August 01, 2011

    Call for Demos: RuleML2011 - 5th InternationalRule Challenge

    RuleML is just around the corner and will be in Fort Lauderdale this time.

    The RuleML Challenge sessions are always interesting and fun and a great way to show case your work and get noticed. So hurry up and submit now :)

    If you aren't sure that your work it suitable to submit, just email me and we will be happy to discuss it with you.

    Mark

    ==========================================
    Overview and Aim
    The RuleML2011@BRF Challenge is one of the highlights at RuleML2011@BRF Conference.The RuleML2011@BRF Challenge is dedicated to practical experiences with rule-oriented applications. In particular, submissions of benchmarks / evaluations, demos, case studies / use cases, experience reports, best practice solutions (e.g. design patterns, reference architectures, models), rule-based implementations / tools / applications, demonstrations of engineering methods, implementations of rule standards (e.g. RuleML, RIF, SBVR, PRR, rule-based Event Processing languages, BPMN+rules, BPEL+rules, ...), rules + industrial standards (e.g. XBRL, MISMO, Accord, ...), and industrial problem statements are particularly encouraged.

    Key themes of the RuleML2011@BRF Challenge include the following:
    • Demos related to the RuleML2011@BRF Track Topics
    • Extensions and implementations of rule standards: W3C RIF, RuleML SBVR, ...
    • Editing environments and IDEs for Web rules
    • Benchmarks and comparison results for rule engines
    • Distributed rule bases and rule services
    • Reports on industrial experience about rule systems
    A dedicated track of RuleML2011@BRF Challenge will be focused on the theme:
    **Combining Rules, Objects, and Ontologies: Implementations and Applications**
    • Loose/tight integrations of rules and knowledge bases
    • Knowledge Modelling and Reasoning
    • Real cases and practical experiences
    Ideally, demos submitted to the Challenge track should tackle knowledge-rich domain problems. The proposed solution should address such problem using a combination of rule-based modelling and semantic knowledge-based modelling. Solutions ranging from loosely coupled hybrid systems (i.e. where different frameworks are put together), to unified homogeneous architectures (i.e. where a unified model / semantics, within a single framework, is proposed) will be of great interest for the special track.

    Prizes will be awarded to the two best applications from the main focus theme and for the all categories. All accepted demos will be presented in a special Challenge Session.

    Submission
    The submission is composed of two parts:
    • open-source or commercial demo
    • demo papers describing research, implementation, and technical details of your submission.
    Submissions to the Rules Challenge 2011 consist of a demo paper of 4-8 pages, describing the demo show case, and a link to the demo/show case, e.g. a project site, an online demonstration, a presentation about the demonstration, or a download site for the demonstration.

    Demo and papers submission website:
    https://www.easychair.org/conferences/?conf=ruleml2011challenge

    Please upload all demo papers submissions as PDF files in LNCS format
    (http://www.springer.de/comp/lncs/authors.html).

    To ensure high quality, submitted papers will be carefully peer-reviewed according to the evaluation criteria indicated below.

    To better disseminate your work, please also udpate your demo in the systems submission website with a brief abstract presentation:

    http://2011.ruleml.org/america/?page_id=184

    Challenge Evaluation Criteria
    Submissions to the RuleML2011@BRF Challenge general Track will be evaluated according to the following criteria:
    • clear exposition of the objectives, outcomes, benefits for going beyond the state of the art in the application domain (25%)
    • demos should demonstrate a good level of effectiveness to manage complex rules according to statistical/analytical/benchmarking evaluations (25%)
    • demos have to demonstrate the results with a concrete example balancing conciseness and completeness (25%)
    • demos should preferably (but not necessarily) be embedded into a web-based or distributed environment (15%)
    • demos should pay attention to end-user interactions, providing an adequate and usable interface that favors a concrete usage of the application (10%).
    Submissions focused on this year's special theme (Knowledge-Based Applicationscombining Rules and Ontologies) should show the potential and benefits of combining rule-based reasoning and taxonomic/frame/description-logic reasoning in a realistic application. Demos submitted to the Special Theme will be evaluated according to the following criteria:
    • papers should clearly expose the objectives, outcomes, benefits for going beyond the state of the art in the application domain (20%)
    • demos should demonstrate a good level of integration or interaction between rules and ontologies (40%)
    • demos should demonstrate their results with a simple but meaningful case study, balancing conciseness and completeness (20%)
    • demos should preferably be deployed in a web-based or distributed environment where multiple nodes exchange information (10%)
    • demos should pay attention to end-user interactions, providing an adequate and usable interface that favors a concrete usage of the application (10%).
    Proceedings
    Authors are invited to submit original contributions of practical relevanceand technical rigor in the field, benchmarks, evaluations, experience reportsand show/use case demonstrations of effective, practical, deployablerule-based technologies or applications in web-distributed environments. Papers must be in English. Accepted papers will be published as CEUR Workshop Proceedings.

    Exhibition Room
    The RuleML2011@BRF Chairs are currently evaluating the possibility to have an exhibition space where to present the demo live to the participants throughout the Symposium.

    More information will be released with the notification of acceptance of the demo papers and demo systems.

    Important Dates
    Submission deadline for demo papers and demo systems: Sept. 2nd, 2011
    Notification of accepted demo papers and demo systems: Sept. 23rd, 2011
    Camera ready papers: Sept. 30th, 2011

    RuleML2011@BRF Challenge Chairs
    Stefano Bragaglia, University of Bologna, Italy
    Marco Montali, KRDB, Free University of Bozen-Bolzano, Italy
    Charles Petrie, Stanford University, USA
    Mark Proctor, Red Hat, UK