Free uml in a nutshell software for linux

UMLMON is a complete run time environment for User Mode Linux. There is a separate monitor daemon for every VM.
UMLMON project creates the run time environment and starts the VM by executing the UML kernel. The daemon also determines the arguments that are passed to the UML kernel, and includes special support to set up arguments for memory size, virtual disks, virtual network interfaces, and console channels in a convenient way.
UMLMON also includes routines to do certain administration tasks like the creation of disks.
The team UMLMON + UML can be applied in the following areas:
- Server consolidation: Improve the utilization of server hardware, and ease the operation of servers.
- Virtual security zones: Instead of building demilitarized zones (DMZ) with real hardware, it is a cost-effective alternative to set up purely virtual DMZs on a single host.
- Virtual hosting: A cheap version of server hosting is virtual hosting; instead of leasing real computers to customers, virtual machines are used.
- Laboratory nets: By using virtual machines it is possible to build cheap laboratory nets, e.g. to test software in real network environments.
- Training environments: One can use virtual machines for Linux trainings where participants can get true administrators priviledges without any risks.
Enhancements:
- This release no longer call the problematic glibc function getgrouplist, which is often broken (symptom: segmentation fault immediately after starting umlmon).

UMLSpeed project is a compiler for a simple, C-style language that allows declaration of UML entities and diagrams. Diagrams can be compiled into SVG and the entities to XMI for use with other tools.
Why?
- Graphical UML tools in general suck - why should we, as programmers have to drag and drop stupid graphical things and use a mouse when we could express what we want 10 times faster with a text editor and a simple notation? - More importantly, why should we have to lay everything out when the computer could do it for us?
- Graphical UML tools are bloated, huge, memory and disk-hogging monsters.
- Graphical UML tools use either a binary data format or XML, which is not particularly friendly to source code control systems.
Main features:
- Written in GCJ-portable java and compiled natively. Its extremely fast even when dealing with thousands of entities and diagrams.
- Purely command-line driven and takes miniscule resources.
- Flexible enough with file imports that large UML projects can be broken up into separate files and only individual bits built at a time as required.
- C-style syntax means that the source language integrates well with source code control and diff tools.
- Standards compliant - produces interoperable SVG and XMI, as well as clean source code.
- Can integrate with automated build tools for regular diagram/xmi compilation.
Status
This is still alpha software. Dont hold me responsible if it kills your pets and blows your house up.
Implemented so far:
- Compiler/parser
- Namespaces, Class diagrams and related entities
- Use case diagrams and related entities
- Auto-link pathfinding
- XMI 1.3 output
- VIM syntax highlighting
- Code generation (Java and Python)
Still to do:
- Documentation output
- Code generation (Ruby, PHP, Perl, C++, C#)
- Diagram packages
- Diagram notes
- Alternative diagram layout managers
- Deployment diagrams
- Sequence diagrams
- Activity diagrams
Enhancements:
- Added facilities to store HTML of reports in a buffer for use by plugins and turn off file generation. Maven plugin now uses this when using Doxia for generation.
- Added $PROJECTNAME and $PROJECTVERSION HTML tokens, with CLI parameters to set them. Maven plugin will automatically set them.
- Added $PUBLISHDATE token
- Added $TOC key for generating links to bookmarks on the same page.

Umbrello UML Modeller is a Unified Modelling Language diagram programme for KDE.
Umbrello UML Modeller allows you to create diagrams of software and other systems in a standard format.
Our handbook gives a good introduction to Umbrello and UML modelling.
Enhancements:
- Bugs/wishes from http://bugs.kde.org:
- Preprocessor keywords ignored which causes endless loop in code import (119125)
- Code generator for D language (124805)
- Unstable saves and loads, class names become dirty (145709)
- Crash on deleting class in list view (145762)
- Class attribute documentation not generated for python (145916)
- Python code generator does not wrap lines properly (145918)
- Attribute documentation not generated for Export to XHTML (145972)
- Crash when moving a class in a Java UML diagram (146058)
- Arrowheads are not shown (146064)
- Crash when creating a class that refers to more than one other classes/datatypes (146367)

UMLet project is an open-source Java tool for rapidly drawing UML diagrams with a pop-up-free, light-weight user interface.
UMLet lets you draw diagram sketches fast; export diagrams to eps, pdf, jpg, svg, and sys.
Add elements to a diagram with a double click. Edit elements using the lower-right text panel. Select multiple elements using Ctrl or lasso. Press C to copy diagram to the system clipboard
Main features:
- fast
- text-based sequence diagram
- call from command line.

SMUSHcode project is a functional (as opposed to procedural) scripting language interpreter, written in Java. Completely documentated.

SMUSHcode started life in 1997 as a term project for a "Compilers and Translators" class. Originally written in C++, it was conceived as a functional (as opposed to procedural) scripting language. After the class was over, it was reimplemented in Java as a good way to learn a new language. It exists now as a solution without a problem -- it works great and is very extendable, it just isnt currently needed for anything.

Currently, the examples and the EBNF are a new SMUSHcode programmers only way to learn the language. The API documentation is amazingly thorough (a good way to learn javadoc, no?) but for some reason refers to the language as "SMUSHcode75". The reasons for the "75" are long lost in the misty past...

SMUSHcode is a functional scripting language that any LISP or Scheme hacker would have no problem picking up quickly (whether they would want to is a different issue). Most newer and/or self-taught programmers are not familiar with the idea of a functional language, so in a nutshell it is this: Everything is a function. Every function returns a value. Functional languages do not encourage the concept of "Do A. Do B unrelated to A. Do C unrelated to A or B." (that is procedural programming). Functional programming instead follows the model of "Do A, then use As result to do B, then use Bs result to do C.".

To give a better example, a procedural language might evaluate the Pythagorian theorem thus:

a_squared := a * a;
b_squared := b * b;
c_squared := a_squared + b_squared;
c := square_root(c_squared);
A functional language would evaluate it thus:
c := square_root((a * a) + (b * b));

Curiously, the author had never studied functional programming and only learned Scheme one semester after designing SMUSHcode. It seemed oddly familiar...

This projects GNUmakefile is also interesting; it was written before the Ant project was available. Using GNU make, it dynamically explores a package structure, rebuilds class files as necessary, runs javadoc and creates JAR files. It is documented and easy to customize.

libping is a C library designed to allow a programmer to make ICMP_ECHO requests directly from a script or program. libpings functions return either boolean--is alive--or the round trip time in milliseconds.

The library also includes support for "pinging" the following tcp/ip services: echo, http, https, smtp and pop3. Versions 1.15 and better are threadsafe.

Installation:

In a nutshell, to install the application in the default directory, ( /usr/local ), run the following commands:

$ ./configure
$ make
$ make install

This will install the application ( ring ) in the default directory /usr/local/bin. If that directory is in your PATH, then to run ring and view the online help type:

$ ring --help

It will also install libping in /usr/local/lib and place the header file ping.h in /usr/local/include.

To learn more about ring, make sure /usr/local/man is in your MANPATH and type:

$ man ring

For information about the C library functions, type:

$ man pinghost

For more details, read on. Especially if you want to install libping in a directory other that /usr/local

uml2svg is an XSLT-based tool for converting XMI-compliant UML Diagrams into SVG.
We started the developing uml2svg with six main goals in mind:
- Standard conformance
- Good Documentation
- Modularity
- Extensibility
- Comprehensible SVG
- Multiple diagrams per XMI-file
SVG is a standard language for describing two-dimensional vector graphics in XML. As the open SVG standard gains in popularity and gradually replaces proprietary formats for vectorial graphics, the support provided by the Web browsers is getting better.
Plugins to display SVG exist for most browsers and it is most likely that the next generation of Web browser will provide built-in support for SVG. When that happens there will be no better way to distribute vector graphics on the web. Furthermore, not only web browsers can process SVG in a meaningful way; in fact that is just the tip of the iceberg. SVG can be easily read in, processed, and then transformed into many other formats, being well suited for both text and graphic tools as well as for web agents and screen readers.
UML diagrams are composed of lines, polygons, ellipses and text labels, so they are inherently vectorial. However, the SVG is not very well suited for direct use by UML tools. While some of them can in fact export UML diagrams directly to SVG, they do that by discarding all the information about structure, and converting everything into a shape. Moreover, some tools use the screen-capture function provided by their environment (such as java2d) and then they apply a filter to generate SVG out of the "screenshot".
What comes out of that is a pile of meaningless information, which by accident happens to draw a gorgeous diagram. How will a screen reader interpret such a file? How will a web crawler be able to index it? How will a web agent process it in a meaningful way? A program needs the semantic information that the humans can extract just by looking at a picture. For a machine, an obfuscated SVG file is not easier to process than a PNG file or any other image.
Although for humans it is better to be able to scale the image, for a program this is irrelevant. Programs need a way to "understand" the semantics of the UML models to be able to process and interchange them in a meaningfull way. This was the main idea behind the XML Metadata Interchange (XMI), an OMG specification for model interchange. And probably the best use that XMI has found so far is the exchange of UML models between different modeling tools. And while the XMI provides a standard way for tools to represent models as XML documents, it is still limited to the model elements only.
With the introduction of the UML 2.0 Diagram Interchange Specification as part of the upcoming UML 2.0 standard, it will become possible for tools to exchange the models together with the layout of the diagrams. We think that, once this specification appears, XMI will be used averywhere. Not only will the tools be able to exchange diagrams, but could even represent them internaly as DOM trees. Have you ever considered drawing your UML diagrams online, using only a web browser? This could be done even now by using a custom SVG syntax for the DOM tree, but a solution based on XMI could do even better and be a standard at the same time.
Therefore, we believe that with the advent of UML 2.0 and the increase in the use of SVG, the need for transformations between XMI and SVG will be great. Nevertheless when the uml2svg project was started, there was hardly any good open-source solution to convert XMI diagams into SVG.
The UML 2.0 Diagram Interchange Adopted Specification in its current incipient form references a set of XSL transformations. Although the standard draft covers them to a large extent, the link is actually broken (you can try for yourself). It has been broken for more than a year and most likely it will stay like that forever.
The personal webpage of Professor Mario Jeckle provides an online transformation service capable of dynamically generating SVG from XMI-compliant XML files. The XSL files accomplishing the transformations are also available on that website. These transformations are monolithic and not well documented (the only documentation is in the code, and it is generally written in German). With the tragic accident that took the life of Professor Jeckle, the transformations have no longer been maintained.
Finally, the STZ-IDA research center in Karlsruhe had to convert UML diagrams to SVG, as part of one of their projects. The XSLT stylesheet they created for this purpose was named xmi2svg and is available under the terms of the MIT license. At the time we started work on uml2svg the only type of diagrams supported was class diagrams.
Recently the package reached version 0.2 and it supports more diagram types, without major changes in the code (the opposite of what we were expecting). Andreas Junghans, the author of xmi2svg, provided us with a lot of insightful hints which helped us eliminate many glitches in uml2svg. It looks that the development of uml2svg and xmi2svg will continue in parallel, at least for a while. The good thing about this is that the two (quite different) implementations prove each others validity and the features tend to propagate freely from one side to the other. However, this comes with the prize of having to maintain two different code-trees and possibly confusing some users.
We did not like the two existing solutions because they were:
incomplete - just prototypes, not well suited for production environment
monolithic - hard to maintain and extend
not documented - hard to understand
At first sight, we thought we could find a way to improve one of the existing solutions and just add the features we needed. However, we slowly came to the conclusion that it would be better if we started anew. There are things one can fix in a project, but that does not include what we thought is was bad design. The fact that the two implementations presented above are open source helped us get quickly on the way with our own project.
Enhancements:
- Two annoying bugs were fixed.
- The site and documentation were updated.