Create models textually. Rather than drawing diagrams, it tends to be faster to create
class diagrams, state machines and other types of models using Umple's textual format that looks
just like programming-language code. Editing, comparing and many other
tasks can often be done faster using this textual form. Umple has tools that
allow you to edit the model textually (and see changes appear in a
diagram) or to edit a diagram (and see changes appear in the textual
code)
Add modeling constructs directly into your programs, when you
are programming in Java, Python, PHP, C++ or Ruby. For example, when programming in
Java, you can directly add a state machine that conforms with UML semantics into your code. This can
save you a lot of coding. The Umple compiler acts as a pre-processor,
first compiling the state machine to Java, and then compiling the Java
into an executable program. Java methods found in the Umple code will be unchanged in the generated output.
The same works for languages like Python and C++, although methods have to be tagged with the relevant language. See the Hello World examples
to see how to do this.
Specify requirements and have AI generate models. Umple allows you to specify requirements in many ways. You can simply refer to existing external requirements, or embed them directly as files in the same repository with your Umple code. Umple allows you to specify requirements as user stories, use cases and other formats. Then you can use artificial intelligence to generate Umple models such as data models (class diagrams) or state models. They key idea is that rather than getting AI to go from requirements to code, you ask it to go from requirements to Umple (with embedded code for certain capabilities), and then have Umple generate the final system. This results in deterministic code that is more consistent as changes are made.
Generate high quality code from models. The Umple
compiler creates code in languages like Java, Python, C++ and PHP that is of top
quality. It is a goal of the Umple team to create the best open-source
code-generation tool available. The generated code never needs to be
edited and never should be edited, since you can always embed native methods (i.e.
Java, Php, etc.) in the Umple, or else use Umple's aspect oriented
capabilities to alter the effects of generated code. As a result the concept of 'round
tripping' is obsolete in Umple. You should treat Umple-generated code just
like you would treat bytecode-or machine code, i.e. as a development
artifact that can be thrown away and recreated. Nevertheless, we have
endeavoured to make the generated code as clean and readable as possible
so you can verify its correctness and learn how it works.
Incrementally Umplify a program. A program in a base
language like Java should pass through the Umple compiler unchanged. As a
result you can incrementally refactor such a program, stripping off
complex code for such things as associations, state machines and certain patterns,
and replacing it by simple Umple code. This can be done bit-by-bit, while
testing thoroughly at each step. When you are done, you will have a
program that should not only be more compact, but also more reliable and
more maintainable. In addition, you have the benefit of being able to view
UML diagrams of your program.
The term "Umple" derives from "UML Programming Language", "Simple"
and "Ample".
The quickest way to get started with Umple is to go to UmpleOnline, and
select an example listed under 'EXAMPLES'. Each of the user manual
pages also allows you to instantly load the examples into UmpleOnline.