Metamill 6.0 Build 1350

Size 3.504 MB   0 seeders     Added 2011-08-16 23:14:09

To download or stream you need BitLord. Visit them at BitLord.com
UML CASE tool with UML 2.3 support and round-trip Java, C, C++, C# and VB.Net



Metamill is a powerful UML modeling software supporting latest standards. Metamill is a powerful software engineering tool with features only much more expensive tools usually have. Metamill offers great software engineering power for very affordable price.With Metamill you can capture business requirements using use case diagrams, design software architecture using package diagrams and design subsystems using class diagrams and object diagrams.For dynamic modeling you can use sequence and collaboration diagrams as well as statechart, activity and timing diagrams. Model component and deployment diagrams for physical implementation. All 13 UML diagrams are supported.You can generate C, C++, Java, C# and VB.Net code from the model using code markers which allow you to preserve your changes. Contents of a method are preserved even if you re-generate the code.You can also synchronize the model using reverse engineering, as well as import external code to the model. Metamill is written in C++ and it is fast. No bytecode, no interpreting, no emulations, just fast pure binary code. Here are some key features of "Metamill":

Use case diagrams:
· A use case diagram describes the behaviors of the system. When designing a use case diagram, remember that it should describe what the system should do, not how it should be done. Use case diagrams can be used for capturing system requirements.

Package diagrams:
· Package diagram is used for designing the software architecture of the system. It consists of organizing the diagrams and elements in manageable groups and declaring their dependencies. A package is a subsystem or a library of classes that are semantically close to each other. A package diagram contains packages and their interfaces and relationships between them.

Class diagrams:
· A class diagram illustrates the static design view of the system. It is one of the most important diagrams used in object oriented modeling. A class diagrams consist of classes and interfaces and relationships between them. The classes in class diagram usually have direct counter parties in implementation language. Of course, you can design classes that are in very high level of abstraction, just explaining their responsibilities. The high level approach is usually used at the beginning of design.

Composite structure diagrams:
· A composite structure diagram illustrates the inner structure of an element, usually a class or a component. In a composite structure diagram there can be ports on the edge of the element to describe "gates" to the inner structure of the element. Within the element itself you can visually explain the inner relationship of parts.

Object diagrams:
· An object diagrams shows a static design view or static process view of a system. It freezes a point of time and shows objects and relationships between them at that moment. Object diagrams can also be used to design static data structures.

Communication diagrams:
· A communication (collaboration) diagram is an interaction diagram that shows the structural organisation of objects and messages between them. Communication diagrams show dynamic aspects of the system. Going and coming messages can be shown on the links. These describe the events sent and received by objects. A dependency from object to a class can be used to show explicit class instantiation. Showing only links between objects without messages you can show static set of objects.

Sequence diagrams:
· A sequence diagram describes the dynamic design view of the system. It consists of objects and time ordered messages between them. Focus of controls are used to describe the period of time during which the object is performing an action. Asynchronous messages can be used to describe events with time constraints.

State machine diagrams:
· With state machine diagram you can model dynamic aspects of the system. For example you can model life-cycles of an object having different states. A state machine diagram consist of states and transitions between them. There are five different types of state: initial state, final state, deep history, shallow history and normal state. Initial state shows the start of life cycle and final state describes the end. History state presents the previous substate in embedded states. All other states are normal states between initial and end states. State transitions describe events that cause an object to go from state to another.

Activity diagrams:
· An activity diagram describes the dynamic aspects of the system. In UML 2.0 activity model was separated from state machines. It consists of activities containing actions and control flows between them. Control nodes can used in describing the flow of execution. With decision node you can specify alternate paths of control flows and with fork and join you can describe parallel flows of execution. Swimlanes can be used to separate independent areas.

Component diagrams:
· A component diagram is used in modeling physical aspects of the system. With component diagrams you can visualize the implementation of component-based system. A component is a physical part of the system that can realize a set of interfaces. A component is easy to replace with another component as long as it implements properly its interfaces. A component can be an executable, a library, a source or data file or any other physical part of the system.

Deployment diagrams:
· A deployment diagram shows the configuration of run time system. It shows the components and the nodes which the components belong to. A node is usually understood as physical system, e.g. processor, which executes the components it owns. Deployment diagrams are useful describing complex distributed systems.

Interaction overview diagrams:
· Interaction Overview diagrams focus on the overview of the flow of control, thus describing high level interaction flows between more complex interactions shown only as icons. These interaction icons are called interaction use – elements. They can be understood as shortcuts to interaction diagrams which describe each interaction in detail.

Timing diagrams:
· Timing diagrams describe changes in a system’s state on linear time axis. State lifelines are useful when illustrating discrete and continuous state changes, such as temperature or density. Value lifeline focus on showing points in time where the system’s state changes.

Profile diagrams:
· Profile diagram is used for explicitly describing how stereotypes extend metaclasses. When a stereotype extends a metaclass the stereotype can be assigned to that metaclass. E.g. metaclass Class can be extended by two stereotypes, and . These both stereotypes will then be available in Class stereotype choice-menu.

Extensibility mechanisms:
· Extensibility mechanisms consists of stereotypes, tagged values and constraints. Using stereotypes you can create new meta-elements by "stereotyping", i.e. giving new roles to existing ones. Tagged values are additional information for elements, e.g. implementation specific guidelines. Textual constraints can be added anywhere in the model to present limitations in the system behavior.

Managed Packages:
· A managed package is an otherwise normal package, but which is stored in its own XMI file. Single packages can be versioned under the version management system. The main model may be write-protected and only the packages under development can be made changeable.

Generate C++ code:
· C++ code can be generated from models. The generated code contains user-blocks which mark areas the designer can make changes that are not overwritten when the code is re-generated. It is good practice to always make changes to UML models and then generate the code.

Generate Java code:
· Java code can be generated from models. The generated code contains user-blocks which mark areas the designer can make changes that are not overwritten when the code is re-generated. It is good practice to always make changes to UML models and then generate the code.

Generate C# code:
· C# code can be generated from models. The generated code contains user-blocks which mark areas the designer can make changes that are not overwritten when the code is re-generated. It is good practice to always make changes to UML models and then generate the code.

Generate C code:
· C code can be generated from models. The generated code contains user-blocks which mark areas the designer can make changes that are not overwritten when the code is re-generated. Each class corresponds one C file and methods become global C - functions.

Generate VB.Net code:
· VB.Net code can be generated from models. The generated code contains user-blocks which mark areas the designer can make changes that are not overwritten when the code is re-generated. It is good practice to always make changes to UML models and then generate the code.

Reverse engineer C++ code:
· C++ code can be reverse engineered from source files. Code can be imported to a Metamill class diagram using reverse engineering. The models created this way can be used in code generation and the generated code can be analyzed i.e. reverse engineered again. This is called round-trip engineering.

Reverse engineer Java code:
· Java code can be reverse engineered from source files. Code can be imported to a Metamill class diagram using reverse engineering. The models created this way can be used in code generation and the generated code can be analyzed i.e. reverse engineered again. This is called round-trip engineering.

Reverse engineer C# code:
· C# code can be reverse engineered from source files. Code can be imported to a Metamill class diagram using reverse engineering. The models created this way can be used in code generation and the generated code can be analyzed i.e. reverse engineered again. This is called round-trip engineering.

Reverse engineer C code:
· C code can be reverse engineered from source files. Code can be imported to a Metamill class diagram using reverse engineering. Code can be generated from these models in C, C++, Java or C#. Reverse engineering C is best used for understanding old legacy code.

Reverse engineer VB.Net code:
· VB.Net code can be reverse engineered from source files. Code can be imported to Metamill model and class diagrams using reverse engineering. VB.Net code generation is also supported.

Reverse engineer sequence diagrams:
· Experimental sequence diagram reverse engineering helps to understand existing code. You can automatically create sequence diagrams for operations. It will consider only objects and operations known to the model, this also avoids unnecessary clutter. Currently supports C++ and Java.

UML 2.3 metamodel system:
· Metamill metamodel system has been partially re-written to support latest standard, UML 2.3. Enhanced metamodel support allows easier and more detailed metaelement management.

XMI 2.1 support:
· Metamill model files are standard XMI 2.1 files. i.e. XML files. This allows access by external XML tools. Metamill also imports and export XMI 1.2 and 1.1. There is also limited import support for older XMI 1.0.

HTML document generation:
· Metamill can generate HTML documentation from the model. This allows other users to easily browse the model. Also plain text generation is possible.

RTF document generation:
· Metamill can generate RTF documentation from the model. Generated document can be opened with Word or OpenOffice word processor and further edited.

MetamillScript scripting language:
· MetamillScript is a simple scripting language that can be used to manipulate metaelements in the model. The core language is implemented and basic access methods for model elements are available. Also recursive subroutines are supported. MetamillScripts are executed from the Metamill GUI.

Export Rose .mdl model files:
· Metamill can export .mdl model files which can be opened by Rose tool. Also diagrams are exported as much as possible.

Import Rose .mdl model files:
· Metamill can import .mdl model files written by Rose tool. Also diagrams are imported as much as possible.

Model templates:
· Model templates can be defined for use when new models are created. Templates may contain any structures that normal model contain. Usually it contains domain specific stereotypes, source language primitive datatypes (void, int, long etc.). Model template may also contain a package structure which is common to many designs.

Miscellaneous features:
· export diagram to metafile or bitmap
· copy/paste to clipboard
· parameterized class (templates)
· notes and note-links
· tabbed dialogs for settings
· multiple source file import
· mouse right click short-cuts
· project tree for easy diagram access
· vertical tool-palette
· multi-page printing
· undo/redo commands
· element type color-settings
· autosize elements
· diagram panning
Limitations:

· 30 days trial
· The number of elements is limited to 20 per diagram What's New in This Release: [ read full changelog ]

· Support for UML 2.3
· All 14 UML diagrams supported
· RTF (Word) document generation
· Java annotations support
· Experimental sequence diagram reverse engineering
· Drag and drop attributes and operations
· Super-fast XMI model file loading
· Improvements in code engineering and GUI
metamill-6.0-build-1350.exe 3.504 MB
Gathering some info...

Register and log in Isohunt and see no captcha anymore!

4000 symbols left
Hash 3BC5A451FDE649E0B10C3DDA44994C169A08411F