I was hoping you could tell me what the advantages and disadvantages of BPMN are in a developers perspective.
I'm comparing UML with BPMN and a found a bunch of advantages and disadvanteges for UML but none for BPMN.
It's largely down to audience and purpose. In terms of modelling language, BPMN and UML activity diagrams cover pretty much the same conceptual space with different notations. The notation thing gets religious very quickly. I personally prefer AD notation over BPMN - but it's a very personal thing.
Broadly speaking, BPMN tends to find favour with those coming from a business process modelling / business analysis background. UML ADs tend to be favoured by those coming from a software perspective. Tool support tends to mirror this: the high end process modelling tools (casewise, aris, etc.) are more likely to support BPMN; software modelling tools (MagicDraw, Sparx, etc.) favour UML. However there's increasing crossover there. I've used both with business stakeholders with no issues in either case.
Finally is purpose. Are your diagrams going to be for human consumption only or used as a specification for some form of analysis/code generation? If it's not just pictures then your tool chain may well be the deciding factor.
If you want a more detailed description of the differences, have a look at the answer in this forum post.
A new BPMN Profile has been discussed at the OMG. UML can easily generate code even with an activity or state diagrams. You just need to add stereotypes in your model then a parser will take the xmi and create code. The OMG specification will define which stereotypes should be used and why. Really a very good idea !!
In my company we have stopped using BPMN and are only focus on the activity diagram which is more accurate because built on the top of a standard language. Having also class diagram, usecase and activity diagrams allows to model faster.
We get a running code from our activity or state diagram. We debug with our class diagram.
We use the same metamodel for all diagrams and therefore can trace activity to code implementation and through class diagram. I mean that the code is reversed once generated and then we check all requirements and the architecture in order to have a nicer object architecture.
Everything works well :-)
We are now waiting for the new profile specification and will implement the needed stereotypes in order to cover BPMN.
My answer to your question is that we don't need anymore BPMN and should move on to UML 2.3 BPMN profile implementation.
BPMN is for modeling business process flow, isn't it? That's not exactly what UML is for. The goal of UML is to model a software from different view and ultimately not to have to code it (yes that's kind of ideal).
The main arguments for BPMN from a business perspective are usually:
When building BPMN diagrams from scratch with many stakeholders, it is ok to mix tasks of different levels of hierarchy, which can be detailed out or summarized later.
The basic language elements can be thought quickly even to a non-technical audience.
The developers can immediately start working and attaching source-code and scripts to the BPMN-diagram by workflow and business process management software like Camunda.
The main drawbacks are that
The initial BPMN sketch (usually by the business) usually needs many iterations to arrive at a diagram which allows for implementation.
It is not straight forward to represent different roles since the usual concept of lanes in pools might not be enough or lead to huge diagrams, see e.g. BPMN: multiple roles in a row
See the MDA on OMG (Model Driven Architecture):
- we use BPMN only for Computation Independent Models (CIM)
- we use UML only for Platform Independent Model (PIM, high level design) and Platform Specific Model (PSM, low level design).
- using BPMN for any "software systems" or UML for "business" have no sense (see UML v.2.5)
- for developers: we can make transition from BPMN business process to Use Case, it is good tool for defining scope of requirements for software https://www.visual-paradigm.com/tutorials/from-business-process-to-use-cases.jsp
If you are looking for similarities, both UML and BPMN diagrams can be described using text.
PlantUML
BPMN Sketch Miner
Related
When designing for a software, what is the correct order of UML diagrams we have to do? Starting from the Use Case diagram, what would be the next diagrams until we have enough to start coding?
UML is just a modeling language, not a software development methodology. A well-known methodology that provides guidelines for using UML in its software development process is the Rational Unified Process, although its popularity has declined. Still, it is not easy to determine the order of the UML diagrams prescribed by RUP from the available material provided by IBM. I have written a paper http://admiraalit.nl/admiraal/WhichUMLmodels.pdf which may help you with that.
For a simple application, a class diagram and a component diagram may be enough, but it depends very much on the type of application.
Please I need help in understanding this two approaches in the uml world. I am a programmer who is new to uml. I just started learning uml lately but kept getting this phrase asked all the time. - Are you modelling or drawing?. An explanation is needed with clear examples.
This link hinted just a little but I am stil confused -- http://modeling-languages.com/drawing-tools-vs-modeling-tools/
UML is a modeling language, which has a graphical notation. Its semantic is precisely specified by UML 2.5 standard of the OMG and also the international standards ISO 19505-1:2012 and 19505-2:2012 (although the latter corresponds to UML 2.4.1).
THere are two different approaches to UML diagramming. And it's heavily influenced by the tools you use:
Drawing tools generally offer UML shapes to be used in drawings. But there is no deeper meaning behind the shapes. It's only pictures. These tools would allow you to mix a use case with a class or an actor in a deployment diagram. The advantage is that you can do what you want. The inconvenience is that what you want may not be compliant.
Real modeling tools let you combine only valid UML elements together and ensure consistency of what you draw with the deeper meaning of the UML language. And they build a true and comprehensive model behind the scene by combining all the facets of the different diagrams.
Modeling tools can do smarter things. They can relate for example a class to their object instantiations in sequence diagram. They can help you to find all the other models in which a specific class is used. If you rename a class or add a property in one diagram, it'll be automatically reflected in all the others.
Modeling requires more discipline, but it's more powerful in the end. Some modelling tools can even use their understanding of UML to generate code out of the model.
You can use UML diagrams in very free way and you can use them up to the specifications. There are even different UML tools - some support only free style diagrams/drafts, some check dependencies and correctness and thus create models. There are some tools in between (MS Visio is one of them)
Nothing is ideal and fitting for everything. For example, some strict tools (VP and EA) forbid to make number-named classes, but according to UML specification you MUST use number names for anonymous classes. But -sigh- we have what we have.
Use of UML as such is not strictly predefined. So, you can use it for freehand drafts, later work on them more thoroughly and make them models. Or do only drafts. Or only models. But at any moment you should know how strictly are you keeping up to specifications. Or at least, trying to keep up. But even very free draft can help you greatly to understand the task or to think in a more productive way.
I often draw a dataflow on a sheet of paper. Even the planning of my little tools is done on a paper.
There exists UML.
The problem is - I don't like it. All the tools I've used (Visio and a lot of online editors) are just not flexible for my hands. With a pencil you can easily draw shapes and connect them, describe them.
What could you suggest in order to create a diagram of data-flow, sequence diagram, etc. in the fastest, most natural and easiest way except on the computer not the paper :)
****Useful links as posted in comments:** SO Link #1 SO Link #2
Right now I am curious about 2 things and one of them was in my minds quite long ago:
1) Mindmap - I've tried a while ago, quite liked it but abandoned. Hoever will give it another try
2) Whiteboard. It would be the easiest and most natural method, except that taking a photo and storing it somewhere on a computer would make the process repetitive and boring.
Has anyone other interesting ideas? I would really like to hear what others are using to design their software and the progress of it.
Thanks a lot!
Why do you want to hand-draw the UML at all whether it's on paper or on the computer?
I agree that you need a model to represent the design. But even in large projects of about 500 man-months, I observed that only 3-4 sequence diagrams really matter and have a chance of surviving the entire lifecycle of the application. Those 3-4 sequence diagrams (and class diagrams that represent their static time relationships), usually represent the high level design of the application.
Or, look at it this way:
Any decent enterprise application will not have 20 different call flows. There will be one or two generic (or abstract) call flows, which all the concrete use cases implement. Let us take a simple Struts / EJB application. The generic flow will be something like - an action class calling a validator and then calling a stateless session bean, which in turn calls a domain class, which will call a DAO. All the use cases of the application just implement this flow with concrete classes that are specific to that use case.
Do you agree?
If you do not, I would like to hear about applications that have 20 different call flows and survived for 5 years after the first release.
If you agree with me, we are boiling down to 3-4 class and sequence diagrams even for large enterprise applications comprising several thousand classes. Why is it a big deal how you draw and maintain those 3-4 diagrams?
You might say that you want to document all the use cases for training or documentation purposes. During my last 14 years of experience in the real enterprise software world, I don’t remember seeing well 'maintained' UML documentation. First of all, good documents are difficult to produce and are not found that often. Secondly, they are out of sync with the code most of the time. Most of my experience is with large banks, insurance companies, Auto companies, etc. Those environments are just too hectic and their resources are limited (really? Are we talking banks? Yes, difficult to believe, but true) for 'maintaining' good documentation.
So am I suggesting that we get rid of UML?
No. We need visual models to represent complex systems. Human brains seem to be at their best when processing visuals. The visual cortex, which is responsible for processing the visual images, is the largest system in the human brain.
So what is a reasonable solution to easily produce and maintain UML models?
Probably we are better off using the current crop of UML tools to draw those 3-4 high-level UML diagrams. If you hate using them, check option 3 below.
For the diagrams at the next level of abstraction (any useful models should have different levels of abstraction), generate the UML from source code. You can generate both class and sequence diagrams.
In this age of agile methodologies, why not just write the shell classes and generate those 3-4 high-level UML class and sequence diagrams as well? This way there won't be any UML to maintain at all.
The source code is the truth.
Can you argue against that statement? If not, why not generate the models from the source code itself? I am not suggesting the round-trip engineering, by the way. I am just suggesting a one way trip - from code to models.
There are 2 main problems however with the generated UML.
When we hand draw a class diagram, we show the relations between the classes involved in a scenario. Most existing class diagram generating tools allow the user to drop the Java classes (the source code) into the tool and the tool automatically shows the relations between the classes. The problem here is, how does one know about the classes involved in a scenario to begin with?
The second problem is the verboseness of the generated diagrams. There are tools available to generate runtime sequence and class diagrams for a scenario. But the diagrams are often very verbose and defeat the purpose of models, whose purpose is to highlight the important aspects and filter out unimportant details.
Good UML generating tools should address both the above problems. There are a few tools in the Java domain that try to address these problems. Check the discussions below:
What tools should I use to visualize structure of my code
Are there any tools for detecting architectural and design patterns in code?
I hope I answered the original question:
Has anyone other interesting ideas? I would really like to hear what others are using to
design their software and the progress of it.
I am the author of the runtime UML generating tool MaintainJ, but I tried to address the original question in an objective manner. Your comments are welcome.
There are various tools that allow you to create diagrams based on textual input. There's some up-front learning in that you need to learn the syntax. However it's not hard to do. Once you have, creating diagrams can be very fast. There are some downsides; in most cases there's limited ability to change the layout/style. Significance of that will depend on whether you like their style or not.
There's a growing number, here's a few you might want to look at:
UMLet: desktop app, supports most UML plus various other diagrams. Can also create your own custom shapes & connectors. FOSS.
WebSequenceDiagrams.com: online sequence diagrams.
TextUML: desktop app. Focus is executable models, auto-generates class diagrams. FOSS. It also has an online commercial sibling.
hth.
I like using a whiteboard and a camera. For even more flexibility, use post-it notes on the whiteboard.
I use ER diagrams (on the whiteboard) to model my data, and message sequence charts (on the whiteboard) to model the data flow. I'll also do quick mockups of UI pages on the whiteboard.
Asides from that, I use Ruby/Rails to code server side and HTML/CSS/jQuery/JS on the client.
If even Visio is not flexible enough, I'd suggest a digital whiteboard or touchscreen with a whiteboard software. After some accommodation you could probably use a simple tablet (without display) as well - they are really cheap.
Regarding pure software: we are trying to achieve a "pen-like" input method with UML Lab, but it currently supports Class Diagrams only...
I think that the UML and code should be mixed using a class diagram. You model your architecture with the class diagram (e.g package, classes etc....) then you code your business finally multiple iterations between code and model.
I think that UML should more be oriented to code but not to focus on textual input.
The problem with standard languages, such as UML, is that you have to invest a considerable effort to learn the language and the modeling tools. These languages are defined by an expert consortium, e.g. OMG, that proposes a language specification suited to the biggest overlap of design problems in a certain domain.
Why not defining your own language that fits exactly to your needs and your specific problem? Such languages are termed Domain-Specific Languages (DSL). Instead of investing into learning a language that's complex, you invest into the definition of a languages that exactly suits your needs.
There are numerous approaches that support the definition of DSLs. The most widespread is the Generic Eclipse Modeling System (GEMS). Personally, I made great experience with GrGen due to its versatility and the possibility to automate working steps using graph transformation.
No. There are various other ways. UML is just an option.
Pen and Paper Prototyping is a great option too, it doesn't have to follow UML.
Mind Map is another great way.
For more adaptive software processes, UML use is encouraged to be as minimum as possible. Such as, teams that practice Agile or XP tend to use UML less and they would rather rely more on informal means to conceptualize the software. In a rigid structured company, UML can be rigorously followed.
UML provides us with many different kinds of diagrams. but in many situations only small set of them is really necessary, what do you think about the most usefull UML diagrams, even for very small projects?
Well, it really depends on the project. I think it is wrong to just create any UML diagram as a rule without assessing if it will be really usefull.
However there are some obvious situations when they're usefull:
If your project will be any way large in terms of OO structure then it is usually usefull to create a class diagram. That way you can deal in abstractions until it is time to get stuck into details.
If you project will be mostly UI driven then it can be quite useful to create a Use Case diagram as a way of defining requirements. This is especially useful if you can get your customer to buy into this method.
If it looks like your system will have many interactions between objects then creating a sequence diagram can be usefull for understanding interactions. Also, I think sequence diagrams are the most intuitive for developers as I notice a lot of developers instinctively diagram there interactions like this - even if they're not familiar in UML - in simple powerpoint\visio diagrams.
Deplyoment Diagrams are obviously usefull if your system will use many technolegies and require a lot of HW.
I think key point is that only use UML when the software becomes complicated to the point where we need to think in abstractions - UML helps visualise and document these abstractions.
I do not think UML diagrams are essential part of a project documentation whether we're talking about big or small projects.
Good comments around provide much more value than sophisticated diagrams.
I personally have an impression UML is a toy of the academia world. It's the only place I was hearing and seeing people running around with UML, SOA and so on.
In my working practice I've barely seen UML at all. Well, maybe once during my term project and at my current job where we've got a couple of eight-years-old (and just the same deprecated) diagrams somewhere on the internal FTP server.
Usually formal UML is too much for small projects. Just stick to basic class diagrams and simple use-case diagrams.
Small projects are (in my experience) more often subject to change so your diagrams will be out-of-date very often. You are much more likely to keep a less formal diagram up-to-date than redo all the fancy UML stuff.
UML is dead, nobody who matters uses it.
The only people that use UML are consultant types who write articles and are trying to be formal and fancy and lack substance.
If UML is so great why cant i find any for any of the projects that Google publishes on googlecode ?
Where is the UML for Ruby or Python or DOT NET or Java ?
UML is dead because the use of open source crapy tools !! Many companies take free tools and just create few diagrams, no training at all then they say that this is not useful.
This is non professional and very limited use of UML is a real disaster for projects !!
I'm quite familiar with UML for modeling object-oriented applications. However, I'm not familiar with anything specifically designed for designing and/or modeling procedural, functional, or any other paradigm. How do you design or model applications written in a non-object-oriented language?
Oh golly, there's a blast from the past.
We used to use flowcharts, pseudocode, data flow diagrams, structure charts, Hierarchy-IPO, "coathanger charts" (which are really a variant of flowcharts), Nassi-Schneiderman diagrams. Among others.
Oh, SADT is another one.
SSADM - I think I've still got my certification in a box somewhere...
UML can be used for modeling non-OO languages as well. I use UML for modeling just about anything. To be fair the core of UML is OO focused, but much of the behavior, instance level, and less common structural types work for non-OO languages. However, UML is for design in OO not implementation, your building blocks/objects are just different, modules, or whatnot.
Many of the diagram types mentioned by Charlie Martin have analogous UML representations. Even better it is a model not just a diagram/view.
Example: LISP is not OO based. So create a keyword or stereo type for classes that is function. The attributes are the arguments as it has no state. This is not perfect, but it is the most approachable.
Example: COBOL/JCL is not OO based. Have each PACBASE package be a component and have structural components as your COBOL. Artifacts can be your JCL.
Let fact that UML is broad and loosely defined to your benefit and re-purpose UML parts. You can always formalize it with a UML profile. Where I work this has been a point of discussion for some time. Mainframe programmers do not see OO design and OO-UML as relevant, but it is only partially true in that the core or how far most people go with it is just to the class/structural stuff and use cases, which is OO focused.