Quantcast
Channel: Camunda BPM Team Blog
Viewing all 143 articles
Browse latest View live
↧

camunda forks Activiti and launches camunda BPM

March 18, 2013, 1:00 am
$
0
0
I am proud to announce that today camunda launches a new open source BPM project: camunda BPM. At this juncture we part ways with the Activiti project which we have contributed to since the first days.

Leaving Activiti is a sad but necessary step for us. Starting as a consulting company, we have built a customer base of 250+ in little over 4 years. Last year, we entered the BPM vendor business with the camunda fox BPM platform. Our success and the positive feedback we got from customers made us realize that we have to go all-in. Today, we drop the "fox"-brand and as camunda BPM, we embark on the journey of building the best BPM platform, under our own leadership & vision.

We are grateful for Alfresco's contributions to the community and we part with the sad feeling of leaving a great project and a unique pack of people behind. Personally, I still regularly hang with Tom Baeyens (who left Activiti before and has moved on as well) and I am certain to remain in touch with Joram, Tijs and Frederik. Guys, I respect you and I wish you the best of luck!

But most of all, I am very excited about what lies ahead for us. Our ambition is to kick off a vibrant BPM community and move the open source BPM space forward. We are very serious about our open source commitment. With this move we broaden the scope from open source embeddable BPM to open source BPM infrastructure, opening code and technology that we built as closed source before. Our software will be Apache License v2.0 (excluding the EPL licensed modeling plugin) and all core components will be developed as open source exclusively (no shadow-repositories).  The commercial add-ons we plan on providing to paying customers are distributions for commercial application servers (e.g. IBM WebSphere Application Server) and plugins for mass data manipulation inside the operations tooling (camunda cockpit). Check out our Roadmap.

We know that many people and companies have invested in activiti projects. We will work hard keeping the migration path from Activiti to camunda open for as long as we can and support teams that want to migrate their project from Activiti to camunda. Talk to us in the forums (or request a Migration Evaluation Workshop).

What is camunda BPM?

camunda BPM provides infrastructure, tools and knowledge around the BPM lifecycle. 

Process Implementation and Execution
  • camunda engine - Fork of the Activiti process engine with lots of additions. Responsible for executing BPMN 2.0 processes. We provide infrastructure integration into Servlet Containers and Java EE 6 application servers allowing you to run the process engine both embedded or as a container managed service. With this step we broaden the scope from open source embeddable BPM to open source BPM infrastructure. 
  • REST API - New embeddable REST API based on JAX-RS, providing remote access to running processes.
  • Spring & CDI integration - Programming model integration that allows developers to write Java Applications that interact with running processes in their familiar environment.

Process Design

  • camunda Modeler - A great  BPMN 2.0 modeling plugin for eclipse. Allows developers to design & refactor processes inside their IDE.
  • camunda Cycle - Enables BPMN 2.0 based Roundtrip between Business and IT parties involved in a project. Allows to use any BPMN 2.0 compliant modeling tool with camunda BPM.

Process Operations

  • camunda engine - JMX and advanced Runtime Container Integration for process engine monitoring and operations.
  • camunda Cockpit - Web application tool for process operations.

Human Task Management

  • camunda Tasklist - Simple web application demonstrating how the process engine task API can be used to build task management applications.

And there's more...

  • ca-bpmn.js - We started building a complete BPMN toolkit for Java Script (Parser, Process Engine, Renderer)
  • camunda BPM incubation - This is where we, together with the community, try out new ideas.

Who are we?  (A bunch of angry nerds.)

We have assembled a unique team of hackers, nerds and BPM experts who want to move BPM forward.
BPM is our passion, its in our blood (and it has been our bread and butter for the last years). And together, we share a common belief: BPM is powerful but BPM is often not delivering on it's full potential. Why?

As BPM practitioners, we have seen anything from large scale process automation projects to the kind of wasteful organizational documentation projects you read about in books. Last year we successfully introduced the camunda fox BPM platform to the market and it was a huge success. Our customers come from different industries and organizational cultures (some are explosive startups, others are rather traditional players in the insurance industry). What struck us was that from all these different customers, we got one common message of feedback: "no other BPM solution can be integrated as seamlessly into our existing infrastructure. With camunda we can focus on our individual business requirements. We are not constrained to a predefined space of possibilities set by the BPM vendor." And that's the point: as soon as you start automating core business processes, you tap into your business model and that is something very personal and individual to your business. To do that, you don't need a predefined solution, you need a powerful, configurable framework.

And you need nerds.

So we say: BPM has the potential to scale your business and to do this, you need an open, flexible platform that allows you to align Business and IT and together build dedicated, individual solutions that realize your individual business model.

This is what we believe in and this is what we build.

----------------------
Activiti and Alfresco are registered trademarks of Alfresco Software, Inc.
All other trademarks are the property of their respective owners
↧
Search

Sandy Kemsley writes about camunda BPM

March 19, 2013, 6:11 am
↧
↧

A look at the fresh REST API

March 19, 2013, 9:52 am
$
0
0
camunda BPM comes with a fresh REST API based on JAX-RS. Its goal is to expose the process engine services as broadly as possible. That means we aim to enable you to interact with process engine services via REST with similar expressiveness as in plain Java. With 7.0.0-alpha1, we provide methods such as task querying that already realize our desired degree of detail (similar for process definitions and instances). For future releases, we plan to broaden the scope to reach the afore-mentioned goal.

Use it with a prebuilt distro

In 7.0.0-alpha1 the API covers interactions with process definitions, process instances and tasks as documented on camunda.org. Enough to build your first process applications as demonstrated in camunda's tasklist. In our prebuilt distros, the REST API is enabled by default and is ready to go.

Cool feature: camunda's cockpit prototype uses the new methods for aggregated runtime statistics. These give you the number of running instances of BPMN concepts such as processes and activities grouped by process definition and activity respectively. Optionally you can also get the number of failed jobs.

You may also address the several process engines you are running on the platform by prepending /engine/{engine-name} to any of the method's urls. If you omit this, the default engine is used.

Embed it in your own JAX-RS application

Got your embedded engine and want to quickly add REST capabilities to it? You may embed the RESTful resources in your own JAX-RS application with little configuration if you run on Resteasy and have jackson-jaxrs on your classpath. Pick up the REST resources by adding the following Maven dependency:
<dependency>
<groupid>org.camunda.bpm</groupid>
<artifactid>camunda-engine-rest</artifactid>
<classifier>classes</classifier>
<version>7.0.0-alpha1</version>
</dependency>

Then you can choose which of the resources you want to include. Have a look here to see how this can be done. (The alternative is to use a JAX-RS implementation provided by your application server.)

Being an alpha release, we are aware that essential features such as authentication are still missing. However, this is on our roadmap to 7.0.0 final, so stay tuned and explore the docs meanwhile!
↧

The HTML5 parts in camunda BPM

March 20, 2013, 10:18 am
$
0
0
The camunda bpm stacks currently includes three web apps: cycle, cockpit, tasklist. All of them are rewrites from a JSF 2.0 ancestor version and with this post I want to explain the decision to built them on a HTML5 plus REST architecture and not with <insert java web framework here>.

Its clear that the web itself is based on the client-server principle. Many Web frameworks like JSF, Vaadin etc. implement it like this:
  1. Provide a abstraction layer to define the HTML + JS + CSS Code to generate (Java Code, Facelets etc.) which in the end is your application
  2. On request, generate the code sent to the browser, initially create a session model for data binding etc.
  3. Keep the generated browser client in sync with the backend session
The main purposes of this approach: reduce the need to touch JavaScript and make it possible to abstract even more to build reusable components. One consequence is a hard wiring of the client and the server session and you will need to have a integration layer between your application code and the framework, which is unlikely to be reused in case of a framework switch.

In the end all that matters is: give the browser the HTML + JS  + CSS it needs to show the application. So why not write just this code without a server side abstraction or knowledge about the server side implementation? 

Thats the idea behind the HTML5 buzz. We are now living in the age of web APIs (see http://www.apihub.com/) and this concept can be applied to web app development very easily. 

So you provide a server side stateless implementation of you business logic or data and define the interface for your clients (typically url paths and the json structure) to have a reusable API for you applications.




What are the benefits: 
  • You can build new apps around existing apis very fast, the tasklist and cockpit are using the same server side implementation
  • You are free in your choice on how to implement the client. There are many MVC JavaScript frameworks to help you kick-start the client side. Its possible to complement that with the whole universe of JavaScript libs and CSS Frameworks. We are using AngularJS, jQuery, dojo and Bootstrap for our apps.
  • You can easily write unit tests for the code running in the browser
  • Full control over the requests made and the browser compatibility layer 
  • You make your application scale better because of the stateless backend
  • You can develop client and server in parallel and create mockups / prototypes very fast, e.g. to talk about different UI designs
"With great power comes great responsibility" so you will now need to take care of some aspects yourself:
  • How to structure you client side code (javascript + css) for reuse (we are using requirejs)
  • Browser Compatibility (luckily most frameworks we are using take care themselves)
  • All JavaScript related stuff like minifiing, concatenation etc. (there are lots of tools out there)
But in the end these points are part of the flexibility as well.

We are really happy with the results and this setup is a future proof foundation for our upcoming features.


↧

A closer look at the camunda modeler

March 22, 2013, 4:28 am
$
0
0
Along with the launch of our open-source BPM platform we made the camunda modeler available to the public, both as a software and as source code.

With the camunda modeler, you get at free modeling tool that integrates in your Eclipse IDE and focuses on seamless modeling of process and collaboration diagrams. But see yourself:


We invite you to try out the modeler, give us feedback and contribute to it.

Present, past and Future

The camunda modeler is based on the Eclipse BPMN 2.0 Modeler that integrates into the Eclipse IDE. Its aim was to allow users with technical focus to create BPMN 2.0 diagrams and maintain BPMN and camunda BPM / Activiti specific attributes in those diagrams.

Beginning October 2012, we decided to dedicate bigger long term efforts to make the modeler a general purpose tool to create and refactor BPMN 2.0 diagrams. As a result the focus of the tool shifted towards user friendliness, quality (in terms of bugs) and an easier maintainable code base.

Since then, we have taken huge steps forward:
  • We simplified the modeler architecture.
  • We established a test infrastructure which comprises both unit tests for modeler features as well as blackbox user interface tests (400 Unit tests and 45 Minutes of blackbox Jubula tests).
  • We rewrote many, if not most of the modeler features to increase testability and maintainability of the code base.
  • We wrote a new model import to allow it to work with (most) diagrams, including BPMN 2.0 exports from other tool vendors.
  • We reworked the property panels and added help texts and input validation to aid the user.
  • We added advanced layouting features for flows to make it easier to work with complex models.
As of now there are still numerous areas to improve and work is long from finished. Many things such as layouting of message flows, better handling of pools and refactoring of the symbol palette are on our roadmap. Further, we would like to publish the modeler as a ready-to-use standalone tool for non-Eclipse users. Progress on all these issues is documented in both our technical changelog as well as in our release notes. 

The modeler for contributors

We highly encourage you to contribute to the modeler if you share our vision of a user friendly, high quality BPMN 2.0 modeling tool. Check out our contribution guidelines to get started. Tell us what you think and share your ideas on the tool in our development forum.

Stay tuned for frequent camunda modeler releases and upcomming blog posts.
In the mean time, we will continue to code with quality in mind.
↧
↧

camunda @bpmNEXT 2013

March 22, 2013, 7:23 pm
$
0
0
bpmNEXT has definetely been a Home Run, as Bruce Silver puts it. Bruce has impressively succeeded in creating a real think tank event for BPM thought leaders sharing their ideas, visions and quite a lot of crazy new stuff around BPM. For those of you who do not know him: Bruce Silver is the BPMN Guru in the US, and I really admire him for both his competence and all that he has done for the standard. Rest assured that a good deal of BPMN's amazing success is due to him.

That said, it should not be surprising how excited I was when discovering in his Review Post a comment about my presentation of camunda Cycle, one of the numerous components that we have open sourced when launching camunda BPM on Monday. Actually I cannot help but spending that quote the visual apperance it deserves:

"camunda showed true roundtripping between third-party business-oriented modeling tools and a BPMS, the first I’ve seen to do that well."
Maybe that quote is not a big deal for most of you, but for me it is. As someone who is quite passionate about "that whole Business IT Alignment - thing", I have a rather emotional connection with that part of our project. And to be honest: Since there has never been any tool like that before, it has been a long struggle to figure out how it should actually work, how it should look like and so on. If you look at it now, it's actually no rocket science at all, and I won't claim that it is a ground-breaking piece of code. But it's strapped to its absolute core use case, and that use case has been implemented very thoughtfully in terms of both usability and software quality. For me it's a great example of good software craftsmanship.

So is Cycle "feature complete"? Not at all! It's just a first step in a long journey towards a better Business-IT-Alignment, but it is a very good first step indeed, and it's already creating value. We have loads of ideas what features should come next, but it also depends on you which of these would actually be implemented, and how soon that would be. You can both just tell us what you're missing, or have look at the code and make your own contributions (e.g. if you are a BPMN tool vendor wanting to improve how Cycle interacts with your product).

But why should I need Cycle anyway? There is a nice BPMN modeler included with camunda BPM already, so why having a roundtrip with yet another BPMN tool? If you are really wondering about that, you have probably not yet made a lot of experience with BPM projects that actually deserve the "B" in the "BPM" acronym. I will try to answer your question as soon as possible, which means basically as soon as I have time for an other blog post.

But right now I am finally enjoying myself in San Francisco, after I got some very interesting insights in the startup scene of Silicon Valley. Have you ever realized that BPM is the perfect tool for IT-based startups that want to scale up their business model? Oh my, I am already having visions again...

↧

camunda modeler 2.0.12 released

April 5, 2013, 3:14 am
$
0
0
Yesterday we released version 2.0.12 of our modeler with a number of bug fixes as well as layout and usability improvements. One highlight is splitting layouted sequence flows to insert new flow elements between two connected nodes.


Other things worth noting include
  • Improved integration of the model wizard
  • Proper support for event subprocess / non-interrupting start event
  • Diagram image generation handles spaces in diagram file names correctly

Event subprocess and non-interrupting start event
Event Subprocess
Wizard integration

We also fixed some crucial bugs, reworked the layouting of participants and the resize behavior of pools, lanes and subprocesses.

For details refer to the issues closed in this release or check our detailed technical changelog.

As always, upgrade your modeler installation and tell us what you think!

↧

The camunda Hypothesis

April 7, 2013, 8:19 am
$
0
0


Scott Francis has written an excellent post about the core message of our presentation at bpmNEXT. He called it the "Zero Code Hypothesis". Though Scott's summary is completely right in its essentials, I would like to put some details straight:

  • We don't think that "Zero Code BPM" does not work at all - Zero Coding and our approach are both reasonable, depending on what you have and what you need. The real problem is that most of the zero coding BPM vendors claim that you should use their solution for situations where you actually shouldn't.
  • We do not condemn the ideas and ambitions often associated with the term "ACM". Quite the contrary, we even believe that our approach is very well suited to create the according process applications (basically because we already did it).
  • I would not consider our standpoint a counter-point to the movement to make BPM "more accessible" to the business. We just don't belive that zero coding is the right approach to realize that enhanced accessibility. There are other instruments (most of them based on BPMN), that we already successfully validated and incorporated in our approach. But still, just like ACM, this is a field of research. I don't think that anyone could seriously claim to have found the "silver bullet" yet.

But even given these relativizations, we are pretty much off the BPM mainstream with our "camunda Hypothesis":
While there are reasonable use cases for zero code BPM Suites, they are not the right approach for automating business processes that execute an IT based business model. 

A business model is "IT based", if IT is the core infrastructure to create and/or deliver the customer value. Financial Service providers, insurance companies etc. execute IT based business models, while most manufacturing companies, but also doctors etc. don't (though the relevance of IT for business models in any industry is rapidly growing).

business processes execute your business model  (image: www.businessmodelgeneration.com)

One critical success factor of a business model is its uniqueness, which leads to the differentiation from competition and therefore to the leadership in the respective market (segment). The obvious conclusion is, that an IT based business model requires a very high degree of flexibility in the underlying IT infrastructure. Otherwise, the unique idea behind the model could not be implemented, or, if there would be a (customizable) "off-the-shelf" IT solution for it, it could very easily be adopted by competition - and actually could not have been really unique in the first place. The second dealbreaker criterion is, that the company must be able to create, adjust and maintain that executing infrastructure independently from external parties: A company with an IT based business model must recognize IT as their core competence (which, by the way, also means that outsourcing IT resources would be a pretty bad idea).

Zero-Coding BPM suites (including most of the BPM suites currently available) cannot meet those criteria, but an open BPM platform like camunda BPM does, for the following reasons:

Accurately fitting solutions

"The open architecture of camunda BPM allows us to implement our very individual requirements in a way that a traditional BPM suite just cannot provide." (Zalando, fashion e-commerce)


In Zero Coding BPM, you would implement your process application using certain forms, wizards etc. The inavoidable consequence is, that you can implement anything... that the BPM vendor has imagined beforehand. But as soon as you have a requirement, that does not map to a checkbox, dropdown or what ever in the Zero Coding Wizard, you're lost. This would not necessarily be an issue - as I said, there are reasonable use cases for this approach. But implementing an unique IT based business model is certainly not amongst them.

Since camunda BPM is a (Java-based) open source framework rather than a black box product, you have the exact same freedom during implementation you always have when developing in Java. You can implement everything in the exact way it is needed for executing your business model.
"camunda BPM allows a seamless integration of process automation with non-procedural Use Cases for the case management, so that we are able to interlock optimally structural and non-structural processes." (flightright, debt collector)
The ability to seamlessly combine structured and semi- or unstructured processes is another advantage of this approach, and a critical foundation for any process application that should be considered "ACM-like".

No vendor specific learning curve

"Additionally we can use our existing Java know-how combined with camunda BPM to build quickly and easily lightweight process solutions." (Freenet, Telco Provider)


There are ~10 mio. Java developers worldwide. Think of any available BPM suite and tell me, how many according developers you would find on the market.

Besides the restrictiveness described above, this is the biggest issue with traditional BPM suites: Your IT staff has to learn how do develop your process applications in a vendor specific way. This takes time, and most certainly your staff will never really master the vendor stack, because they cannot completely focus on it while also working on other projects with other technology stacks. In other words: It will be a huge effort to learn that vendor specific way, and if they don't continuously work with it, they will soon forget what they have learned.

As a consequence, you will always depend on the know how resources (consultants etc.) the specific vendor or their partners provide. Not the smartest way to execute your business model, is it?

With camunda BPM, there is no vendor specific way. You know Java? You know camunda.

Zero Coding BPM vendors like to claim that you don't need your IT staff any more, because it's so easy to implement the process applications that the business users can do that on their own. I can just repeat myself: The more individual your requirements are, the more flexibility your BPM solution must provide. The more flexibility your BPM solution provides, the more complex is it to implement your process application. You won't gain anything with a form wizard instead of programming code, if that wizard consists of 25 elements your business user is expected to understand.

The force is with you

"camunda rocks." (Plexiti, IT solution provider)


OK, I am getting carried away. What I really mean is this: If your business model is IT based, your software developers are probably your most valuable assets. And actually they are not just "assets" or "resources", but human beings. They can be incredibly creative and productive, but only if they have the opportunity to flower. Have a look around, at GitHub, at Devoxx etc. There is a whole global movement of extremely talented, enthusiastic software developers who just love to create great value.

You can benefit from that enormous force, if you let them create your process applications in an open, lightweight, developer-friendly environment, that can be enriched with any emerging technology or method (HTML 5 or what ever), and actually makes fun to work with.

"It took only a few days to highly inspire the whole project team (consisting of people from both IT and business departments) for process mapping with BPMN 2.0" (LVM Versicherungen, insurance company)
As I said at bpmNEXT, Business-IT-Alignment is not about getting rid of IT, but a successful collaboration between partners. We know that BPMN assumes a key role here. I would never consider camunda BPM a pure "framework for techies". We strive to inspire both Business and IT, to bring them together and enable them to collaboratively create the process applications they need to execute their IT based business models.

The "camunda Hypothesis" is already proven

"camunda showed true roundtripping between third-party business-oriented modeling tools and a BPMS, the first I’ve seen to do that well." (Bruce Silver, BPMN Super Hero)


A this point, I should probably make clear that our "hypothesis" has already been validated. As a consulting agency, we are in the BPM field for 5 years now (the two founders Bernd Rücker and me even for 10 years). Personally, I used to work for a well-known BPM Suite vendor before I joint forces with Bernd, and working for them as a PreSales Consultant I experienced exactly the problems I have described above.

When we (camunda) finally entered the BPM software market in 2012, we quickly won way more clients than we had expected ourselves. Since March 18th, this product is open source, and there are several clients that agreed to be quoted what they like about it (you have found some extracts in this blog post, but there's more).

We hope that by open sourcing not only our technology stack, but also our know how (we started by publishing half of our best-selling BPMN book, but there is way more to come), we can help others to recognize what actually has gone wrong in the last years of BPM, and how we could bring BPM to the next level of success (or even "crossing the chasm" Paul Harmon has mentioned at bpmNEXT).

I suppose this is some hard piece of work, but I know it's worth it.




↧
Search

New: camunda BPM-Community

April 9, 2013, 8:58 am
$
0
0

Process management is not a bureaucratic evil but can be a key instrument for scalable business models.
But to do so we need to get rid of our old ways of thinking. Need an example? The whole Zero Code BPM – Illusion, is one of many errors that have dominated process management in the past.

On 18th March we released our BPM platform under an open source license as Business Process Management is impossible without IT (not everyone likes this, but it’s just the way it is). But of course BPM requires a lot more than purely a technical platform. That’s why we are also, bit by bit, providing our knowledge that we have acquired over the years. You can find both software and knowledge on www.camunda.org.

But that’s not enough.

We know first-hand that BPM works and what is important. We helped more than 500 companies and public organisations to apply BPM selectively or openly. A lot of it worked well, but some didn’t. We need to bring these people together so as to not reinvent the wheel and to realise in time which paradigms do not work (Need an example? The “refinement” of modeled processes via partial- or subprocesses, from the process landscape to the executable technical workflow, is rubbish. It doesn’t work that way but unfortunately it’s being tried again and again).

Therefore, we call the camunda BPM community to life. We will start with evening workshops, preferably hosted by specific BPM-users. The first dates are planned and are taking place at the dwpBank in Frankfurt (Germany), LVM insurance in Münster (Germany) and plexiti in Vienna (Austria). If you want to register for one of these events or stay informed about future events please register here:

http://www.camunda.org/community/meetings.html

The first meeting’s subject will be the introduction of our new open source platform, but further subjects will follow. If you have specific subjects you want to be discussed please contact Nastasja Johnston who will be managing the community via community@camunda.org.

The same applies to BPM-users who are hosting events. If you have specific ideas how the community can support and join fellow BPM enthusiasts feel free to let us know!

Are we doing this without self-interest? Not quite. camunda will profit as this community grows and prospers. But we are also talking about a win-win situation for all involved!

Therefore: let’s do it :-)

↧
↧

camunda BPM Launch Party

April 10, 2013, 7:58 am
$
0
0
After launching our open source platform camunda BPM on 18th March, we gave it a proper welcoming to the BPM community last week. 55 people showed up to the launch party held at camunda HQ, which coincided with our 5th birthday.
It was a great night, during which the hard-working team around camunda BPM had the chance to demonstrate some of the platform's great features and advantages followed by good discussions with the guests afterwards.
But not only that, our foosball table, Wii and a fridge filled to the brim with beer made sure that the hard work also payed off with some well-deserved fun.
Take a look at some pictures we took on the night and make sure to sign up here for one of our future community events.







↧

camunda BPM 7.0.0-alpha2 released

April 23, 2013, 7:21 am
$
0
0
I am happy to announce the release of camunda bpm platform 7.0.0-alpha2. This is the first camunda BPM release that contains a distribution for Glassfish Application Server. You can now download a complete open source BPM platform with fully compliant Java EE 6 integration!

Download it now!

Highlights:

  • Glassfish 3.x Distribution with Java EE 6 process engine integration
  • New Job Executor Service with JCA 1.6 Integration
  • Job Executor manageability through JMX
  • New space for documentation: http://docs.camunda.org/ with new installation guides.
I will dedicate a separate Blogpost to showcasing the Job Executor improvements in the following days.

In addition, the release contains a set of small improvements and bug fixes. Read the Complete Release Notes in JIRA.

Major QA Infrastructure Improvements 

Probably not as exciting for most people as for myself but I still think stuff like this deserves some attention :) We also made a lot of QA infrastructure improvements behind the scenes. For instance, we have made it a lot easier to run in-container (ie. inside JBoss / Glassfish / Tomcat) integration tests for both process engine and web applications.
This allows us to run extensive in-container testsuites testing the Java EE 6 and Servlet integrations against all supported runtime containers and databases. 

What's next?

For the next release we plan:
↧

The start of camunda.org community events

April 24, 2013, 1:02 am
$
0
0


Last week we had our first two camunda.org community kick-off events. On Wednesday we were at the Deutsche WertpapierService Bank AG in Frankfurt followed by an evening on Thursday at LVM Versicherung in Münster.
Both companies successfully work with camunda BPM and have spoken of their experiences with the platform.
We also got a chance to present the camunda project to groups of about 20 BPM enthusiasts and had open discussions about aims, preferences, likes and wishes.
A lot of positive feedback trickled through this week and more evenings with varying subjects will follow.
Make sure to sign up to our newsletter to find out about what's happening next and check out some pictures below.





And last but not least, our partners Plexiti just introduced camunda BPM at the JUG Barcelona. Thanks to Rafael Cordones for flying the camunda flag in Spain.




↧

camunda BPM incubation space launched with contribution by plexiti

April 24, 2013, 9:57 am
$
0
0
I am happy to announce the official launch of the camunda BPM incubation space with the first large community contribution by plexiti.

View it on github: 
https://github.com/camunda/camunda-bpm-incubation
https://github.com/camunda/camunda-bpm-fluent-testing

The goal of the camunda BPM incubation space is to promote the development of interesting new projects and ideas around BPM, BPMN and process engines.

Due to the productization and stabilization focus in the camunda BPM core platform, we decided to separate out these experimental projects from the core platform. The core BPM platform is stable and maintained and can be found in the github repository camunda-bpm-platform. This is also the base for the supported (commercial) camunda BPM platform product. The camunda-bpm-incubation repository contains a list of incubation projects which may be located in that repository itself or inside a different repository. We hope that this helps us finding a balance between being able to try out new innovative ideas (possibly in an unstructured or even unstable manner) but still being able to provide a stable "core" project. I think that this is also helpful for users of the project: users immediately see which parts of the project are stable and maintained and which other parts are still experimental.

Plexiti makes the first large community contribution to camunda BPM

The first project started in the incubation space is located at https://github.com/camunda/camunda-bpm-fluent-testing and is a contribution by plexiti. 

Plexiti is an innovative company from Vienna / Austria and founded by Martin Schimak and Rafael Cordones. You can meet them at our jointly organized community event in Vienna.

Martin Schimak
Rafael Cordones




It's an emerging little library aiming at easing tests when developing process applications. We reach out to
  • ease the readability and maintainability of process model tests and make the writing of process model tests more fluent and more fun
  • make it even easier to mock the services available to a process instance than it already is
For that purpose, you can - aspect 1 - write FEST assertions, e.g. like
assertThat(processInstance).isWaitingAt("review");
assertThat(task).isAssignedTo("piggie");
but you can also - aspect 2 - query and drive "the process" via a somewhat more fluent API than currently available, e.g. like
processInstance.task().complete("approved",true);
You can find a bit more documentation of what's currently possible in the README.md of the github project.

We are currently working to completely separate these two independent aspects and would like to contribute them into the camunda.org incubation space, e.g. as

Project 1) camunda-bpm-fluent-tests
Project 2) camunda-bpm-fluent-engine-api

Try it out!

Since today we have a running Hudson job that deploys snapshot builds to the camunda BPM nexus repository. This allows you to easily try out camunda-bpm-fluent-tests:

Add the following maven dependency:

<dependency>
  <groupId>org.camunda.bpm.incubation</groupId>
  <artifactId>camunda-bpm-fluent-engine-api</artifactId>
  <version>0.4-SNAPSHOT</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.camunda.bpm.incubation</groupId>
  <artifactId>camunda-bpm-fluent-assertions</artifactId>
  <version>0.4-SNAPSHOT</version>
  <scope>test</scope>
</dependency>

And add the camunda BPM repository:

<repositories>
  <repository>
  <id>camunda-bpm-nexus</id>
  <name>camunda-bpm-nexus</name>
  <url>https://app.camunda.com/nexus/content/groups/public</url>
</repository> </repositories>

More contributions welcome!

If you have an interesting idea for an incubation project, read the technical guidelines in Github and talk to us on the DEV mailing list!
↧
↧

camunda BPM 7.0.0-alpha3 released

May 3, 2013, 7:24 am
$
0
0

camunda BPM 7.0.0-alpha3 is out now! It packs a bunch of new features such as support for Spring Process Applications and correlation via the engine's Java API.

First things first: Get it here!

Spring Process Applications

Use process engines, container-managed or embedded, from within your Spring application context (on Tomcat, Glassfish). See below an example from our getting started guide:

Message correlation

BPMN offers two incoming message constructs that are supported by the engine: Message start events and intermediate catching message events. Now you have the possibility to deliver messages in one call.

Use the RuntimeService#correlateMessage methods to correlate messages to executions waiting for a specific message or start a new process instance. You do not need to know any longer, whether you deliver the message for a start or intermediate event. Correlation is done based on process instance variables and business keys. Our documentation on message events gives some details.

Shortly, we will also offer this through the REST API and publish a more detailed blog post covering this topic.

What else?

A number of bug fixes. Check our release notes to see what ships in alpha3.

↧

camunda vs. Oracle: Shootout Roadshow

May 7, 2013, 5:39 am
$
0
0


High Noon in BPM City: not a soul walks the dusty main road and the sun glares mercilessly onto El Camundo and his opponent – the Oracle of the Desert. The wireless mouse still rests in his holster, his hand hovers above it – only the slightest quiver reveals Camundo's tension. Pearly beads of sweat are glistening on Oracle's face. Who will be the first to shoot off his token?

This is close to what you can expect from our Shootout Roadshow, that we will run together with Oracle and Opitz Consulting (the latter as a neutral presenter). The idea is to set camunda's and Oracle's BPM systems against each other and get a direct comparison. On the one hand the well-established and powerful infrastructure, on the other hand Oracle's tool. Just kidding, I just can't help myself. Seriously though: obviously Oracle as well as camunda offer serious and high-quality BPM solutions. What then are the similarities, what the  differences? Which solutions is eligible for my specific project? This is less a question about which tool is the better, but more about which approach is the most suitable for a specific problem or business situation.


Dates:
10.06.2013 | Berlin
11.06.2013 | Hamburg
25.06.2013 | Cologne
26.06.2013 | Bad Homburg
27.06.2013 | Munich

Further information and registration: http://www.opitz-consulting.com/go/26-16-1281

We are pleased that Oracle is prepared to participate in this event and will be present with some of its qualified representatives. I do believe that it will be an exciting few days without one side belittling the other, but where real BPM enthusiasts will describe why they love their product and which of its strengths they believe to be especially relevant and during which the Optiz team can report from their experiences with these products and enough time will be given for your questions (feel free to be critical). Definitely a marketing event (hey, free coffee!), but not the typical empty yes-we-are-great-stuff that one usually has to endure. It'll be cool.
↧
Search

camunda BPM 7.0 on WebLogic 12c

May 14, 2013, 1:08 am
$
0
0
If we go on tour together with Oracle I think we have to have camunda BPM running on the Oracle WebLogic application server 12c (WLS in short). And one of our enterprise customers asked - so I invested a Sunday and got it running (okay - to be honest - I needed quite some help from our Java EE server guru Christian). In this blog post I give a step by step description how run camunda BPM on WLS. Please note that this is not an official distribution (which would include a sophisticated QA, a comprehensive documentation and a proper distribution) - it was my personal hobby. And I did not fire the whole test suite agains WLS - so there might be some issues. We will do the real productization as soon as we have a customer for it (let us know if this is interesting for you).


Necessary steps

After installing and starting up WLS (I used the zip distribution of WLS 12c by the way) you have to do:

  1. Add a datasource
  2. Add shared libraries
  3. Add a resource adapter (for the Job Executor using a proper WorkManager from WLS)
  4. Add an EAR starting up one process engine
  5. Add a WAR file containing the REST API
  6. Add other WAR files (e.g. cockpit) and your own process applications
Actually that sounds more work to do than it is ;-) So let's get started:

Add a datasource

Add a datasource via the Administration Console (or any other convenient way on WLS - I should admit that personally I am not the WLS expert). Make sure that you target it on your server - this is not done by default:

 

Which camunda distribution do I use?

Before we can install the camunda BPM platform on WLS we have to download it. But there is no WLS distribution yet. Hence we can leverage the existing distributions for other Java EE containers, I use the Glassfish distribution as it is technically pretty close to WLS. 

Unfortunately I had small issues with the current alpha3 version on WLS - which I fixed on a branch and try to convince the team to apply them to alpha4. So for the moment you have to build a patched alpha3 from this branch: https://github.com/camunda/camunda-bpm-platform/tree/wls-prototype-7.0.0-alpha3/distro/wls12c. If you do not want to build it by hand here is a ZIP file containing the relevant artifacts:


Now we will install the artifacts step by step.

Add shared libraries

Just copy the provided libraries (the core engine, necessary dependencies like Apache MyBatis and interfaces for the Ressource Adapater) into your domain "lib" folder:

Add resource adapater

We use a JCA (Java EE Connector Architecture) resource adapter to be fully Java EE compliant. This component is basically responsible to do something we call Job handling. Basically we need a thread pool to query the database if any timers or the like are due. See more details in the Job Executor docs.

The resource adapter is deployed as RAR archive. I used the archive provided for Glassfish - as there are no changes necessary. You can deploy it via the Administration Console without problems:

Important: You now have to adjust the configuration. Change the deployment order (the resource adapter should be deployed before other stuff), set a JNDI name and allow global access to classes (actually I still wonder how providing the RAR classes to EAR classloaders really works in WLS as defined in the JCA specs - I didn't get it to work in the prototype so I added the stuff as shared libraries - any hints from WLS experts are welcome!):

And you have to provide an outbound connection factory which later can be used via JNDI from our process engine:

And last but not least we need a Weblogic WorkManager for our thread pool:
That's it. Next step :-)

Add EAR starting a process engine

I have build a custom EAR for WLS to provide a WLS specific deployment descriptor necessary to wire the EAR with the RAR correctly - but I will skip the details here. The EAR basically only does one thing: It starts up one engine - therefor it does not have more content than the deployment descriptor and a "bpm-platform.xml" file containing the configuration of that process engine. Deploy this with the wizard again:

This time there is not much to configure - I would suggest  that you change the deployment order to 75 - then it gets deployed after the RAR but before other applications.

If you want - you can have a look in the JNDI tree - you should see the started process engine there:

Deploy REST API as WAR

Now we can deploy the REST API, this is a simple WAR (leveraging JAX-RS) providing a REST interface to the already running process engine of the server. To be precise it provides an interface to all running process engines of the current server - but that's a story for a different post :-)

You can deploy the WAR file (I again used the Glassfish one without modifications) with the wizard - I think you practiced that enough by now. Just make sure you deploy it as "application" - not as "library" as the wizard tried to trick me here.

For example you can now query all existing process engines: http://localhost:7001/engine-rest/engine/. You can see get the one existing engine:

Congratulations - now on you have a platform working correctly within WLS - fully Java EE 6 compliant - and without any hazzle for starting your process engine. Amazing - isn't it? 

Deploy cockpit and tasklist

Since tasklist and cockpit are HTML5 web applications using the REST API in the background you can easily deploy them as well as soon as you have the REST API running. Do that now (use the wizard again) and you can access them via the browser:

Deploy Process Applications

Now you can deploy normal process applications - as e.g. described in the Getting Started Guide. Enjoy!

Please note that there is one limitation with the current codebase on WLS: The classpath scanning we do in order to find process definition files automatically does not work on WLS. Hence you can not auto-discover your process definitions but have to configure them by hand in the META-INF/processes.xml:

<process-application
  xmlns="http://www.camunda.org/schema/1.0/ProcessApplication"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <process-archive name="pa">
    <process-engine>default</process-engine>
    <process>invoice.bpmn</process>  
    <properties>
      <property name="isDeleteUponUndeploy">false</property>
      <property name="isScanForProcessDefinitions">false</property>
    </properties>
  </process-archive>

</process-application>

Some Screenshots

To prove that it was working :-) See cockpit showing the invoice example process application:
The tasklist:

And starting a process instance via REST:

Feedback welcome

We welcome every feedback on this - best use our forum (http://camunda.org/community/forum.html, can be used by sending mails to it as well: camunda-bpm-users@googlegroups.com). Let us now if you want to use this in production - then we can place a proper enterprise distribution on our roadmap...
↧

camunda BPM 7.0.0-alpha4 released

May 16, 2013, 6:49 am
$
0
0
Release early and release often. Today we bring you the next release of camunda BPM (7.0.0-alpha4). The Highlights are:

Read the full release notes in Jira.

Message correlation in REST API

With the previous release we added a message correlation method to the Java API. With this release we bring the new functionality to the REST API. (Read the docs).

The API is pretty straight forward, just execute a POST to the /message resource. Example: 

{"messageName" : "aMessage",
"businessKey" : "aBusinessKey",
"correlationKeys" : {
    "aVariable" : "aValue"
},
"processVariables" : {
    "aVariable" : "aNewValue",
    "anotherVariable" : true
}}
This allows correlating a message to an existing process instance (or start a new process instance) in a single, atomic request.

The corresponding Java Api call looks like this:

Map correlationKeys = new HashMap();
correlationKeys.put("aVariable", "aValue");

Map processVariables = new HashMap();
processVariables.put("aVariable", "aNewValue");
processVariables.put("anotherVariable", true);


runtimeService.correlateMessage("aMessage", "aBusinessKey", correlationKeys, processVariables);

What's next?

Now that we have the infrastructure ready for writing cockpit plugins, we can start implementing a bunch of awesome features in cockpit. We will now also start work on the login and security modules for the web applications.

On top of that, we will continue work on the REST API and the Websphere distribution.

Read the full Roadmap.
↧
↧

Extending camunda Cockpit through Plugins

May 17, 2013, 7:07 am
$
0
0

camunda Cockpit with a plugin. Yeaaah.

As we have seen in the past, it is impossible for camunda Cockpit ---our process monitoring tool--- to satisfy all needs, out of the box. That is why we have long thought about providing it with an appopriate extension mechanism that empoweres users to fit the tool to their very own monitoring needs.

With the latest relase of camunda BPM a first version of a plugin system for camunda Cockpit is finally here. So what is it about? Simply spoken it is about extending the cockpit GUI with custom views on everything that runs with camunda BPM. Processes, process instances, deployments, tasks... you name it. That may be accomplished by providing backend services that execute custom queries against an engine database. In addition, the backend services can also execute custom engine commands. A colleague already promised me to exploit the full powers of the mechanism in a Chuck Norris plugin. camunda BPM engines around the world, watch out.

I created an article on how to develop a plugin for everyone who is interested in all the details. Another good start to get right into the matter may be the sample plugin that gets developed in the article.

The whole plugin matter is brand new and you can expect more source code, documentation and articles on the matter. Up to then we welcome your feedback on our dev mailing list.
↧

PHP SDK for camunda BPM: new Incubation Project started

May 24, 2013, 9:58 am
$
0
0
If you want to do BPM / Workflow and BPMN 2.0 in PHP then we have good news for you: as part of our camunda BPM polyglot initiative we started a new incubation project which aims at providing a PHP SDK for camunda BPM. This SDK will facilitate the development of PHP-based applications that use the camunda BPM middleware services. The project will provide a client library which authenticates against the REST Api and provide PHP developers with a native API for interacting with the process engine:



While the camunda BPM project stays focused on Java as primary programming language, we believe that it is important to support developers that use other programming languages and give them access to the BPMN 2.0 process engine technology, without having to rewrite that technology in every programming language.

The main developer on the project is Stefan Hentschel who has a great deal of experience developing PHP applications.

The project will provide 3 main artifacts:

  1. A PHP client library for the REST API,
  2. Documentation including Getting stated, Userguide and PHP Api Docs,
  3. A PHP demo application which showcases the features of the Api. 

As additional topics we might look into OAuth 2.0 authentication for the REST API and external service tasks (a facility for implementing service tasks externally and polling the process engine for new task instances. This will enable you to code service tasks directly inside the PHP client application).

If you are interested in contributing to this project, please talk to us on the developers' mailing list:
https://groups.google.com/forum/?fromgroups#!forum/camunda-bpm-dev


Jira:
https://app.camunda.com/jira/browse/CIS/component/12056



Github repository:
https://github.com/camunda/camunda-bpm-php-sdk

↧

camunda BPM 7.0-alpha5 released

May 31, 2013, 7:52 am
$
0
0
Two weeks after the last alpha release we bring you the freshly baked* alpha5 version of the camunda BPM platform. The highlights of this crispy new release are:

50 JIRA issues were closed, see the complete release notes.

Note: this release contains database changes. Upgrade scripts can be found in the "sql" folder of the distribution.

(* using Robert Gimbel's special homemade yeast)


Things are happening in the cockpit

Over the last two weeks, process engine hacker Roman Smirnov and Javascript wizzard super magician Nico Rehwaldt have been focusing on camunda cockpit. They have added a couple of features and refined the cockpit plugin infrastructure. 

There is process definition summary plugin which visualizes the state of a process definition using green and red dots (red = failed jobs):


On the process definition details page we now have process instance table:



We now have an increasingly powerful and flexible client side-architecture in place which will now allow us to implement interesting new features and start working on usability and layout of existing features. Read the full client-side plugin story at http://docs.camunda.org/how-tos/cockpit/develop-a-plugin/ (section "The client side"). Also check out our client-side test infrastructure using Karma and Node.js: see README.md and sources.

Incident infrastructure in Process Engine (Work In Progress)

We started work on a new Infrastructure for incidents in the process engine. This project has 3 goals:

  1. Provide an abstraction over different "notable" events that can happen during process execution. 
  2. Provide an extensible, event-oriented API for handling such incidents.
  3. Provide a default implementation for incident event handlers which writes incidents to the database.
Currently we provide incidents for failed jobs. Failed job incidents are raised when automatic retries for a Job (Timer or Asynchronous continuation) have elapsed. The incident indicates that the corresponding execution is stuck and will not continue automatically. Administrative action is necessary. The incident is resolved, when the job is executed manually or when the retries for the corresponding job are reset to a value > 0. In the future, we plan on providing features for raising additional kinds of incidents. Examples are the fact that a process instance has entered a certain task, that an error boundary has been triggered or that a process instance took to long to complete. 

Incident handling is extensible. The default implementation writes incidents to the database such that they can be queried:

runtimeService.createIncidentQuery()
  .processDefinitionId("someDefinition")
  .list();

In cockpit we can now visualize different kinds of incidents in the same way and allow users to define for a given process definition what constitutes an "incident".

We also support recursively raising incidents for super process instances and correlating them to the call activity which has invoked the process instance in which the incident occurred. This is used by the cockpit tool for visualizing the state of a process definitions (and instances).  The recursive nature of incidents will allow the cockpit tool to provide drill-down features.

There is an extensible API for handling incidents which allows you to replace or enhance the default behavior. For example, you could send an email to an administrator if an incident inside a given process definition is raised.

Additions to the REST Api

Thorben has done some additions to the REST API, checkout 
  • Better exception messages.
  • Execution Queries.
  • Process instance /execution variables.
Errors are now also provided in JSON format:

{"type" : "SomeExceptionClass", "message" : "a detailed message"}.

You can modify multiple process variables in a single request:


POST /process-instance/aProcessInstanceId/variables

Request body:

{"modifications": [
    {"name": "aVariable",
     "value": "aValue"},
    {"name": "anotherVariable",
     "value": 42}
    ],
"deletions": [
    "aThirdVariable", "FourthVariable"
]}

Or you can address individual process variables through PUT/ GET / DELETE:
PUT /execution/anExecutionId/localVariables/aVarName
GET /execution/anExecutionId/localVariables/aVarName
DELETE /execution/anExecutionId/localVariables/aVarName



↧
Viewing all 143 articles
Browse latest View live
Search