(Find the Dutch version in this article)
(Find the Spanish version in this article)

Some time ago, Alfresco, Signavio and Camunda started Activiti, an open source alternative for enterprise BPM. The

first question that crossed my mind was “why a new BPM engine”? Basically, there are some reservations about the jBPM Alfresco implementation in the areas of developing and controlling processes. Alfresco had more reasons to reconsider an (embedded) BPM engine. There are customer considerations against limitations to the LGPL license (or the perception thereof) which is why the Activiti project is developed under the Apache 2 license.

Vision

JBPM is a ‘technically oriented’ BPM engine. The Activiti project’s vision is that it should be a lightweight engine, easy to use (for Java developers) and that ‘workflow’ could also be social. Remind the could be. The Activiti project does not prescribe how an organization should use BPM, but it wants to facilitate collaborating around the business process.
Traditionally, the development of (business) processes is the ‘analysts’ domain. This role develops process diagrams, defines the flow of jobs, defines to what role a job is assigned, and what automated steps take place. Next in line, the ‘developers’ create “executable code” of it. Activiti has a number of elements in it which can facilitate collaboration among the roles involved like analysts, managers and developers.

First, Activi utilizes BPNM2.0, the now widely accepted open standard for process modeling. The beauty of this 2.0 version of the standard is that next to the schema language, the underlying defining XML standardized as well. Activiti can directly execute this XML. This has the advantage that the analyst and the developer work on the same process scheme and therefore underlying XML. They can read each other’s work, and actually work on the same schema’s. That will do a lot for the effectiveness of communication. Activiti also provides an additional module where all roles involved are facilitated to collaborate in a ‘2.0’ style, and improve the process of developing business processes, and improve existing ‘running’ process definitions. I will elaborate on this later in this article.

For Alfresco the Activiti path is a well thought out decision. Two of the founding fathers of jBPM actually joined

Alfresco in order to achieve this open source BPM engine. Alfresco already had the experience of running an open source project because it is open source itself. Next to that they have run the Apache Foundation-route before when they created the OpenCMIS project, now included in the Apache Chemistry project. (Did I mention SpringSurf Alfresco developed and donated to SpringSource? Quite some open source activity here…)

The concept

For ease of explaining, let’s assume that in the development and operation of BPM processes the following four roles are involved:

• The analyst has understanding of the business domain and defines processes and tasks.
• The developer creates the executable code, to fill in the automated tasks and lookups as resulted from the analysts work.
• The process participant is any person in the organization that gets a task assigned in running business processes.
• The administrator is the role that ensures that the BPM system will operate. Tasks that ‘get stuck’ or processes that fail can be restarted, removed or reassigned. This role is understanding why processes function as they do in terms of errors, performance etc.

I will explain the modules of Activiti using the chart below.

Activiti Engine

The heart of the system is the Activiti Engine. This is the work horse where BPNM2.0 XML format is ‘imported’ and depending on the logic the described process steps are created and dispatched. This advanced engine has an extremely low overhead in terms of memory usage and database storage/manipulation. The engine generates jobs that can get assigned to individuals / groups / roles. There may also be “system tasks” defined that can do all kind of automated tasks. Think of document manipulations in a DMS (using CMIS?), communication with other systems using web services for example, changes in (external) databases, etc. Processes that are no longer active are moved to an archive, to improve on execution speed.

Activiti comes with many types of activities / tasks. Next to that a simple Java API exists that enables organizations to define their own tasks. If a basic set of functionality is implemented these tasks can be graphically modeled and the engine can execute. This way, the custom activity can be reused and configured by the analyst using the graphical user interface.

The Activiti Engine is as open as possible. Besides extensive access through the Java API, you can access a REST interface to query and control the application. This means that the applications which make use of the Activiti Engine not necessarily have to be programmed in Java. This allows presentation of the task list in applications build in languages like PHP or .NET. The Activiti Engine can be queried in many ways to generate work lists, metrics,  ongoing processes etc. etc. Think of searching running processes, using the numerical value of an attribute is greater than x, sorted by start date.

Activiti is designed as an enterprise grade BPM engine, thus is also scalable. It is prepared to function in the cloud, instances of the engine can run in parallel if desired, and it integrates seamlessly into an existing application for example using the Spring framework.

The last feature I want to be mentioned is the ability to automate the testing process. There are facilities built to test using JUnit (version 3 and 4) to test the process. This is great news because it saves a lot of clicking to the many paths of a process to go through. This is a process facilitated by the engine deploy, run and undeploy the process definition. All steps can be executed, where automated tasks like sending email can be (temporarily) switched off. Using the JUnit results it can be determined whether the business logic in the process is working as intended.

Activiti Explorer

The Activiti Explorer is the user interface for the process participants. Here the personal and group task lists can be found. Group tasks can be claimed, and tasks can be completed. This means that data in a form can be completed or process choices can be made. Tasks can be reassigned to other users, and ad-hoc tasks can be created and assigned to anyone on the spot. Similarly, a user can ad-hoc create sub-tasks to divide a task into a number of smaller assignments.

Activiti Modeler

Activiti Modeler was developed by Signavio. The Modeler is a web application in which processes can be modeled using the BPMN2.0 schema. The process definitions are stored in BPMN2.0 XML format stored on the server. Like the SpringSurf framework the modeler communicates to the server via JSON. In the default configuration, the Activiti process definitions will be stored on the servers file system.

Activiti Designer

Activiti Designer is an Eclipse plugin. In this way, the developer can work on both the process XML and the graphical schema and the code in the same developer environment and easily switch between the related pieces of logic. Basically it does just exactly what you’d expect.

Activiti Probe

Activiti Probe provides an overview of running processes. This application is typically for administrator-like roles. Here you can monitor if the BPM engine is still functioning, how the resource usage is doing, and check up on the log files. Process instances can be deployed into the engine. If the process unexpectedly fails, running tasks can be restarted, reassigned, or the process be stopped or restarted.

At present Activiti Probe is “limited” to display system settings and relevant database tables. This is in my opinion already much better than the ‘web based command line tool’ that is currently shipped with Alfresco version of JBoss. However, it is not yet what one would expect of an Enterprise tool. A graphical tool with more management possibilities and more ways of finding running (or failed) processes, is in the pipeline.

Activiti Cycle

Activiti Cycle is the module where the social, collaboration aspect is located. BPM traditionally is the domain of business analysts. On the other hand, the developers combine the flow with the (custom) logic, make it communicate with repositories and ‘make the process work’. Activiti Cycle is an environment focused on collaboration with the process in its center. Processes can have relations with “artifacts” such as (for example Visio, Office, CAD) files, Maven repositories, Jira issues, a source code repository (like SVN). All roles involved in the creation,  and execution of a process can collaborate and discuss about the related processes and artifacts in context. There are many features that could be used, but the tool does not force off ‘how to do it. “ Depending on how an organization intends to deal with the process of mastering BPM, the tool can be used accordingly. Various benefits can be gained, like people are more involved, solutions become more realistic (i.e. successful), and the design / development process is documented properly and subsequently decisions can be traced back to how, when and why.

Integration into Alfresco

Integration of Activiti into other systems is the responsibility of the embedding system. Activiti is intended as a ‘generic’ BPM engine. Luckily Activiti and Alfresco share the same standards (including SpringSurf), making integration with Alfresco “relatively easy”. The integration team at Alfresco is mainly engaged in creating “activity types” (to automate manipulations of the repository), mapping Alfresco users to Activiti (and the effects on authorization in Alfresco), and integrating task-related user interface elements to the Alfresco (Share) frameworks ( think of the service forms to generate the task screens).

Current Status

At the moment Aactiviti is a project heavily in development. The first release candidate is out just this afternoon (we count Version 5 RC1 at time of writing). According the roadmap, seven point-releases are scheduled from the start of 2010 up till July (5.1 – 5.7) , one each month. Although it is an indication in terms of planning, it is a tight schedule, but also a serious indication of the rapid pace of product development. At this point in time Activiti is not the enterprise grade, production ready competition to ‘commercial’ mature BPM solutions. As the pace of development continues, it could soon be suitable for “simple processes”, provided the required basic blocks are there. Personally I’m really excited for what the integration with Alfresco will bring… Take a look at the activiti.org web site for the Today’s current status, and keep an eye on the roadmap!

Screenshots are reused from the activiti.org web site
CMIS is the Content Management Interoperability Standard managed by OASIS.
OpenCMIS (is part of the Apache Chemistry project) is a Java implementation of the CMIS standard.
BPNM2.0 is a standard managed by the OMG (Object Management Group).
JBPM is the open source workflow engine of JBoss, so owned by RedHat.

(There is also an English version of this posting)
(Find the Spanish version in this article)

Enige tijd geleden is Alfresco samen met Signavio en Camunda gestart met Activiti, een open source alternatief voor enterprise waardige BPM. De eerste vraag die bij mij opkwam was ‘waarom een nieuwe BPM engine’? Op zich zijn er wel wat kanttekeningen bij de JBPM implementatie in Alfresco op het terrein van ontwikkelen en beheersen van processen. Maar daarnaast had Alfresco meer redenen om eens goed opnieuw over een BPM engine na te denken. Enerzijds zitten er beperkingen aan de LGPL licentie (danwel de perceptie daarvan) waardoor Activiti project wordt ontwikkeld onder de Apache 2 licentie.

Visie

Daarnaast is JBPM een ‘technisch georiënteerde’ BPM engine. In het Activiti project heeft men de visie dat populair gezegd workflow ook ‘sociaal’ zou moeten kunnen zijn. Let wel, moet kunnen zijn. Het Activiti project schrijft niet voor hoe een oganisatie het gebruik van BPM organisatorisch moet inrichten, het wil gezamenlijk samenwerken kunnen faciliteren.

Traditioneel is het ontwikkelen van (bedrijfs)processen het domein van ‘analisten’. Deze ontwikkelen processchema’s, bepalen dat taken bij rollen terecht moeten komen, en welke stappen er geautomatiseerd plaats moeten vinden. Vervolgens gaan ontwikkelaars met deze plannen aan de slag om er ‘uitvoerbare code’ van te maken. Activiti heeft een aantal elementen in zich waardoor meer samenwerking gefaciliteerd kan worden tussen de analisten, beheerders en de ontwikkelaars. Enerzijds wordt gebruik gemaakt van BPNM2.0. Dit is een inmiddels breed geaccepteerde open standaard om processen te modelleren. Het mooie van deze 2.0 versie van de standaard is dat naast de schema taal, ook de achterliggende, definiërende XML gestandaardiseerd is. Activiti kan deze XML rechtstreeks uitvoeren. Dit heeft tot voordeel dat de analist en de ontwikkelaar van hetzelfde schema en dezelfde onderliggende XML uitgaan. Ze kunnen elkaars werk lezen, sterker nog, ze zouden op dezelfde schema’s kunnen werken. En dat communiceert erg effectief.  Anderzijds heeft Activiti een module in ontwikkeling waar de analist en de ontwikkelaar gezamenlijk kunnen werken aan processen, en ook bestaande processen kunnen gaan verbeteren. Ik kom hier later in dit artikel op terug.

Voor Alfresco is het pad van Activiti een doordachte actie. Zo zijn twee ‘founding fathers’ van JBPM bij Alfresco in dienst getreden om deze open source BPM engine te realiseren. Daarnaast is de kennis en ervaring in huis hoe een open source project te draaien. Alfresco is natuurlijk zelf open source, maar met OpenCMIS, ook door Alfresco gestart en inmiddels gedoneerd aan de Apache foundation, heeft Alfresco inmiddels de nodige ervaring met het opstarten van Apache projecten. Activiti moet daar uiteindelijk ook terecht gaan komen.

Het concept

Laten we voor het gemak even uitgaan dat er bij het ontwikkelen en in bedrijf houden van BPM processen de volgende vier rollen betrokken zijn:

• De analist overziet het bedrijfsdomein en bepaalt hoe processen lopen.
• De ontwikelaar neemt het resultaat van de analist over, en ontwikkelt een technische workflow die uitvoerbaar is, die allerhande geautomatiseerde en door mensen uitvoerbare taken kan bevatten.
• De procesdeelnemer is de persoon in de organisatie die een taak uit een proces krijgt toegewezen om iets bij te dragen aan het proces,
• De beheerder is de rol die er voor zorgt dat het BPM systeem blijft werken. ‘vastzittende’ taken of processen kunnen worden herstart, verwijderd, en deze rol heeft inzicht in waarom processen functioneren zoals ze doen in termen van foutmeldingen, performance etc.

Aan de hand van het schema hieronder zal ik uitleggen hoe een en ander bij elkaar hoort in Activiti.

Activiti Engine

Het kloppend hart van het systeem is de Activiti Engine. Dit is het werkpaard waar de BPNM2.0-formaat XML wordt ‘ingevoerd’ en afhankelijk van de beschreven logica processtappen worden aangemaakt en uitgestuurd. Deze geavanceerde engine heeft een extreem lage overhead in termen van geheugengebruik en database opslag. De engine genereert taken die naar personen/groepen/rollen gestuurd kunnen worden. Daarnaast kunnen er ‘systeemtaken’ worden gegenereerd om allerhande geautomatiseerd werk uit te voeren. Denk aan document manipulaties in een DMS (via CMIS?), communicatie met andere systemen middels bijvoorbeeld webservices, mutaties in (externe) databases, etc.  Processen die niet meer actief zijn worden verplaatst naar een archief.

Activiti wordt geleverd met veel typen activiteiten/taken. Daarnaast is er een eenvoudige API waarmee organisaties hun eigen taken kunnen definieren, die vervolgens kunnen worden gemodelleerd en door de engine kunnen worden uitgevoerd. Op deze wijze kan de maatwerk activiteit eenduidig worden hergebruikt, via een nette user interface worden geconfigureerd, en daarmee ook door de analisten worden gebruikt.

De Activiti Engine is zo open mogelijk. Naast uitgebreide toegang middels een Java API, kan via een REST interface een applicatie van alles aan de engine ‘vragen’. Dit betekent dat de applicaties die van de Activiti Engine gebruik maken niet noodzakelijkerwijs ook in Java geprogrammeerd hoeven te zijn. De programmeertaal van de omliggende applicaties is dus middels het REST protocol ontkoppeld. Hierdoor kan de takenlijst bijvoorbeeld in een PHP of een .NET applicatie worden gepresenteerd. De Activiti Engine kan worden bevraagd op allerlei manieren, om werklijsten te genereren, statistieken te vergaren, om lopende processen op meerdere manieren terug te kunnen vinden. Denk bijvoorbeeld aan zoeken naar lopende processen waarbij de numerieke waarde van een attribuut groter is dan x, geordend op startdatum.

Activiti is ontworpen als enterprise BPM engine, dus ook om schaalbaar te zijn. Het is voorbereid om te functioneren in de cloud, instances van de engine kunnen parallel draaien, en het integreert desgewenst naadloos in een bestaande applicatie in het Spring framework.

De laatste feature die ik niet onvermeld wil laten is de mogelijkheid om processen automatisch te kunnen testen. Er zijn faciliteiten ingebouwd om middels JUnit testen (versie 3 en 4) het proces te kunnen testen. Dit is fantastisch nieuws omdat dit heel veel klikken scheelt om de vele paden van een proces te doorlopen. Dit wordt door de engine gefaciliteerd door een proces tijdelijk te deployen, uit te voeren (maar evt. versturen van email etc. achterwege te laten), en weer te ‘undeployen’. Aan de hand van de JUnit resultaten kan worden bepaald of de businesslogica in het proces functioneert zoals het bedoeld is.

Activiti Explorer

De Activiti Explorer is de ingang voor de procesdeelnemers. Hier zijn de persoonlijke- en de groepstaaklijsten te vinden. Groepstaken kunnen worden geclaimd, en taken kunnen worden uitgevoerd. Dit betekent dat gegevens kunnen worden ingevuld in een formulier, of proceskeuzes kunnen worden gemaakt. Taken kunnen aan andere gebruikers worden toegekend, en er kunnen zelfs ter plekke ad-hoc taken worden gemaakt om iemand iets onder de aandacht te brengen. Ook zouden sub-taken kunnen worden aangemaakt om de taak ad-hok op te delen in een aantal deeltaken.

Activiti Modeler

De Activiti Modeler is ontwikkeld door Signavio. De Modeler is een web-applicatie waarin processen volgends de BPMN2.0 standaard kunnen worden gemodelleerd. De procesdefinities worden in het BPMN2.0 formaat op de server opgeslagen. Net zoals het SpringSurf framework communiceert de modeler ook middels JSON met de server. In de standaard Activiti configuratie worden de processen op de server op het filesysteem opgeslagen.

Activiti Designer

Activiti Designer is een Eclipse plugin. Op deze wijze kan de ontwikkelaar zowel het grafisch proces als de xml en de code naast elkaar zien en hier eenvoudig tussen switchen. Eigenlijk gewoon precies wat je ervan zou verwachten.

Activiti Probe

Activiti Probe geeft overzicht over lopende processen. Deze applicatie is typisch voor beheerder-achtige rollen. Hier kan men ondermeer bekijken of de BPM engine nog  functioneert, resource gebruik, hoe staat het met de logfiles. Ook kunnen proces instances naar de engine worden gedeployed. Als het proces onverhoopt niet goed loopt kunnen taken opnieuw worden ‘gestart’, of het proces worden gestopt of herstart.

Op dit moment is Activiti Probe ‘beperkt’ tot het tonen van systeeminstellingen en relevante database tabellen. Dit is in mijn beleving beter dan de ‘commandline tool’ die op dit moment met Alfresco wordt geleverd. Het is echter nog niet wat van een Enterprise tool mag worden verwacht. Een meer grafische tool met mogelijkheden tot zoeken van processen op allerlei kenmerken zit in de planning.

Activiti Cycle

Activiti Cycle is een module waar het sociale, samenwerkingaspect wordt uitgewerkt. Traditioneel is BPM het domein van business analisten, terwijl aan de andere kant juist de ontwikkelaars met het samenstel van code, repositories en het BPM proces het geheel laten ‘werken’. Met Aciviti Cycle wordt een omgeving gecreëerd waar samengewerkt kan worden rond processen. Processen kunnen relaties hebben met ‘artifacts’, zoals (bv. visio) bestanden, maven repositories, Jira issues, een source code repository (zoals SVN). Er zijn mensen die bij een proces betrokken zijn, en over allerhande zaken in context kunnen discussiëren. Er zijn veel features die kunnen worden gebruikt, maar de tool dwingt niet af ‘hoe het moet’. Afhankelijk van hoe een organisatie met BPM om wil gaan kan de tool worden ingezet. Voordelen die gerealiseerd kunnen worden zijn dat de mensen meer betrokken zijn, oplossingen realistischer (dus succesvoller) worden, en het ontwerp/ontwikkelproces wordt gedocumenteerd en achteraf het gevolgde pad is te reconstrueren (waarom en op basis waarvan zijn besluiten genomen).

Integratie met Alfresco

Integratie met systemen is de verantwoordelijkheid van de systemen zelf. Activiti is bedoeld als ‘generieke’ BPM engine. Gelukkig delen Activiti en Alfresco dezelfde standaarden (waaronder SpringSurf) , waardoor integratie met Alfresco als ‘relatief eenvoudig’ omschreven mag worden. Het integratie team aan Alfresco zijde is vooral bezig op het gebied van ‘activiteit-typen’ (automatische mutaties op de repository), koppeling van Activiti gebruikers naar Alfresco gebruikers, en het inpassen van taakgerelateerde user interface elementen aan de Alfresco (Share) frameworks (denk aan de forms-service om taakschermen te genereren).

Huidige status

Op dit moment is het Activiti project zwaar in ontwikkeling. Er wordt hard gewerkt aan een release candidate (we tellen versie 5 op moment van schrijven). Volgens de roadmap zijn de eerste 7 punt-releases (5.1 – 5.7) gepland, en wel maandelijks vanaf januari. Dat is een straf schema, een indicatie qua planning, maar ook een indicatie van het hoge tempo van ontwikkeling van het product. Activiti is nog niet productiewaardig als concurrent van de ‘commerciële’ BPM oplossingen. Als het tempo van ontwikkeling doorgaat, is het binnenkort wellicht geschikt voor ‘eenvoudige processen’ waarvoor dan al wel voldoende functionaliteit aanwezig is. Persoonlijk zit ik heel erg te wachten wat de integratie met Alfresco gaat opleveren… Let vooral op de activiti.org website voor de exacte huidige status, en houd een oog op de roadmap!

Ik snap het wel en ik snap het niet. Case management. Wat ik snap is dat er altijd een behoefte is om bestaande oplossingen te koppelen aan nieuwe of nieuw bedachte business problemen. Wat ik niet snap is dat diezelfde bestaande oplossingen dan ineens heel anders gepresenteerd moeten worden. Komt daar die IT terminologie overkill vandaan?

Eerst was er document management. Dat was simpel. Documenten moesten netjes worden opgeslagen en makkelijk terugvindbaar worden gemaakt. Logisch. Duidelijk werd dat documenten een levenscyclus hebben. Van eerste grove aanzet tot door alle instanties goedgekeurd. Workflow bood ondersteuning bij het doorlopen van dat proces. Prima, snap ik allemaal.

Toen kwam de tweede golf. Business Process Management deed zijn intrede. Tot op de dag van vandaag heeft niemand me helder kunnen uitleggen wat dat is, en vooral niet wat daar anders aan is dan wat we al deden. Maar het bracht de spanning wel weer even terug, dat is waar.

Kennelijk is de BPM hype een beetje overgewaaid, en was er behoefte aan een nieuwe trend. Voila case management. Forrester rapporteert braaf dat hiermee een oud idee wordt afgestoft en dat de tijd er nu kennelijk rijp voor is. Maar ook Forrester loopt vast in een goede definitie. Het lijkt nu een soort van ophoping van concepten uit ECM en BPM (uiteraard bouwen we wel voort op de verwarring die al gezaaid is).

Schiet mij maar lek. Als ik er met een dosis gezond boerenverstand en de nodige ECM achtergrondkennis naar kijk, zie ik leveranciers Case Management uitleggen als een preconfiguratie van hun softwareoplossing, die daardoor sneller implementeer is op veel voorkomende business uitdagingen. Handig!

Eigenlijk is de industrie dus bezig haar eerst zo generiek mogelijk ontwikkelde platformen nu pre-fab aan te bieden voor bepaalde doelstellingen. Dus waar je vroeger een aannemer kreeg op je vraag om een nieuw huis, krijg je nu een brochure met pre-fab mogelijkheden die hopelijk passen bij het soort huis dat je zoekt. En anders kun je altijd nog de aannemer inhuren.

Enfin, ik denk het hiermee begrepen te hebben, en vind de hele hype weer een hoop ingewikkeld gedoe voor iets wat eigenlijk heel simpel (en daarmee heel krachtig) is. Maar mocht ik er finaal naast zitten, dan hoor ik het graag!

Inmiddels heb ik het EIM Maturity Model al op de nodige plekken besproken en gepresenteerd, en iedere keer valt me op hoe makkelijk dit model het onderwerp informatie management inzichtelijk maakt. Het model biedt handvatten om de discussie te concentreren op die gebieden waar het rendement van informatie daadwerkelijk winst kan opleveren. Winst in de vorm van een verbeterde concurrentiepositie, winst in efficiënter werken, etc. Bij de besprekingen komt ook het fundamentele belang van het juist inschatten van het ambitieniveau aan de orde.

EIM Maturity Model

Ik vergelijk dit graag met voetballers in een team. Met name verdedigers kunnen vooraf geïnstrueerd worden hoe te anticiperen op acties van de aanvallers van de tegenpartij. Er kan getraind worden op patronen, op te hanteren regels als bepaalde situaties zich voordoen. Voor aanvallers geldt een ander principe. Er zijn absoluut aanvalspatronen te leren, maar uiteindelijk is het vaak die spontane geniale ingeving van de aanvaller die de verdediging het nakijken geeft.

Precies dit verschil is het verschil tussen de niveaus achieve (verdedigers, focussend op foutminimalisatie en snel doorzien) en outsmart (het boven vaste patronen durven uitstijgen op basis van opgedane kennis gecombineerd met creativiteit).

Juist in het outsmart level komen de invalshoeken van sociaal psychologen als Malcolm Gladwell en onze eigen Ap Dijksterhuis om de hoek kijken. In de achieve fase kunnen we veel meer vertrouwen op vanuit IT-perspectief veilige (want herkenbare) aanpakken op basis van Business Process Management en Operational Business Intelligence.
Daarmee is meteen duidelijk dat het verkeerd zetten van de ambitieniveaus killing is voor een organisatie. Prop de creatieve geesten in een uitgekauwd proces, en ze zullen afsterven. Laat de operationele uitvoerders verantwoordelijk zijn voor innovatie en strategie, en de organisatie zal spoedig achterlopen op de concurrentie.

Op deze blog zal meer aandacht besteed gaan worden aan het EIM Maturity Model. Specifieke vragen? Shoot!