Home ›

UML Parsing Analysis

Sponsors are sought for the online UML and SysML specification Parsing Analysis projects

[book] Submitted by webel on Thu, 08/07/2010 - 14:27
in

Sponsors are sought by Webel IT Australia for continuation of these educational, online projects:

Potential sponsors include:

Please contact Dr Darren by phone +61 (2) 9386 0090 or email to discuss possible sponsorship arrangements, to help bring these powerful hyperlinked online resources to the UML and SysML communities.

NEW: UML Parsing Analysis demo based on the recently released UML2.3 and SysML1.2 specifications

[blog] Submitted by webel on Thu, 24/06/2010 - 11:32
in

Dr Darren is delighted to announce a super new online resource, a sentence-by-sentence UML™ Parsing Analysis of (some of) the latest Unified Modeling Language™ (UML™) and Systems Modeling Language (SysML) specifications from the Object Management Group™ (OMG™). Drupal™ CMS technology is used to represent the metaclasses and stereotypes and related documentation in massively hyperlinked and richly cross-referenced form:

Every sentence of these crucial, complex specs could have its own web page with illustrative, educational diagrams and its own analysis comment trail, linked where applicable to OMG issue tracking. It's a vision to behold for UML™ and SysML fans, brought to you by Webel.

Visit also this new incubating tutorial trail: Tutorial: SysML study case: examination of SysML structure, sysml properties, value type, and value state using coloured props

8 Blocks

[book] Submitted by webel on Sun, 20/06/2010 - 01:08
in
This content area is UNDER CONSTRUCTION or MIGRATION
Related packages (backlinks)
SysML Blocks

SysML1.2 specification overview using hyperlinked SysML Parsing Analysis

[book] Submitted by webel on Sun, 20/06/2010 - 00:54
in
This content area is UNDER CONSTRUCTION or MIGRATION

This Webel reference and tutorial zone employs the UML™ Parsing Analysis recipe developed by Dr Darren Kelly, which technique exploits graphical and logical «wrapper» Components to relate text "snippets" from technical documents - in this case the OMG's SysML1.2 specification (with change bars) - to UML™, and in this case SysML, elements.

Please note that the SysML specification does not include the UML Component; the use of «wrapper» Components (which is supported in some tools, such as the SysML Plugin for MagicDraw™ UML) therefore goes beyond official SysML.

The (still incomplete) online trail is structured precisely after the SysML1.2 specification.

All SysML specification text appearing in this online reference trail is quoted, with permission, for educational and conformance analysis purposes only, and to permit convenient web page referencing under Dr Darren Kelly's UML™ Parsing Analysis recipe, and such quoted text remains © Copyright Object Management Group™ (OMG™).

Webel IT Australia maintains © Copyright in all additional UML™ Parsing Analysis models and diagrams of quoted specification text.

Good places to start include:

- Packages (SysML)

- 8.3.2.2 Block

Taxonomy Access Control

[book] Submitted by webel on Sat, 10/04/2010 - 04:28
in
This content area is UNDER CONSTRUCTION or MIGRATION

Snippet-driven engineering: a meta-process for documentation-driven software and systems engineering

[source] Submitted by webel on Sat, 10/04/2010 - 02:21
in
This content area is UNDER CONSTRUCTION or MIGRATION
Source URL (as named hyperlink)
Snippet-driven engineering [in this case an internal link]
Copyright in parsed text, figures, diagrams, and other quoted media held by
Webel Scientific IT Consultancy

The term "snippet-driven engineering" was coined by Dr Darren Kelly of Webel to describe a particular recipe and process for strongly document-driven software and systems engineering, a strategy that is designed to integrate well with a modern Content Management System (CMS) like Drupal™ (if you consider that modern), and with Dr Darren's UML™ Parsing Analysis recipe.

The idea behind Snippet-Driven Engineering is very easy to describe, yet the consequences (just as for disciplined requirements-driven engineering) are ground-breaking and of wide-ranging consequence to every engineering discipline, because it can be applied to any engineering documentation in nearly any form. It is a value-adding meta-process.

The main elements and principles of Snippet-Driven Engineering are stated as child Snippets of this very introduction page, which acts as a Source for each demonstration Snippet, and you'll notice on each Snippet's focus web page that it knows its Source. The Snippets that describe Snippet-Driven Engineering are stated as hyperlinks to each Snippet's focus page of course, and they include:

- Every Snippet gets a dedicated analysis "focus" page in a CMS, and can appear as a "titled" link to its unique focus page

- The title of a Snippet's focus web page is typically a sentence

- Every Parsing Snippet is a consumer of text for a source document known by URL, URI, ISBN, or by another unique source identifier.

- Each Snippet may be represented in a graphical language such as UML or SysML

- Where possible, the title of a Snippet should be digitally transferred from the source Document, not typed.

- A source document may be reconstructed (at least in part) as the union of all downstream Snippets that have it as source

- A Snippet may carry standardised editorial flags, error and warning flags, and ratings

- Wherever and whenever possible, a Snippet should be bound to an executable or functioning expression of the represented text in the real-world

Q: Isn't this just text-based requirements-driven engineering ?

A: No, it is far more than text-based requirements engineering, especially when combined with graphical Unified Modeling Language™ (UML™) or Systems Modeling Language (SysML) models of each Snippet.

A requirement stated as text may be a Snippet, and thus some popular forms of text-requirements-driven engineering are achieved as a mere side-effect of the Snippet-based UML™ Parsing Analysis and Snippet-Driven Engineering meta-processes, which are ways of organising UML™ and Content Management System (CMS) page representations of Snippets of document text to create massively hyperlinked and massively cross-referenced text resources.

Requirements documents are of course excellent candidates for Snippet-Driven Engineering and for UML™ Parsing Analysis, and nearly all good principles of disciplined requirements engineering apply also to Snippet-Driven Engineering. Snippet-Driven Engineering can be combined easily with most popular modern requirements tools (by managing requirements as bound URL targets with matching snippets).

Snippet-Driven Engineering is however far more powerful and far-reaching and all-encompassing than requirements engineering, especially when combined with graphical parsing anaysis engineering such as the UML™ Parsing Analysis recipe. Because Snippet-Driven Engineering and UML™ Parsing Analysis are about meta-processing of and value-adding for any useful documents, (not just those that are already stated in a special form like requirements documents).

Above all, Snippet-Driven Engineering is conceived to work with any document, written in your natural language, not just with documents already in a very specific form.

DrUML: UML parsing analysis of the Drupal.org contributed modules documentation

[book] Submitted by webel on Sat, 10/04/2010 - 02:06
in
This content area is UNDER CONSTRUCTION or MIGRATION

This Webel zone demonstrates the UML™ Parsing Analysis technique and Snippet-Driven Engineering applied to selected contributed Drupal™ module documentation from Drupal.org. For more information please visit the DrUML introduction.

DrUML: UML parsing analysis of the Drupal.org core documentation

[book] Submitted by webel on Sat, 10/04/2010 - 02:05
in
This content area is UNDER CONSTRUCTION or MIGRATION

This Webel zone demonstrates the UML™ Parsing Analysis technique and Snippet-Driven Engineering applied to the Drupal™ core module documentation from Drupal.org. For more information please visit the DrUML introduction.

[ANNOUNCEMENT]: the JUML project: a Java mapping of Drupal under UML Parsing Analysis of Drupal.org

[book] Submitted by webel on Wed, 07/04/2010 - 10:40
in

The prevailing lack in PHP-based Drupal™ CMS of the following technologies (largely perpetuated into Drupal7) drives me (even more) crazy, and it wastes my time:

  • substantial object-orientation
  • flexible method-based hook encapsulation
  • custom type field and user interface inheritance
  • use of GoF and other well known design patterns
  • support for graphical software engineering technologies

If you are an advanced Drupal user with discerning clients, I can assure you that it is wasting your time and money too (even though the software is "free"), and there are much better, well known, well tested ways that have not yet been embraced by the Drupal.org community.

I want to help fix it, and I clearly think that Drupal™ CMS does need a lot of fixing. I (Dr Darren) am a person who can do that, because I am the developer and promoter of the incredibly powerful «wrapper» Component-based UML™ Parsing Analysis analysis recipe, and also develop a powerful recipe I call "snippet-driven" software and systems engineering, a meta-process for document-driven engineering, and because of my current deep involvement with Drupal™, which runs many sites for me and my clients.

As far as I can tell, not one other Drupal user is using such powerful software engineering technologies in combination with their Drupal coding and documentation, and the DrUML and JUML projects are conceived not only to help me, they are conceived to teach you, and to act as as clear examples of what is possible with advanced software engineering process and strategies. I am an evangelist for technologies not yet embraced by Drupal, and I would be delighted to convert at least some Drupal users and developers. I do think Drupal.org needs some salvation.

If I am going to stay with Drupal™ CMS technology, I am going to have to either help reengineer it (which I hope the DrUML project will help achieve for Drupal8), or, perhaps foolishly, I will have to consider forking completely away (given sufficient support and interest from others) to a new Drupal-friendly Java project, which I've decided to call:

JUML: The Java+UML Content Management System

Pronounced 'joo-em-el', with intonation like 'U-M-L', the name is chosen to also sound a bit like both Drupal and Joomla, although in fact all the document mappings are to be from Drupal.org (only).

The JUML project represents a forked design layer for the DrUML analysis project, i.e., once the analysis layer is sufficiently evolved, executable Java components can be generated from them (against my own Webel Java frameworks, and against the Eclipse Modeling Framework (EMF)).

For now, JUML should remain merely an educational example of snippet-based UML™ Parsing Analysis, however by design, it will be able to interact with Drupal sites (and will provide a Swing or SWT interface to them, too). It is not intended (yet) to completely replace or fork from Drupal, and a fundamental requirement is that it should always (!!!) be able to interact with prevailing Drupal sites (at least with my own).

By contrast, the DrUML analysis project is very ambitious, and I want it to cover large portions of crucial Drupal elements.

Moving to some other open source Java CMS projects is not the answer for me, not least because I run so many Drupal sites, but also because the Drupal community is so strong, and there are things about what I can do with Drupal and some contributed modules that I like (and appreciate). I want to amplify the power of that community.

To do this I need snippet-driven engineering and UML™ Parsing Analysis (which manage the mapping from Drupal docs), and I need Java™, because although I can do some reverse engineering of PHP into UML, it requires too much babysitting because PHP is untyped (although, as I've often pointed out, it would be nice if PHP would at least support type-hint annotations, which could be reverse engineered to graphical UML™, it's easy enough to do).

Best of all: JUML is conceived to be able to write PHP against Drupal module APIs, because (my) Java can write PHP ! The graphical UML-based engineering can then be done on the Java components, and when needed, they can write themselves as Drupal friendly PHP (only enough to interact with selected Drupal modules).

Syndicate content
[book] Submitted by webel on Tue, 16/12/2008 - 14:54
Unified Modeling Language
OMG Systems Modeling Language
Java Get Powered
PHP
Powered by MySQL
Powered by Drupal
Lunarpages.com Web Hosting