Shell's TechBlabber

…ShelLuser blogs about stuff ;)

Looking at software design with Visual Paradigm


Visual Paradigm is a program which can very well change the way you approach software design. Its key goal is to provide an environment which gives you full access to the most commonly used standards in design modelling while also making sure that despite the complexity with some of those models you’ll always have the right tools at your fingertips.

Now, I need to get one thing out of the way: I am probably biased. I’ve been using Visual Paradigm for over 8 years now and I still seriously like this software.

But then again, I’ve also been using some design models, like UML, for a long time as well and I also continue to appreciate what those have to offer. So… Time to do a review on a software product which has seriously changed the way I approach software developing.

Brief history

My story begins when NetBeans 4.1 (A Java IDE) got released. I had been looking for a solid way to make myself more familiar with Java and I figured that I should go straight to the source (Sun developed Java, so I began looking for an IDE on the Sun websites). At first I tried the Sun JavaONE studio which “worked” but wasn’t very sophisticated. However, the IDE also provided support for UML modelling and that managed to catch my attention somehow. Soon afterwards it became clear that JavaONE was going to be abandoned in favor of NetBeans, which really made sense Smile


Because NetBeans had a very rough start and also tried to appeal to former JavaONE users they made a very valiant effort to port the JavaONE UML plugin over into NetBeans but eventually failed. It turned out to be very unreliable. The NetBeans project really gained my respect here because they didn’t mope around but simply admitted that this wouldn’t work, and pointed interested developers to Visual Paradigm; a company which provided integrated UML support for NetBeans (as well as several other IDE’s). Better yet: they also provided a free community license which was limited in funcionality but still provided full UML support. Even though I didn’t really need it I got myself a modeler license that same year and I never regretted it.

From integrated to stand alone + integration options

The program I had licensed was called SDE-NB (Modeler Edition), in other words: a UML design program specifically made to be used within NetBeans. The main advantage over the SunONE (and later NetBeans) plugin was that your UML designs would become an integrated part of your NetBeans projects: you only needed to keep 1 project open, while JavaONE treated UML diagrams as completely separate projects. This could become a burden if you were trying to make a diagram based on your source code (think about class diagrams) and had to switch back and forth.

But this was not the only software Visual Paradigm maintained. They had a whole arsenal of modeling software. Some focused on software development, others on more abstract topics such as business modeling. And what I seriously appreciated: Visual Paradigm was constantly busy trying to make things better.

All of this eventually led up to Visual Paradigm fully focusing their attention on one single program which could provide a solution for pretty much all modeling needs. This was really huge for people like me who had licensed the SDE environment because you now gained access to two different programs: first the integrated environment for the IDE which you were using, but also a fully stand alone program which you could be used to work on your models as well.

And that brings us to the main topic of this post…

Visual Paradigm 14 (Modeler edition)


As mentioned earlier Visual Paradigm is a program which allows you to create a large variety of diagrams that can help you to visualize your software, your database designs and even the business processes which you might be working on to automate. It can be used in two different ways: first is the stand alone program as shown above (and which I’ll be describing), the other is the IDE integration: Visual Paradigm can also be used within NetBeans, Eclipse, IntelliJ and Visual Studio (VS Professional and up only).

The software is developed in Java which means that it’s also relatively easy to use on other platforms besides Windows. Better yet: you also don’t have to worry too much about licensing. I started using VP (the SDE version) on Linux and eventually moved to Windows as my desktop environment. Switching was no problem for Visual Paradigm.

Also the software has seriously matured over time, so much that it nowadays provides support for plugins. There’s a full API included which you can use to develop your own extensions. However, that’s something which I won’t be covering in this blog post.

Supported modeling languages


Visual Paradigm supports several modeling languages where the most commonly used ones are UML (Unified Modeling Language), SysML (Systems Modeling Language), SoaML (Service-orientated architecture Modeling Language), ERD (Entity Relationship Diagram), DFD (Data Flow Diagram) and BPMN (Business Process Model and Notation).

As you get a broader license the program will also provide more modeling capabilities. However it’s my experience that the Modeler license (the lowest tier license so to speak) already supports a very diverse feature set which allows you to chart just about everything you’d need, you can see an overview of all supported diagrams on the right. The only two not listed are the Overview diagram and the Grid.

One of the key strengths of Visual Paradigm is its interoperability. In other words: in providing a specific collection of diagrams it also allows you to easily re-use certain elements throughout these diagrams. A package element for example could be used in a Package diagram, a Deployment diagram and a Class diagram. The advantage is that any changes you make to the package element (name, description, etc.) will be immediately applied to all the other diagrams its used in.

This can become extremely useful when you’re working on larged projects, or when you’re using sub-diagrams, which is another key feature; every element in a diagram can be used to reference another (sub)diagram. This allows you to set up a diagram which describes a very broad feature set, and which also references sub-diagrams to cover specific sections in more detail using the same or another diagram type.

Flexibility in every possible way…

Visual Paradigm allows you to configure and change the software’s behavior in just about every imaginable way. As you might have seen in the screenshot above the program uses a ‘Ribbon type’ interface which is somewhat comparable to Microsoft Office. Within Visual Paradigm this is referred to as the toolbar, and just like with Microsoft Office it can be fully customized.

So what to do when you don’t want to use such an interface, what if you’re more familiar with the previous layout and want to continue to use that instead? Well, this is another fine example why I favor Visual Paradigm so much, they truly understand the need for backwards compatibility:


If you prefer the previous interface layout then a switch is but a few mouse clicks away.

Some specific Visual Paradigm advantages

One of the key problems which I’ve often encountered when trying to set up a design to base my projects on is getting the ideas I have in my head into my diagrams, and in a proper way too if possible. So making sure that my diagrams don’t end up in a huge blurry mess of hundred different options. Sometimes you may need to stop and think about your design project, which you’re basically using to think about your software project…

Fortunately Visual Paradigm has our back here; it provides tons of ways to help you get started.

My absolute favourite way to start a design project is using the Textual Analysis. Probably not much of a surprise for someone who also enjoys blogging Winking smile

A textual analysis is basically a written report. You can start and write something up yourself using the build-in editor or you can choose to import already existing material. Once you have an analysis description written up then the fun can begin: Visual Paradigm allows you to extract snippets from your report and use these as so called candidate items which are usable in your upcoming diagrams.

So by merely writing up a description of your project you’re also generating the building blocks for your diagrams, and I think that’s a very powerful way to start a project. So even when all else fails you’d still have material which you can use to build your documentation on. Win-win in my book:


Using your ‘building blocks’

So now that I have extracted a few elements I’m ready to begin with my first diagram: a Use Case. This will allow me to start thinking about nothing else but the mere key features (‘functions’) of my project. So I double click and add an actor, press control-space, and what do you know:


All I have to do now is press the cursor down key, select the model I want to use, and hit enter. Can it get any easier than this? Why, yes it can Winking smile How about adding the first use case itself? When you have an element selected in your diagram you’ll see a small square pop up in the upper right corner. This is the so called Resource Catalog; when clicked it shows you all the relevent elements which you have at your disposal. Now, obviously you don’t want to place your use case directly next to the actor, so click the resource catalog, drag it to the location where the use case should be and then let go.


You can see an example on the left. Here I’ve dragged the resource catalog into place, and now it shows me all the relevent items which are available as addition for my diagram.

To make things even more easy the top row of the resource catalog will show the most frequently used items, and as you work along it’ll keep track and refresh if needed.

So now I select the element I want, and after it has been placed I can enter the description it should have.

What makes this workflow so powerfull is that even despite the fact that I have a whole palette at the left side of my diagram (see screenshot above) I do not have to drag and drop items from there in order to set things up. Instead I can keep my focus on where it should be: creating the most optimal diagram layout.

It is these specific features, and more, why I favor Visual Paradigm so heavily for all this.

A (brief) look at software design

So why use this design approach in the first place?

There are many developers, speficially individuals and/or small(er) teams, who would approach software design as an extra burden which doesn’t serve much more purpose than making a nice presentation. And of course there are also those who wrongly assume that simply following a specific pre-determined design model (or design pattern) also counts towards software design.

And to make things worse… There are dozens of so called modeling languages available which you can use to create such software designs. Some of which can seriously overcomplicate things which obviously doesn’t help. I mean… instead of thinking about solving problems in your software you’d now be thinking about how to make some kind of weird “valid software presentation”; do you need to connect your models with a dotted arrow, a solid arrow or no arrow at all? Ugh!

But seriously, it doesn’t have to be like that, as I hope to have shown above.

So why would you want to spend time on all this in the first place?

There are several reasons. Setting up a design model can be just as useful as adding comments to your classes and methods; it helps to get up to speed with the way things work and keep a good overview of the functionality. I know what some might be thinking: “My code is its own language, just follow the way I coded and you’ll understand how things work”. Yah, but that creates two key problems. First it assumes that you’re actually capable to follow the applied logic. There’s often more than one solution to a problem. The other issue is time. If you have a program consisting of 30+ classes then how much time do you think it’ll take to get a good understanding of its inner working?

Speaking of time: you may be fully familiar with the source code now, but will you still be if you leave the project alone for a few months?

But the most important reason to bother with all this is the design itself. Thinking about software design, so how your software is going to work, can seriously help you detect and solve certain problems long before you’ve done any coding. For the simple reason that you’d be thinking things over before actually setting them up. And that can seriously help your project in the longer run. For example: have you ever though about what might happen if you need to expand on your program’s functionality?

Design vs. rewrite

What do MySQL, NetBeans, PHP and the Apache webserver have in common? At some point in time the whole project, or major parts of it, have been rewritten from the ground up. In most cases that was done to cope with problems which had crept in over time and which hindered further expansion.

Now, using software design doesn’t give any guarantees that this won’t happen, but when done right it can seriously reduce those chances. Simply because you’d be looking at a larger picture of your project.

Using modelling languages such as UML or SysML may seem boring at first, but once you give it a serious try you may end up surprised with the results.

April 22, 2017 - Posted by | Editorial, TechBlabber, Visual Paradigm | , , , ,

Sorry, the comment form is closed at this time.

%d bloggers like this: