The project scenario:
Management, engineers, scientists and users contributes their requirements for a piece of software. They contribute gifs, jpegs, pngs, ms presentation files. They specify the sequence of occurrence.
I want to provide them with a piece of software like the movie scenario and scripting editor. (A movie scenario and scripting editor is a computer aided script writer and scenario presenter in movie production). In my case, I am not producing a movie but documenting and integrating various specifications of software UI sequences.
I need the software to sequence out the UI scenario. A scenario would be comprised by various scenes in specified sequence. A scene is a particular moment of the UI or software state.
I need the software to associate each scene to one or more files (gif/jpg/png/presentation). So that when we present it to mgmt, users, customers, we could progress through the scenario with each scene illustrated by those files.
I need the software to be able to compose sub-scenarios as a standalone project. So that each user could compose his/her own contribution to the project. Then the software should be able to specify project dependency to integrate the scenarios into one big kahuna.
Ideally, the software would generate UML sequences and empty classes.
I think, the gaming software industry might be using something of this nature.
Could anyone please suggest and discuss various software available for the purpose I have described?
Unfortunately, I don't know about any software that does what you describe - but it sounds interesting as an idea - especially with use case modeling...
If I would try to write such a tool, I would probably look at Xtext to create a DSL with editor for those scenario scripts you describe and add some code generation using the Abstract User Interface metamodel from topcased.org (curiously currently down...) modeled after UsiXML.
Good luck!
I will not be able to discuss, but I could suggest something that I think is similar. Mindomo?
Related
I'm trying to create a UML diagram from the command line without preexisting code.
Eventually I'll write code in C++/Java, but I need to create a diagram first.
I'm thinking of a header-like file, which could be read and could generate a diagram.
Of course, I could just create a header and generate it. However, I'm not supposed to write any code until I've submitted my diagram (I'd also just like to have an efficient way to do this for the future).
UML does not require application to draw. On the contrary one of the main usages of UML is to model the application that you're going to build to understand it better and make a better code as a result.
You also don't use application you create to draw UML diagram. You can use any application that supports UML modelling. Simple Google search or visit on Wikipedia will give you tons of options. You may even take a sheet of paper and a pencil. I've seen a course of UML, where participants did not use computers. They were supposed to learn UML, not tools that allow to draw it.
Finally (answering the question stated in the question topic), UML is in no way limited to model only graphical applications. Static structure and dynamic behaviour of the system exists regardless if user communicates with it through a GUI or command line.
Are you sure you understood the reason why you are supposed to make a UML diagram or do you disagree with that reason? What I can definitely suggest is to find a good book about IT business analysis using UML. This site is not to recommend specific books, but again Google will be your friend here.
As according to the comment the goal is to actually generate a UML class diagram from text let me add a second part of answer
First disclaimer. In general SO is not a place to ask for tools and that question is brushing it. Let me make my answer more generic though.
UML is in general graphical language so technically what you need is something that will parse text version of your "diagram" into a nice picture.
Most if not all tools keep UML in some textual format, be it XMI or some internal legacy solution. The problem with that is that the format is usually pretty complex.
There are some tools that are intended to "draw" diagram by typing text and that's probably something that would suit you best. In general I definitely prefer "normal" GUI but if you insist yuml.me has a nice and easy to understand textual layer based on which it generates really cool diagrams. You may expect you will find others as well, so as usually, ask uncle Google. As suggested by Thomas Kilian in a comment, PlantUML is another example as it can work without GUI and "is an open-source tool allowing users to create UML diagrams from a plain text language." (quote after Wikipedia)
My objective is to have traceability between requirement, design, test case and test results of a project. Can any one give me the details of such an ALM tool . It should be an open source tool.
There are many tools for this. The first Question as always is: which programming language is this for? How big is the Team (including the specialist division which use these tools => requirements)?
Suggesting JAVA is the language, I'd prefer these tools:
Requirements: JIRA (not free but best!), Mantis or Bugzilla also may do an acceptable job
Design: depending on which design? To use UML a good choice had been TogetherJ (RIP => now part of Borland's toolbox); you may try ArgoUML or WhiteStarUML; using a Wiki I'd suggest e.g. DokuWiki and a good Office System is also a choice - depending on the needs within your team! (Yes a design always includes text)
test case: I'd like to split this topic a bit to “test planning” and “test execution” an last but not least “test documentation”
test planning : give TestLink a research
test execution: (free of charge!) Jubula, JUnit, Selenium => depending on your needs
test documentation: you should use a standard Editor like Word or Writer etc. (not the Wiki)
Additional perspectives:
build server: I've missed the build server within your list: if you code a piece of software how do you certain the software can be build also if a machine or a person refuse to work (on any reasons)? Building a software on the developer’s machine includes exactly the risc that the SW may not be buildable of another machine/by another person. So use a build server (where jenkins/hudson should be on your short list)
repository: according to the topic on saving the sourcecode within a CVS you probably also ensure to have an access to all the used external libraries you need within your program. Try artifactory or nexus
clearing process: If you work within a company’s team where the company’s strategy is actually to test a software before publishing the software you you’d think of a clearing process according to the test results. You should think about the group of people who should be involved within the clearing process of the software. Get them as partner into your project – otherwise it’ll be hard!
I hope the answer was helpful and fits to your needs?!
ALM is a huge topic and here we're discussing just a part of SDLC which is ONE topic in ALM.
I don't have a programming job. But I do code (using functional programming and OOP) from time to time, in order to make many repetitive tasks, that I perform in the software I use, simple: extract data from a simulation and dump it into an excel file, read data from an excel file and use that data to manipulate my simulation, etc.
I can manage this pretty well without using UML. But what I want to know is: for someone who doesn't code for a living, yet uses code to make life simpler and save time, how important is using UML (I do understand that I cannot use it for functional programming)? What are the practical benefits? How can I write better code by using UML? I know it's not a substitute for a programming language .. as in I cannot use it as a programming language. But what I was also hoping to understand was how can I use it before I actually begin to write OOP code?
Unlike other answers suggest I believe that UML is not only beneficial when you work with a team of developers, also when you work on a project on your own you can benefit by using UML.
In my opinion the true benefit of UML is that you are forced to think before you act. Of course you can always directly start programming when starting a new project, but (most certainly for larger projects) it is better to think about your design.
By creating complete UML models you will notice that you need to think about your software (what does the user needs to be able to do with my software? How will the software react? etc. etc.). Due to this whole process I believe that by the time you will start coding, you will already have such good understanding on the structure of your program that you will be able to code your project better and faster.
Concluding I think UML is all about doing it right the first time.
Next to this, you will always have proper documentation on your code. This makes it more easy to maintain.
Not very sure what you mean by day to day life but UML helps in:
The communication of the desired structure and behaviour of a system between analysts, architects, developers, stakeholders and
users.
The visualisation and control of system architecture.
Promote a deeper understanding of the system, exposing opportunities for simplification and re-use.
Manage risk.
When working in a team, you first create a UML. That way you know which classes have to be made and you can divide the working, knowing everyone will use the names on the UML with the right connections between classes. (Inheritance, composition,..)
It's an abstract version of a program and it's very important. Ofcourse, if you're on your own you don't 'need' to use it, but it might make life easier. If the task takes long, create the UML beforehand so you don't loose track of what you're doing plus it helps you see design patterns. :)
In addition to the other mentioned use cases of UML models, the most efficient use case for a UML model is when it is used to generate other models or text (code).
For instance you can generate java classes from a UML class diagram.
Search for MDA (Model Driven Architecture) or MDSD (Model Driven Software Design).
If you are looking for a tool to support generating code/text from UML models then take a look at the Acceleo Project.
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.
I am using UML to document parts of an older c++ program. It's only a portion of the code, but documenting it has made me insane since even this process is quite large. So far I have used class diagrams for the relevant code and some activity and sequence where necessary.
My question is I feel what I have done so far is good for the overall documentation but I want to get down to the dirty details of a few methods and one of them is 202 lines long, what should I use for this? An activity diagram or sequence?
I am using Visio for the UML documentation.
Thanks.
A rule of thumb might be that if it seems like there are multiple agents handing off flow between each other, use sequence; otherwise, activity. In a single function, activity is probably best - but not necessarily.
Try to imagine what it's going to end up looking like, put yourself in your ignorant reader's shoes, and think about which will tell the story better.
Is splitting up the function an option?
The question is: Do you want to describe the process or the interactions between objects that those few methods are executing? The process can be broken down into activities which are performed, their composition and data flow. Interactions are comprised of messages sent between objects.
Well,
Short answer is:
If you want to document an algorithm (that is used by one of your system object^s method): Use Activity diagrams.
Long Answer:
For my experience UML documentations are the worst ones.
People generally use Uml Tools which automaticly reverse engineer code to Uml (generally class diagrams, and sometimes sequence diagrams) and diagrams that are automatically generated are generally has many details and sometimes nonsense.
As an advice "Comments your code properly" and use tools like Doxygen. They are better for Code Documentation.
But you can use UML for Software Architect Document.[SAD]. Craig Larman has nice section and example of it at his books about Documenting Architecture
Motivation: Why Create a SAD?
When someone joins the development team, it's useful if the project coach can say, "Welcome to the NextGen project! Please go to the project website and read the ten page SAD in order to get an introduction to the big ideas." And later, during a subsequent release, when new people work on the system, a SAD can be a learning aid to speed their comprehension.
Therefore, it should be written with
this audience and goal in mind: What
do I need to say (and draw in the UML)
that will quickly help someone
understand the major ideas in this
system? [ Applying UML and Patterns Third Edition By Craig Larman ] [Chapter 39. Documenting Architecture: UML & the N+1 View Model]