JModeller
Group: Leeloo.
1 Abstract................................................................................................... 1
2 Statement of the
Problem........................................................... 2
2.1 Short Statement of
the Problem............................................ 2
2.2 Motivation.............................................................................................. 2
2.3 Goals........................................................................................................ 2
2.4 Skills Baseline.................................................................................... 3
3 Background to the
Problem...................................................... 4
3.1 Commercial
background............................................................... 4
3.1.1 ArgoUML................................................................................................... 4
3.1.2 EctoSet Modeller
1.3............................................................................ 5
3.1.3 Visual Paradigm for
UML 1................................................................... 6
3.1.4 SmartDraw.............................................................................................. 7
3.1.5 Together
ControlCenter 5.5............................................................... 7
3.1.6 Rational Rose......................................................................................... 8
3.2 Scientific
background.................................................................... 9
3.3 Technical background................................................................... 9
4 Appendix.................................................................................................. 10
4.1 Leeloo members............................................................................... 10
4.2 Project roles................................................................................... 10
The purpose of the project is to build a tool, JModeller, for visualisation and execution of Finite State Machines. Our main motivation for choosing this project is to meet the need for such a tool. Our goal is a well working and graphically attractive program. All members of the group have fundamental knowledge of the technologies to be used, but we will probably need to get further information on certain graphical algorithms. There are various books and resources where we can do that. Experts at NADA will be able to answer questions on correct implementation of Finite State Machines. JModeller can in some respects be compared to a UML modelling tool, and there are several on the market. We will use Java as the programming language. If possible, we will use freeware Java packages to solve parts of the problem. There is a Leeloo member catalogue with e-mail addresses included in the appendix of this document. Project roles are assigned to each member and included in the appendix as well.
When attending the OAD classes that covered some UML languages and FSM (Finite State Machine), some of us came up with the idea of writing a program supporting the drawing and execution of a FSM.
With the start of the MVK class approaching we made an inquiry among Nada employees whose research or educational activities are related to FSM, in order to find someone interested to sponsor our project. It turned out that Frank Hoffman (Ph.D.) and a researcher at ”Centre for Autonomous Systems” was interested. He teaches Object Oriented Modelling, Programming and Analysis course and related that he could use such a program as a tool for this course.
The purpose would be the visualisation of a FSM and the execution of a FSM given certain input. One should be able to specify a machine either graphically or textually. This may be achieved graphically, manually or with some layout support from the program.
We will strive to keep the program as modularised as possible. If successful, it shall be easy to add modules for other UML languages as well for Turing machines and something similar.
Our main motivation for choosing this project is to meet the need for an easy to use FSM tool. Depending on the user’s requirements in the future and on the specific ways we later chooses to solve the problems, this project may satisfy many interests as well as enhance various job skills. Here are some examples:
· How to work with a relatively large program.
·
Enhanced Java™
skills.
· How to write good tests for graphical algorithms.
· More general graphics and UI programming experience.
· Experience in the design of modular architecture and infrastructure
· How to create APIs for modules, where both the modules and the basic framework make use of the MVC architecture.
· An encounter with the XML instance SVG, our fileformat candidate.
· More HTML experience in working with the projects WebPages.
Further more, we consider this project a suitable one for providing some practical experience of software engineering.
We want to build a well working and graphically attractive FSM tool, easy to use and enjoyable for students as well as for teachers. We hope that having the tool within easy reach while learning about FSM will improve the intuitive understanding for the machines.
Educationally, we hope to achieve as many of the things that motivated us to choose this project as possible. In addition to that, we wish to:
· Get the eight academic points for the MVK and the PROJ classes before the end of this semester.
· Achieve improved communication skills.
· Achieve teamwork and management skills.
· Achieve administrative and organisational skills.
· Achieve customer relation experience.
All members of the group have fundamental knowledge in Java language but wish to learn more. Some members have advanced skills in special areas of programming. All of us have experiences of how FMS-machines work.
We already have the mathematics knowledge that we may need for the graphics part, and they who are responsible for graphics have already started to learn Java 2D. We have also begun to look at specific graphic algorithms, but it seams like we need to know more before we can make any conclusions.
Both knowledge and
interest for comprehensive design of the program are already in the group. Some
members have a great interest for GUI-programming. They who are responsible for
testing the program will probably have to learn more about different testing
methods. We hope that we will find that information on the Webb and by talking
to people with experience in the subject. We also have members that know how to
express them selves in English by speech and writing.
We might need more knowledge of how the
program could be divided into
smaller modules. If so, we think that we can find information about that in literature and on the Webb. It is still quite
difficult to see what kind of knowledge we will need, since the project is at
it’s beginning, and we cannot predict what kind of problems that will turn up.
The market in UML-tools is still a rather young market and there is a varying type of products today. Most of the products are aimed for professional development companies, who have users that know UML and are able to use it in their work. We were not able to find any pure Finite State Machine editors worth mentioning, but there are some that have similar content. Very few products on the market are freeware or shareware, but some companies choose to release demo or free starter versions to attract future customers.
It is difficult to say which product is the best available on the market. The choice of product depends on the needs of the customers and their knowledge of implementing an UML-tool in a project. One of the biggest and most complex tools is Rational Rose, which can support a complete development lifecycle, while SmartDraw is one of the more simple, and is more or less a canvas. There are also different opinions about the products. Some users would say that Rational Rose have several drawbacks besides the price. These opinions would be that the program follows user interface guidelines poorly, making it difficult to work with. Furthermore, it crashes far too frequently for being an enterprise class tool. ArgoUML on the other hand is both easy to use and a rather reliable.
We have listed some of the products on the market to give a better picture of the diversity in the quality of the products.
Open source (for any platform with Java 1.2)
ArgoUML is distributed on an Open
Publication License and supports the design, development and documentation of
object-oriented software applications. The product implements almost all the
diagram types of the UML 1.3 standard. Since the program is a project in
progress, the goal is to implement all diagrams in the future. ArgoUML is
available for free and can be used in commercial settings.
XML is standard saving mechanism in
ArgoUML and the GEF-format, the UCI Graph Editing Framework, is
used to edit the UML diagrams. The diagrams that are supported are: Class,
State machine, Activity diagrams, Use case, Collaboration and Object /
Component / Deployment (which is basically one diagram type in ArgoUML).
Sequence diagrams support is one of the features that will be implemented in
the near future.
The product provides full OCL syntax and type checking and is also able to generate Java-code from OCL-Constraints. It is, however, not possible to generate code based on State Machines, or vice versa. The product also contains Design critics, which analyse the design as the designer is working and suggest possible improvements. These suggestions can be indications of syntax errors, reminders, style guidelines or advice of expert designers. Some of the critics offer to automatically improve the design. A "to do" list user interface that presents action items in an organised form is also implemented as well as checklists and Database Support. Code Generation is yet only partially implemented.
ArgoUML is considered to be fairly easy to use and runs rather smoothly. It is an inexpensive way to get an UML-tool with many useful features implemented.
Source: www.argouml.tigris.org

Figure A. Screen shot, ArgoUML
By
EctoSet
(Release date December 2001for Windows)
The selling arguments for this product are that it is inexpensive and easy to use. There are two product versions, the standard edition (EctoSet Standard) and the professional edition (EctoSet Professional). Both versions contain the capability to produce a range of diagrams (Use Case, Sequence, Activity, Deployment, Class and Component) that can be customised in some aspects. It is possible to draw Finite State Machines and then generate Delphi or Java code. You can also write your own scripts to generate code for any other language, but there is no support for generating diagrams from scripts. The product does not check syntax and has no feature for execution of State Charts.
The program has a component palette that allows the user to select from a range of diagram elements and drop them on to the workspace. The project files in EctoSet Modeller are stored in single project files and uses XML for representation of data. EctoSet Professional also includes scripting capability, which include generating code from diagrams. The product is created for the smaller company in which the user is familiar with UML. The product costs about $60.
Source: www.gajits.com

Figure B. Screen shot EctoSet Modeller.
By
Visual Paradigm
(Release date December 2001for the Java VM Platform)
The product has UML 1.3 support for the following diagram types: Use Case, Class, Sequence, Collaboration, State, Activity, Component and Deployment. The product contains automatic Java code generation, but only for the class diagrams. It also has UML syntax check on the fly for all diagrams (including Finite State Machines), the possibility to define UML-defined and language-specific properties for a class, and textual analysis.
The program has cut/copy/paste facilities for diagram elements to the system clipboard, and as well as HTML and PDF documentation generators. Since the product uses the Java VM Platform, it can be used on almost every computer, provided that the hardware requirements are met. According to our estimations, the product is developed for professional product development (industrial and software engineering).
Source: www.visual-paradigm.com

Figure C.
Screen
shot Visual Paradigm.
By
SmartDraw program
SmartDraw is a Windows based drawing program with the ability to draw UML diagrams. It has “drag-and-drop” futures and built in collections of clipart, images, and symbols. You can save your drawings for the web as a GIF, JPEG or as HTML, and if you want to present your drawing to more people, you post the drawings on the SmartDraw Internet page.
The product is completely adapted to the Microsoft Office Package. It is created for anyone and there is no need to know any UML to use the program. The cost of the program ranges from $69 to $198 depending on the version.
Source: www.smartdraw.com

Figure D. Screen shot, SmartDraw
By
TogetherSoft
(Release date May 2001 for Java VM)
The deluxe version Together ControlCenter and the standard version Together Solo are products for teams building e-business software solutions. Both versions contain an UML-modelling editor, a programming editor, a source-code formatter and reporting features in HTML/RTF/PDF formats, among other things. The deluxe version also has features like custom report designer, DBMS integration, metrics, audits and e-solutions.
The program has automatic update of code when a diagram changes and adaptation of the diagram when the code is changed. It also contains a text editor were you can compile, run and debug your code. Among its users, Together Solo and Together ControlCenter are well liked, because they are considered being products that are easy to use. Unfortunately, they are rather expensive. Together Solo costs $3495 and Together ControlCenter costs $5995, which is quite a considerable sum.
Source: www.togethersoft.com
By
Rational
(Release date November 2000 for Windows 98, Windows 2000, Windows NT 4.0, UNIX, Linux)
Rational Rose is a number of UML-based model-driven development tools, which are a part of a complete software development solution (Rational Rose for UNIX/Linux/Java, Rational Rose RealTime, and Rational Rose for Visual Studio and Microsoft Developers). The product enables modelling of the entire application architecture, which can be transformed into a number of distinct technologies. It also has support for object-relational mapping, schema generation, and for Java development code-model synchronisation among other things.
This is a one of the most advanced development tools on the market and it is a product developed to suit the large companies and their experienced users. The base model, Rose Modeller, costs about $1829 and Rose Professional costs about $2442. If you want the deluxe versions, Rose Enterprise and Rose RealTime, you have to pay $4290 or more depending on the demands on the product.
Source: www.rational.com/products/rose/prodinfo.jsp

Figure E. Screen shot, Rational Rose in Visual Basic.
Since the finished software product is going to be a specific type of drawing tool, there will be extensive implementation of graphics and graphical algorithms. Spline and polyline algorithms may be needed, and therefore a further study on algorithms is necessary to decide on which algorithms will suit this particular project. Some useful algorithms can be found in the books Computer Algorithms, Introduction to Design & Analysis by Sara Baase and Allen Van Gelder and Discrete and Combinatorial Mathematics by Ralph P. Grimaldi. The book Interactive Computer Graphics by Edward Angel will be used to handle potential graphical problems.
There is also help to be found on the Internet. The web page “Journal of Online Mathematics and its Applications” presents a mathematical library with solutions to spline problems, among other things.
The JOMA pages can be found at:
www.joma.org/vol1-1/articles/bogomolny/bogomolny1.html
The theory of Finite State Machines is to be implemented graphically by the program. The OMG UML v.1.3 specification will give us guidelines on the implementation of UML. Frank Hoffman or Karl Meinke (at NADA) are specialised in UML, and can also answer questions on correct implementation of Finite State Machines.
Java will be the programming language for the graphics and the interface. We have not yet decided on which version. JDK 1.2, JDK 1.3, and the recently released JDK 1.4 are the candidates. Java2D is the graphic package that will be used. XML or other file formats will be used for storing the models.
That implementation of the graphical part may use self-developed algorithms for Spline curves, or it may use an existing appropriate freeware Java package, if such a package will be found.
Since the language is Java, there is no need for choosing any specific operating system.
|
Name
|
E-mail |
|
Borg Tage |
tage@kth.se |
|
Gebrehiwet Tsegereda |
md99-tge@nada.kth.se |
|
Johansson Tomas |
tojo@kth.se |
|
Karimian Maria |
su98-mka@nada.kth.se |
|
Nilsson Anders |
md96-ani@nada.kth.se |
|
Olczak Dominika |
md98-dol@nada.kth.se |
|
Oscarsson Carina |
it_is_nina@telia.com |
|
Randahl Åsa |
cayenne@inbox.as |
|
Tchaoucheva Suzan |
md98-stc@nada.kth.se |
|
Wieweg Andreas |
andreas.wieweg@obbit.se |
|
Zhang Johanna |
xz@kth.se zxh@swipnet.se |
|
Leeloo Inc. mail list |
leelooinc@yahoogroups.com |
|
Role
|
Responsible |
Assistants |
|
Project Leader |
Wieweg Andreas |
Karimian Maria |
|
Customer Representative |
Zhang Johanna |
Wieweg Andreas |
|
Chief Programmer |
Borg Tage |
Johansson Tomas |
|
Tester |
Olczak Dominika |
Borg Tage |
|
Programmer / Designer |
Johansson Tomas |
All
of us |
|
Technical Writer |
All of us |
|
|
Documentation Manager |
Nilsson Anders |
|
|
Graphics Expert |
Zhang Johanna |
Tchaoucheva Suzan Randahl Åsa |
|
Web Designer |
Oscarsson Carina |
Olczak Dominika |
|
GUI Expert |
Gebrehiwet Tsegereda |
Tchaoucheva Suzan Oscarsson Carina |