File and Code Generation in ThinkComposer version 1.3

A new version of ThinkComposer (1.3) is available! It can generate text files, either for code generation or custom information export, based on templates using the Liquid markup language. So, the precise knowledge stored in Composition documents can be consumed from external sources. Lets take a look.

Suppose you want to export the information content of the next Composition diagram…


…and your desired generated file, for the ‘Compute Result’ Concept, would look like:

Global-Id: 7b104a91-b464-484a-9419-9d37ee578b9c
Name: Compute Result
Summary: Use the entered Code to calculate the proper result.
 [1] 'Correct' (Correct state.)
 [2] 'Star Gold' (Star Gold award.)
 Descriptor: 'Approved' -- Full compliance with our test cases!
 [1] 'Flow (Idea 10)' FROM 'Is Valid?'('Yes'); .
 [1] 'Flow (Idea 11)' TO 'Show Result'; .

Then, to achieve that formatted result file, you can use the Output-Template editor (accessed thru ‘Domain’ -> ‘Edit Domain’-> ‘Output-Templates’ -> ‘Concept base templates…’) as shown in the next screenshot:


The complete sample output-template is:

%%:FileName={{ TechName }}.txt

Global-Id: {{ GlobalId }}
Name: {{ Name }}
Summary: {{ Summary }}

{%- if Markings.Size > 0 -%}
MARKINGS [{{ Markings.Size }}]:
{%- for Mark in Markings -%}
[{{ forloop.index }}] '{{ Mark.Definitor.Name }}' ({{ Mark.Definitor.Summary }})
{%- if Mark.Descriptor != null -%}
Descriptor: '{{ Mark.Descriptor.Name }}' -- {{ Mark.Descriptor.Summary }}
{%- endif -%}
{%- endfor -%}

{%- endif -%}
{%- if IncomingLinks.Any -%}
INPUTS [{{ IncomingLinks.Size }}]:
{%- for Link in IncomingLinks -%}
[{{ forloop.index }}] '{{ Link.OwnerRelationship.Name }}'{% unless Link.Descriptor == null %}('{{ Link.Descriptor.Name }}'){% endunless -%}
 FROM {% for OriginLink in Link.OwnerRelationship.OriginLinks -%} '{{ OriginLink.AssociatedIdea.Name }}'{% unless OriginLink.Descriptor == null %}('{{ OriginLink.Descriptor.Name }}'){% endunless -%}; {% endfor -%}.
{%- endfor -%}
{%- endif -%}

{%- if OutgoingLinks.Any -%}
OUTPUTS [{{ OutgoingLinks.Size }}]:
{%- for Link in OutgoingLinks -%}
[{{ forloop.index }}] '{{ Link.OwnerRelationship.Name }}'{% unless Link.Descriptor == null %}('{{ Link.Descriptor.Name }}'){% endunless -%}
 TO {% for TargetLink in Link.OwnerRelationship.TargetLinks -%} '{{ TargetLink.AssociatedIdea.Name }}'{% unless TargetLink.Descriptor == null %}('{{ TargetLink.Descriptor.Name }}'){% endunless -%}; {% endfor -%}.
{%- endfor -%}

{%- endif -%}

Output-Templates can be defined, at the Domain level, for:

– Composition: To create a file for the root of the Composition.

– Concepts: Use one template to generate files with the same format from all Concepts.

– Relationships: Same as the prior, but for Relationships.

Plus, the Output-Template can be declared individually per each Idea (Concept or Relationship) Definition, in case you have specialized or more complex ones.

These Output-Templates are stored in the Domain, so you can reuse them in other Compositions.

To generate the files, just select the “Tools” tab and click the “Generate Files…” button. The next window will be shown:


The description of the Output-Templates language and the ThinkComposer Information model can be found in the manual.

ThinkComposer 1.2 published

I’m pleased to announce the release of ThinkComposer 1.2., which includes the next improvements:

  • Diagram views and Reports are exportable in PDF format.
  • Reports can be generated as HTML
    • Diagram symbols can be clicked to access the respective Idea page.
    • Uses subdirectories to include nested diagrams (easy to copy/publish on your website)
  • Reports are enhanced with the inclusion of deeper information about:
    • Idea Details (attachments content, links address and tables data)
    • Relationship Links (origins, targets and their companions/siblings)
  • Simplified declaration of Table-Structures for Tables and Custom-Fields.
  • Predefined graphic styles for easy apply.

Also, the next Domains has been added for your use and extension:


Use Case diagrams

Class diagrams

Sequence diagrams

Plus lots of other improvements and fixes!

Only for very Early Adopters: ThinkComposer public Beta launched.

Finally! I deployed the website for my product ThinkComposer and company (Instrumind Software).

A preliminary and undocumented Beta version is also available.

The documentation about how to use the software will be created and published in the coming weeks.

If you wish, download and use it at your own risk and imagination!

The URL is:

ThinkComposer is the versatile tool to Express the Challenges, Solutions and Knowledge of your Unique World.

(for Windows 7, Vista and XP)

It can create Concept Maps, Mind Maps, Models and general purpose Diagrams with rich and detailed content.

You can define your own “Domains” creating specialized Concepts and Relationships, considering its symbols, visual style, associativity and structured information.

This Beta will expire on Jan-01-2012, but more versions will come. Stay tuned!

Programming Software: Less text, more graphics.

Since introduction of CRTs and keyboards programming software has been doing writing plain text. Initially using simple text editors, then evolving to the Integrated Development Environment which incorporated also the rich features of Graphical User Interfaces. Most of the graphical development work was related to designing visual interfaces (arranging windows, buttons, lists, etc.) and drawing diagrams (for design and documentation). But the programming itself is mostly text-based.

Currently, most (source code) programming interfaces look like this one…

However, the use of graphical feature towards programming is growing. Either to simplify the error-prone text programming, or to rise the level of abstraction used in writing software. Let’s see some products and ideas going on this direction…

1.- Constant Velocity IDE.

This is just a concept vision project of a future idealistic programming environment.

 Just see how a class (a programming abstraction) can look like:

2.- Code Bubbles.

This project is pretty interesting in about how to make programming more fluent. Instead of having long text files with code, it represents code parts as “bubbles” which can be graphically arranged, linked, annotated and grouped together as needed.

Let’s see this innovative environment…

3.- 12 Blocks.

This is my favorite, a product for Robotics which present programming parts (sentences, loops, calls, etc.) as jigsaw alike pieces called blocks.

You can see the simple, but intuitive design, showing connectable/pluggable parts, nested loop zones and their parameter inputs…

I know that the idea of graphic programming has been around since the GUI inception in the 70s but, due to complexity of software programs, it has not advanced so much it productivity and acceptance. Hopefully, the current trends of making software more descriptive (less “how to do”, more “what to do”) will rise the abstraction level enough to take advantage of graphics and depend less on detailed text code.