In this episode, we catch up with Nico Rehwaldt, the leader of the BPMN.io project. We talk about his views on the history of the project, how open source it is, what's included (DMN.js, BPMN.js, Forms.js), what's new in the project, and the weirdest places that Nico has seen them being used.
Josh Wulf (00:07):
Welcome to the Camunda Nation Podcast. My name is Josh Wulf and I'm a developer advocate at Camunda. This month I'm speaking with Nico Rehwaldt. He's the tech lead, project lead and chief marketing dude at bpmn.io. Welcome Nico. Thanks for coming on the podcast.
Nico Rehwaldt (00:25):
Welcome. Thanks for having me.
Josh Wulf (00:27):
Can you please share with us your background and how you came to be in the place where you are now as the tech lead, project lead, chief marketing dude at bpmn.io?
Nico Rehwaldt (00:38):
I actually have quite some history in this whole modeling domains. I think we started BPMN in 2014 and it has been interesting ever since to me building editing tools for BPMN, BPM and related standards. I think something, when I joined Camunda, I think 2012, we basically had an engine, right? We were using activity at the time, contributing to activity. The engine actually had an export API to generate an image, or BPNM diagram. But there wasn't be there wasn't much more. You couldn't really conveniently create those BPMN diagrams. So what struck me from the beginning was the question, how can people actually use this? It's awesome if you have a great engine that just executes stuff, but if you can't actually draw those diagrams, which are so important, right, how can we ever be successful? We were already successful at the point, right?
Nico Rehwaldt (01:35):
It was already product, but for me, the crucial part was missing, which is just a great accessible tooling to create those diagrams. This is just something that fascinated me from the beginning. So before we started BPMN, or actually we were walking Red Hat, BPMN, clips modeler just rewrote it from scratch more or less, had a test coverage. We went from 160,000 lines of code down to 80,000 lines of code. In the end it was much more stable, but it also was it was a decent BPMN editor. But it was just an eclipse plugin. So this is our prior investment before we started with bpmn.io. Then we kind of thought about, okay, now we have an eclipse plug in. That's good enough if our users are using eclipse, but developers are using a lot of different tools, right?
Nico Rehwaldt (02:28):
So nowadays for example, a lot of people are just using [inaudible 00:02:31] to code, which is another Hood. It's just a web based. It's an electron application, right? Which is a web browser plus an note backend. But also you have IntelliJ for example, which is very prominent nowadays. Eclipse is still around. A lot of people are using it, but basically it doesn't really work just to be in one ecosystem and have just a plug in one of those editors. But really we needed something that was a little bit more open. So what is more open than the web platform? So that was one of the ideas that we had after we did our first steps into building modeling tooling. This is basically how I pitched this idea of web based tooling over and over again. I think Jacob and myself, Jacob CEO of command, we had a good lunch at some point, and then he offered me, "Do you want to build that web based stuff you're always talking about?" So we did get started doing that.
Josh Wulf (03:30):
So that kind of also flows into this next question is like, what is bpmn.io? What's the history behind it? So your personal history, you've obviously been there since the very beginning at the inception of the whole thing. So what did that become? What has that become and how has it gone since that initial launch?
Nico Rehwaldt (03:51):
Nico Rehwaldt (04:51):
So this was very clear from the beginning that we wanted to go with something like that. But we really focused on BPMN initially. This is why also it was it's called bpmn.io and not dmn.io or form.io. It's really, at the beginning, it was just BPMN tooling. But also OMG came around and said, "Well, it makes a lot of sense to have a standard for decisions." So we basically implemented tooling in the future for DMN, it's called DMNJS. Then we also implemented tooling for CMN, which is a little bit less of a priority nowadays for us because we found it's a standard that didn't really take off. We still have CMMNJS around. So we have tooling that allows you to build and edit CMN diagrams. Then also we edit stuff which is nonstandard. So for example, we recognize that forms are extremely important as well.
Nico Rehwaldt (05:45):
So in this whole BPM space, when it's about communicating processes and sessions, basically the algorithms in your organizations, what are the things that are important for communicating that? Well, it's the process itself. This is why we have BPMNJS, so we're covered. It's also decisions. How are those decisions being made where DMN is a good standard? It's a great standard, it's a powerful standard. So what is missing is forms are also extremely important for users like this in terms of being visual, right? Because forms is something that people, when you consider user task, automation forms is the language of that, right? So this is why form.js nowadays is also part of our BPMN family. Because we want to basically provide the whole package of drawing tools, but also viewers and embedding libraries. So this is basically a little bit where we came from actually being a bpmn.io, or being a project that hosts BPMNJS. Then realizing, well, we're a actually project that hosts any kind of library that makes sense in what we at Camunda called it, this BPM space, right?
Nico Rehwaldt (07:00):
We built all the tooling around creating those diagrams, but also embedding them into your application.
Josh Wulf (07:09):
So that makes a lot of sense for me in terms of the business value for Camunda of having these libraries. What's the reasoning behind making them open source or source available as they are? And making this into some project that's kind of, in some sense, very much supported by Camunda but in some sense, separate from or outside of Camunda in terms of its brand, its identity on the web, all of that kind of thing? What was the reasoning behind that?
Nico Rehwaldt (07:40):
Well, it's kind of interesting and tough question to answer. But one of the reasons it's open source, it's basically me. I would imagine that is the case because I was, I was always pushing to make this thing available, open source/source available, but also standalone. Because it is something that is very, very valuable standalone outside Camunda. This is just something that I personally believe in, maybe right or wrong, I don't know. But I'm a fan of the unit's philosophy, right? Do one thing and do it right. As Camunda also, if you consider Camunda as a product, as product stack, we are also fans of the unique philosophy. I want to give you one example, in CA8 you have the core engine, which is open source, right? You have this auxiliary tooling around it, operates past list, console and so on.
Nico Rehwaldt (08:33):
Those things, they interoperate with the core engine. But you don't have to use them. Right? You can decide this part that you want to use and the part you don't want to use. So it's really composable. If you look at Camunda from the architecture point of view, it's really a lot of tools that one thing do it right, they are composed with each other. You can decide to pick one of these or not. If you look in how many of our customers use our existing tooling, we're building a web modeler, but a lot of customers build their own web modeler, and how do they do that? They do that based on bpmn.io. So they basically use the existing tools that we provide out of the box as a building block, great tooling for modeling, which is also customizable, which is open, right?
Nico Rehwaldt (09:16):
They use it and build their custom modeling experiences. This is something that, especially when they're in centers of excellence, for example, right? Where they have a lot of staffing for it, they also see return on investment to invest heavily in this custom tooling. This is where having this BPMN editor standalone not really a fight into Camunda, but really being standalone, being self-contained to a certain extent, helps a lot. So it helps us to build tooling that is reusable and customizable for our customers. Basically forces us to do that because we always need to define interfaces. Also beyond our customers, there is this case for, well, anytime we open upwards like BPMN, in this case BPMNJS and our tool. We open that up for the community and we do just a little bit of marketing. We make a name for ourselves.
Nico Rehwaldt (10:15):
Nico Rehwaldt (11:13):
So we, as a company, want to make sure to also secure our investment. This is why bpmn.io, for example, is not 100% open source. So it's all source available. So you still need to embed the bpmn.io logo, whenever you embed BPMN.
Josh Wulf (11:28):
Small price to pay for all that code and functionality.
Nico Rehwaldt (11:33):
Honestly, that's a very small price to pay. I 100% agree with you. I mean, we started off 2014. That was basically February, 2014 when we launched. We spent like five or six or seven years of engineering effort in a core library that is very intuitive. People approach us in the forum and they literally ask us, "I am searching for something like auto cut or whatever, like some modeling, dialect, some modeling language. Is there something from bpmn.io?" Then we ask like, "No, there's not, but what exactly are you asking for?" "Well, I'm asking for tooling, that works as good as BPMNJS." So they actually ask for the experience, right? So you've built tooling and, yes, there's room for improvement. There's always room for improvement. But you have tooling overall that just gets the job done where this whole BPMN and getting from ... You basically need to talk to people and you need to basically draw all those processes.
Nico Rehwaldt (12:32):
You need to establish a shared language and synchronize over the image. This also is extremely complicated for people. So if the tooling is also complicated to use, if the tooling gets in your way as well, right, that's a problem. So we've built tooling that is not in your way as much as possible. We see people actually recognizing that, and that's something you can just be proud of. That they're like, just, "Do you have support for modeling dialect X? We just want to have a tool that works for modeling dialect X, and bpmn.io all the way."
Josh Wulf (13:06):
Yeah. So you touched on it here, but where is bpmn.io now? Where do you find BPMNJS? What's the weirdest place that you've ever seen it?
Nico Rehwaldt (13:20):
That's a wide question. Where is it now? I mean, you could ask like, "What's the place? How mature is it?" That's one way to look into this question. One way is to where to find it on the internet is another one.
Josh Wulf (13:33):
I kind of mean it, in the sense of, it's in the desktop modeler, it's in the new web modeler and Camunda Platform 8, which everybody's asking for in self hosted, is it in visual studio? Can you find it in Eclipse?
Nico Rehwaldt (13:47):
So what are the tools that integrate it, right? In Camunda, but also outside of Camunda? If you look at the Camunda tool stack, you will see it in most of the tools that we built. So this is also where the investment from the Camunda site into bpmn.io pays off over and over again. Because you will see it in our C7 Platform, in cockpits, [inaudible 00:14:14] Tasklist. You will see it in C8 Platform. I'm not sure about Tasklist, but at least in Operate, in Optimize, in the web modeler, but also desktop modeler. Basically everywhere, either embedded as a viewer for BPMN, but then also as a viewer. Consider it's similar to open street map where also open street map, you're able to add additional markers, right? So you are able to embed it as a viewer, but still add a lot of interactivity on the diagram.
Nico Rehwaldt (14:45):
This is something where this is a way we embed even in places which are not editors. So all of our tools are both editors, to conveniently draw stuff, but also available as viewer distributions, where you can annotate. So this is basically the use case, how you would see those diagram. BPMNJS, in particular, end up in Operate, which is just viewing only. But for example, you'll see, okay, this is the place in your process where a certain incident happened, so we'll just add a marker. Yeah, so basically it's added to most of our Camunda tools. The desktop modeler, as you know, is a standalone it's Camunda implementation tool, desktop. Which you would use alongside your IDE. You would use visual code or IntelliJ for programming. Whenever you want to edit and implement your processes like your BPMN diagram or draw them the first place you would use a Camunda desktop modeler. The web modeler's new, more or less, on the block, right?
Nico Rehwaldt (15:49):
Which is part of Camunda 8. Over there, if you don't actually .... Are heavily into the desktop development experience, right? But you just want to plug stuff together. Then you basically have the web modeler, it is embedded there, but the diagrams are not actually saved on disk, but they are saved directly in the cloud. You can share and collaborate with your colleagues on those diagrams. So, yeah, this is where they are embedded as part of the Camunda stack, basically everywhere. Outside the Camunda stack, they are embedded in a lot of places as well. Many places we don't know of, many places that we do know of. So for example, if I look at BPMNJS, and there's some interesting statistics you can find just where is BPMNJS used in open source projects, or sources available to GitHub. So GitHub nowadays claims that BPMNJS is embedded into 2,200 openly available applications on the web doing whatever different things, 2,200.
Nico Rehwaldt (16:57):
Most of those we don't know of, that is a freaking number. That's an astonishing number. Some known places, for example, we also, as part of the BPMN project, we also host our own extension for visual studio code, which you can install via the visual studio code marketplace. This is not a Camunda implementation extension, right? So it's not Camunda extension for visual studio code, but just for BPMN diagrams. Other people as well, so there's actually a competing ... So just recently I think a community member published his own BPMN extension for visual studio code. So there's even competition on who gets his BPMN editing into visual studio code in a better, more convenient way. All of those are, many of those are powered by BPNJS. There's also some competitors, for example, there is a confluence plugin for BPMN, which is embedding BPMN.js, but not only BPMN.js, but a lot of the tooling that we've building around BPMN.js.
Nico Rehwaldt (18:01):
So this is maybe something you asked, what is bpmn.io? So I said, "Well, it's a combination of different modeling tools, BPMNJS, DMNJS, bond.js, DMNJS." That's not entirely true because it's also a whole ecosystem around it. For example, it is BPMNJS, yes. But it's also a lending solution, a solution to validate your BPMN diagrams using configurable [inaudible 00:18:28] rules. Which is something that in Java you would call it sona type, which would just check your Java source files and tell you the quality of your code, right? In Java script, everyone is used to [inaudible 00:18:38] and prettier auto formatting, but also, okay, improving the quality of a source. Well, it makes a lot of sense to the same kind of infrastructure for BPMN. So we are providing that kind of infrastructure. Not part of BPMNJS, but part of the wider ecosystem.
Nico Rehwaldt (18:53):
We have our own engine, which I've pitched this year at community summit, if someone wants to follow along. Which is a BPMNJS token simulation. It's basically a fully BPMN spec compliance token simulator. You can actually start the process in your browser, and then you can see how it works through the diagram. Also it forks when there's parallel gateways, and then it joins again, waits in places where it's supposed to wait and you can drive the simulation forward as a user. Why would we build something like this? Interesting question, right? It goes beyond this basic, you have an editor and you have a viewer. Well, you would build it because our mission is to also empower people, right? By providing this kind of tooling, providing it open, providing it easy for you to embed we make BPMN accessible to you as a user.
Nico Rehwaldt (19:43):
In the past, you had to install a full appliance or you had to buy enterprise architect or whatever different tools are out there to start with modeling BPMN. With bpmn.io or BPMNJS you just have to embed a single script tech. You have it, right? You can actually start. As a user, well, there's other aspects in terms of empowering the user. We've built tooling that is not in your way. That is as intuitive as possible. That prevents common errors. For example, anything your model is always going to be valid BPMN, this is one of our design philosophies. And the same applies again for DMN, but also for forms. So there's no invalid states. It is not a drawing tool, but it's really a domain specific. It really knows standard. But then there is this about DMN is still complicated. So you have to understand this idea about token flow. So this is where stuff like the token simulation plugs in by providing additional tooling that you can actually follow along the token, really play through the thing.
Nico Rehwaldt (20:44):
It helps certain kinds of users, especially those getting started with BPMN, really dive into, "Ah, okay, this is how execution would happen later on." So we are building a huge amount of tooling around the core, just editors and viewers.
Josh Wulf (21:01):
What about for the last year? What's the highlight or highlights of bpmn.io over the last 12 months?
Nico Rehwaldt (21:11):
I would need to double check the ... I think we're publishing some year in review block posts usually. So for anyone who wants to follow along bpn.io/block for some updates. There's also every time there's a little bit of summary what happened. But I think last year, I think the major part was getting form.JS into the bpmn.io family. Form.JS is our library for intuitive modeling of forms. Right now you could call it just a little bit limited and also different from the other tools, BMNJS, DMNJS. It's not actually based off a particular standard. But really because it doesn't exist, the standard, at least none that we know of that has seen white adoption. We're basically building our own also data format stuff around it. But form.JS is really our solution to communicate in user task, heavy automation and/or documentation use cases, right? Form.JS allows you to intuitively describe forms, inputs, outputs.
Nico Rehwaldt (22:18):
So this is one of the biggest features that landed. Other than that, we are always continuing to work on the core libraries, making them more intuitive. For example, diagram.JS is a foundation of BPMNJS, but also the foundation of DMNJS. It's basically the core diagram library that our tools are being powered. It got the ability to have different layers. So what we did then in BPMNJS, we implemented [inaudible 00:22:50] into embedded sub processes, which is something that we didn't have for a long while, but a lot of people were asking for it. So this allows you to hide complexity from diagram, right? And very conveniently just jump into a sub process, which has its own implementation. This is the second one. The third one is, just as a side notice, a token simulation working on actually now making it fully BPMN spec compliant simulator. So if you want to check that one out.
Josh Wulf (23:22):
Awesome. Last question. I was looking on the blog and I saw NFT integration lands in BPMNJS. I was like, "I have to check this out." So I jumped in there and it turns out that it's an April fool's notice. It's an April fool joke. But it's so, now it's the kind of thing where you're like, "Okay." I think it's called pose law. It's like any sufficiently satirical version of something is indistinguishable from the real thing itself. It's kind of like, NFTs are everywhere now. Why not on BPMN chairs? So, yeah, does it really do NFT support or is it just you're joking that it does that?
Nico Rehwaldt (24:07):
Well, my question to you would be, because I guess you looked into this year's April fool's blog post, right? Or April 1st blog post. Right? Which each of those April's fool's blog post we would usually put up an April fool's notice in the beginning of the blog post, because people would otherwise confuse it for an actual feature. Right? So this was a little bit what you mentioned. Would you really have confused that one for an actual feature without the notice?
Josh Wulf (24:39):
Yeah, I would. Yeah.
Nico Rehwaldt (24:40):
So that's great. That's great. Because-
Josh Wulf (24:42):
Nico Rehwaldt (24:44):
That is great because that's exactly the idea of our April fool's jokes. You see, we started April's fooling, I think 2014. We started the project February, 2014. I think it was already three months in. We didn't have better things to do than just April's fooling around. Why would you do that? Well, first of all, I think that's awesome to drive people's engagement and also to think twice about certain things they want. Also very creative to look into certain use cases. So for example, our first blog post was a very memorable one, our first April fool. For two reasons, one of the reasons was because we were, if you look at BPMNJS, the modeling canvas, you see it's very clean, right? BPMN it allows you to offer 150 elements or something, overall. 150 different kind of intermediate events, start events, but also activities and so.
Nico Rehwaldt (25:43):
But you look at the canvas, if you look at the [inaudible 00:25:46] and also the context pet, like the one that is, if you have one element selected. It's very clean. So then in the beginning people would actually argue, "You can't hide all that stuff. How do I find certain things? How do I find this signal start event?" Our answer is, "Well, you got to learn how to find and then you will quickly find it. You will do much more harm by showing all the 150 elements all the time." So our first April fool, which by the way, it wasn't 2014 was actually 2015. Our first April fool was actually about, it was called BPMN 2.0 modeling revamped. And we would actually have a [inaudible 00:26:27] that showcases like 50 different elements and gets rid of a lot of our convenience around contextual modeling and replacing, upgrading from a blank task to a signal, for example, start event.
Nico Rehwaldt (26:40):
Oh, sorry, from a blank task to a service task, or from a blank start event to [inaudible 00:26:44] start event. So we're kind of joking. We're kind of making fun of this. "Ah, but how do I find a certain thing?" But on the other hand, it usually picks up user feedback and/or certain trends. So this is basically what we do. In the next most noteworthy in terms of April's fool, because I remember I did this, I set this one up. Was working with a colleague at the time, [inaudible 00:27:12]. [inaudible 00:27:13] wasn't aware my boss at the time, Robert now CRO at Camunda, wasn't aware. Jacob, CEO of Camunda, wasn't aware. So I've published this one, marketed it and Jacob at the time was at BPM Next, which is a, I'm not sure if BPM Next is still a thing, but it was basically a meeting of the BPMN vendors, actually quite innovative stuff they were showcasing for this.
Nico Rehwaldt (27:44):
So he was there doing a demo or marketing, I'm not really sure. But he was actually calling from US. Right before he wanted to show the bpmn.io blog and he read through this blog post and was like, "Robert, interesting what you're doing there, but I'm not 100% sure this is good." We basically fooled him. He said, "Okay, you guys really know to do it, but this is going in the right direction?" He was very ... It was great. It was great. Then Robert approached and was like, "Nico, Jacob called me and he's not 100% sure. What are we doing?" I basically fooled everyone. That was the best one. If you start like this, you got to keep going. From there on, we basically published an April fool's every year, at least we try to.
Nico Rehwaldt (28:38):
It gets more complicated every year because we've already touched upon so many things. And for NFT, maybe because you mentioned NFT, why is NFT a good candidate for an April Fools? Well, I mean, just earlier this year, now the crypto market crashed, right? It's maybe not that cool of a thing anymore. But that wasn't the case on April the first and also last year. Crypto, you can have this or that opinion on it, but it's a hype thing. NFTs is also a very high thing. If you look at NFT as a technology, well, it's basically like you make public that you own a certain thing and by making public that you own a certain thing, you also need to make public the thing that you're actually owning. Otherwise there's little sense to brag about, "I own something, but I don't show you what I own." Right?
Nico Rehwaldt (29:36):
So the idea here in the spirit of this blog was, "Well, we are going to use it for BPMN interchange." So you are going to NFT your company's invoice process, but in order to brag about it, you got to make your company's invoice process public as well, which is obviously a no-no, right? This is the satire part of it. You're not going to do that because you're not going to open source the algorithms of the company usually. But if you want to brag about this at openly, an NFT might ... You have to make that stuff public as well otherwise there's no sense in it.
Nico Rehwaldt (30:10):
So we kind of parody this whole NFT thing in a way, but also try to combine it with certain desires that we have in the community. Because diagram interchange and collaboration is something very important. BPMN at the end, BPMN is about communication and it's about collaboration, right? So we always try to strike the balance. I think when pandemic, back in the first year in the pandemic when everyone was really worn out and especially in Germany, we had kids at home a lot. I had kids at home. I couldn't help but create a, it's a BPMN kids at home edition. Which were just the BPMN with child friendly symbols. The case was like, before you get crazy with your children at home and juggling all the different responsibilities, well just do a process meeting and discuss with them using BMPNJS. "This is a process we're going to do, no more discussions." Which is kind of, I think that it was first in the pandemic when we did modeling kids at home edition. I think it's cool stuff.
Nico Rehwaldt (31:17):
It's also means we're not ... I mean, we're in a serious business. We are helping people a lot by building these tools for editing, understanding, viewing, embedding BPMN and related standards. But also we're still trying to not, what do we say in English? We're trying to not be too serious as well.
Josh Wulf (31:37):
Yes. Great. Any call to action for people? Any final words, anything how people can get involved, or what would you like to leave people with?
Nico Rehwaldt (31:47):
If you're interested in Camunda at large, you will naturally get exposed to the new and noteworthy bpmn.io because all the things that we built, we built it for purpose, we built it for need in our Camunda tools, but also in our bpmn.io community. But if you're interested in core modeling, like basically bpmn.io stuff, you can always follow along our Twitter, but also our website, which has an RSS feed and follow along what we do. If you are using our tools and your feedback, don't forget we're open to feedback all the time. We really strive because of your feedback so you can use BPMNJS. Go to GitHub, open an issue, we'll be able to learn and improve based on your feedback. So that would be my biggest wish. Whenever you want us to change something, raise your voice on GitHub or on our forum. Then we can actually look into it for the benefits of you, but also everyone.
Josh Wulf (32:51):
Fantastic. Thanks for driving the bpmn.io project from the beginning and continuing to steward it and shepherd it through into this new decade. Thanks for coming on the podcast this month, Nico.
Nico Rehwaldt (33:07):
Thanks for having me.
Josh Wulf (33:14):
Roll the credits! Audio engineering provided by Inclusion Audio production, check them out at inclusionaudio.com. The soundtrack is provided by the legendary Japanese Progressive House, DJ Shingo Nakamura, courtesy of monstercat.com.