- Online help
Goals and Features
There are a lot of powerful modeling tools available. Usually they
are big, editing diagrams is slow and involves lots of mouse clicks,
are not well integrated into your code development environment, so
integration with software development is clumsy. And - a lot of them
are very expensive.
The main idea in developing Slime UML was to create an easy-to-use tool
to document a code structure while or even after developing it. Javadoc
is a great tool to document classes and packages, but it is missing a
tool to visually document relationships between classes, which automatically
maintains integrity between code and document.
Eclipse is a very powerful platform for Software Development. Most available
UML tools are very expensive and integrate poorly into Eclipse. Slime
is different. Here are the development goals for Slime UML:
- integrate smoothly into Eclipse
- lightweight, max. 1MB runtime code
- support for Class Diagrams and Use Case Diagrams
- no separate model; use the Eclipse Java Model
- create diagrams of classes with their important relationships
- powerful layout of inheritance structures
- print diagrams and export them to platform-native format
- automatically update diagram elements if source code changes
- fast editing of diagrams; no modal dialog popup with thousands of
checkboxes, edit fields, buttons
Strengths of Slime UML
Other modeling tools on the market are much more famous and much more
expensive than Slime UML. You might ask yourself, when and why you should
use Slime. Here are some reasons to convince your manager :-)
tight Eclipse Integration: Slime UML was designed
from ground up as an extension to Eclipse/WSAD; it builds on the
platform services whereever possible; therefore it integrates extremely
well into the platform, needs less than 1 MByte download and performs
fast roundtrip: The original goal of Slime was
post-coding documenting existing code; thus you can very easily create
diagrams and they automatically synchronize with changes to your
lightning fast reengineering: You want to use a
complex open source framework, but it's poorly documented ? Just
drag all the packages onto a Slime diagram, trigger autolayout --> voila,
there's a detailed inheritance hierarchy you can browse. Instantly.
Measure the time to analyze your favourite framework, compare and
then decide !
efficient workflow: You're an architect and developer;
you want to express your thoughts as fast as possible without fighting
with a tool. You don't want to spend hours and hours popping up modal
dialogs, clicking on the 'public' checkbox, change tab-page to adjust
stereotype. Slime is made for you !
affordable: You're member of a small company, freelancer,
student, like to document your source code visually. You can't afford
to buy a tool which costs 5000$ up, needing an update every year
at about the same price. Slime UML is still free; version 1.0 will
have native Word export, and you can buy it. Definitely cheap enough
that you can afford it. Promised.
- flexible: You want to add a conceptual relationship
which is not visible in the sourcecode; you want to add an actor to
a class diagram, because your specific modeling needs require it; you're
the boss; Slime will accept whatever you model.
Slime UML is not focused on providing as many features as possible.
It focuses on doing the things it does well.
- class diagrams, actors, use cases
- drag&drop of classes, packages from package view
- diagram overview with navigation function
- all operations work on multiple selections
- highly sophisticated auto-layout for crossing-optimized, multiple-inheritance
- inplace editable notes
- associations: all standard UML associations and adornments
- alignment operations left, right, top, bottom
- double-click: position on method source
- printing (on one page)
- diagram zoom in/out
- synchronous update of diagram if you change java-code in editor
- light-weight (< 500 KB plugin-size), well this is no more true
for 2.0 branch
- support for big diagrams (still fast with 300 classes on a diagram)