Argonaut's life

Papyrus critics idea: what to port from ArgoUML into Papyrus

2011-10-29T00:31:00.001+01:00

Although I've been involved with the development of ArgoUML, currently there is another UML editing open source tool which is getting enough track to gain my attention. This is Papyrus. It is RCP and EMF based from its conception, i think.

So, it should be less complex to proceed from it than to proceed from ArgoUML, which must progress in the painful way from an architecture oriented towards Java Swing and NetBeans MDR (the project was abandoned by NetBeans). As a user of ArgoUML, which would be the most interesting features to bring from ArgoUML into Papyrus?...

critics
varied module ecosystem;
plenty of programming languages supported?
some concrete specific features that users can't live without;
some well supported translations;
(meta '("missed something?"))

So, my basic idea is to try to introduce into Papyrus some of the features that ArgoUML has which could add value to Papyrus as a UML editing and visualization tool. At least i could start from there. This blog would continue to be called Argonaut's life, obviously :-)

But you must always start by using the tool and fix a simple bug before delving into some process like this. Guess what - i never used it!?!

Listening now kaya project, elixir.

Common Lisp libraries: Quicklisp

2011-05-17T09:42:00.005+01:00

Quicklisp is the base solution for solving the lisp libraries problem, which therefore is now solved :-)

Thanks to Zach Beane for writing and maintaining it and to Peter Seibel for his continued effort in advocating Common Lisp as a industrial strength language. I know it is because I work at SISCOG which uses Common Lisp extensively.

hb2posts (previously htmled) port to Clojure

2011-05-08T23:40:00.001+01:00

(meta '(idea htmled port clojure github open source learning argonauts-life blog))

[2011-05-06 Fri 22:46]
The initial org-meta-mode was bogus. I must learn Clojure instead of messing around with elisp and Common Lisp. The idea I'm having now is to publish htmled in GitHub tonight! Will I be capable of at least one such small hacking and big learning thing?

[2011-05-08 Sun 23:07]
Here it is: https://github.com/euluis/hb2posts. Licensed under the EPL because I want to port it to Clojure.

I had to change the name from htmled to hb2posts because htmled was already taken.

Improve Emacs HTML mode by adding an automatic translator between accented chars and their HTML / Unicode entities

2010-12-16T23:51:00.000Z

I would like to improve Emacs HTML mode so that when I enter an accented character it would replace it with the corresponding HTML Unicode entity. I don't know if this would have to be some kind of hook which captures the entrance of specific characters or if I could implement if as a gigantic search and replace operation. The later option isn't so attractive because it gets into the flow of writing. But the former would also...

Currently Emacs HTML mode provides the sgml-name-char (C-c C-n) command that almost enables the same thing, but, it gets a bit in the way of my flow of thought. (Actually, writing directly in HTML also gets in my thought process anyway... Maybe I should write first and then edit. But I digress...)

So, how could this be implemented? A way would be a minor mode for HTML for automatic translation which mainly defines a minor mode key map that overrides the global and major mode keymaps for accented characters and invalid HTML characters. Is this an interesting idea?

How to implement an Emacs minor mode? A good example is flyspell-mode, which source is available just C-h f flyspell-mode and following the link to the source.

Idea for Git demo: show its power for sweeping changes in SISCOG-UTIL and CREWS

2010-12-14T07:12:00.000Z

At SISCOG we are using Git as a development tool, but, not as the official version control system. I was challenged to make a demo / presentation on what would be the changes to the processes and working methods if SISCOG was going to use Git.

One idea I had recently was to show what Git could do if I need to change CREWS in a more automated and integrated way, so that I might have an easily mergeable branch of CREWS and SISCOG-UTIL, how would I proceed? Would Git solve the problems easily? How could I demonstrate this?

Showing off the power with defsystem to ASDF migration? How would that give them the thrill of power? Try, don't be shy to fail and earn time, quality and satisfaction.

Para convencer alguém eu tenho de mostrar o que é possível
e não como lá chegar!!!
Eu tenho de estar mais com as pessoas
e só assim as poderei motivar.

Idea: make the binary data library of PCL book parallel friendly

2010-12-14T00:37:00.000Z

I'm still reading and learning from the Practical Common Lisp book by Peter Seibel [it is hard to believe that I started in 2007!]. When reading the chapter 24. Practical: Parsing Binary Files, which describes and provides a library for reading binary files, and upon reaching the variable:

(defvar *in-progress-objects* nil
  "TODO or FIXME, how to make this part of the code more parallel friendly?")

I stopped reading and started wondering about the TODO or FIXME I just wrote. The following is the resulting ideaware...

His it worth it or will the disk access eat the advantages?

Yes if there is parallel disk access, meaning in disk array architectures and for really big files. For small files the parallel access isn't worth it because the disk array will know how to do it in a parallel way.

Design

An additional option to a certain binary-class would mark that binary-class as one that would spoon a new process or thread for writing (NOTE to self write and read operations aren't symmetric from a performance point of view) or reading an instance of that binary-class.

Additional bindings of the dynamic variables would have to be created for the symbol that are to be called in parallel, i.e., a new thread based call would mean a new lexical environment is created in which the new binding exists.

It would be fun to port this library to Clojure / JVM languages. I think that this would be allowed because it isn't the original work that would be made available.

Programming Praxis Alien Numbers in Clojure

2010-10-27T23:51:00.002+01:00

I solved the full Programming Praxis Alien Numbers exercise in Clojure. This enabled me to learn more about Clojure and to train my algorithmic parts of the brain a bit.

In all this I was a bit disappointed. It took me too much time to reach a full solution and then, in the core part of the exercise I had to resort to one of the other persons to reach a better way to convert a decimal number to an arbitrary radix number given its language.

I was also a bit disappointed in the way that I wasn't able to use Clojure's laziness more in the algorithms, resorting too much for my taste to loop. From a positive point of view, the Clojure abstractions work as advertised and the only difference from the code bellow and another that would use instead of strings a vectors or lists would be the conversion in the return value of decimal-to-lang.

Follows the core of the exercise solution. Note that the full solution with tests is here. Still considering the Clojure sweet points, I think I could easily explore its excellent support for concurrency and convert the main algorithm into a parallel one if there were hundreds of lines to be processed.

(defn decimal-to-lang
  "Converts decimal-num to the equivalent number in lang as a string.
  The algorithm was a translation of the algorithm by Rodrigo Menezes
  in C# that he posted in the programming praxis site."
  [decimal-num lang]
  (let [lang-radix (count lang)]
    (loop [decimal-value decimal-num lang-num []]
      (if (>= 0 decimal-value)
 (apply str lang-num)
 (recur (int (/ decimal-value lang-radix))
        (concat [(nth lang (mod decimal-value lang-radix))] lang-num))))))

(defn digit-index
  [digit lang]
  (loop [i 0]
    (if (= digit (nth lang i))
      i
      (recur (inc i)))))

(defn lang-to-decimal
  [alien-num lang]
  (let [radix (count lang)
 ralien-num (reverse alien-num)]
    (loop [i 0 decimal-num 0 product 1]
      (if (= i (count ralien-num))
 decimal-num
 (recur (inc i) (+ decimal-num (* (digit-index (nth ralien-num i) lang) product))
        (* radix product))))))

(defn convert-num
  "Convert alien-num which is in source-lang into the same number in target-lang"
  [alien-num source-lang target-lang]
  (decimal-to-lang (lang-to-decimal alien-num source-lang) target-lang))

More ideas about htmled

2010-07-03T07:40:00.000+01:00

htmled, my Python hacks to automate conversions of the contents in my handbooks into posts in my blogs received some recent attention, but, I still have plenty of hitches with the overall process. Follow two quick ideas for future improvement.

The handbook editing part (creating the content in HTML) is too hard; solution might be a specific mode in Emacs customized for editing HTML with specific functions to accelerate the creation of structural elements or using a base format that can be processed afterward to generate the proper HTML.

Editing in Emacs is way superior than in the HTML browser. I wonder if it would be possible to embed Emacs as the editing component of multiple lines text fields. Extra bonus if you could put a served Emacs frame as the editing component.

ArgoUML tests issues

2010-07-03T07:39:00.000+01:00

Update ArgoUML tests to JUnit 4.x – issue created

This idea now has ArgoUML issue 6100.

Issue 6085 is also moving forward.

ArgoUML C++ – generator and modeling

2010-06-26T21:42:00.002+01:00

The C++ code generator in the ArgoUML C++ module has been growing in its usage of Taggedvalues and it hasn't grown more because it hasn't received recent contributions. In a recent thread in the Using ArgoUML for modeling C++ topic of the ArgoUML's users forum, this started to become more clear for me. Here is my answer to Ulrich Thombansen's on the 24th of June:

Hi Ulrich,

> (...) on the “constructor”. What about taking this off the documentation at tigris?

I consider that the best solution. Given two ways to make something, I would go for the standard UML way, which even if taking a bit more of work by the user, it is more flexible because you have an actual operation that might be customized, e.g., by adding arguments. By being explicit we may in the future enable specific customization related to C++ constructor specificity.

Note to self: TODO: place this conclusion in the issue 21. Consider the possibility of some TagDefinitions in the «cppOperation» Stereotype being only applicable if the Operation to which the Stereotype is applied also has the «create» Stereotype applied.

> cppAttribute
> ==========
> applying «cppAttribute» to a variable “myAttrib” with the tag “pointer” set to different values leads to the following results:
> no) tag value -> result
> ----------------------------
> 1) “false” -> int myAttrib; /*{pointer=false}*/
> 2a) “true” -> int *myAttrib; /*{pointer=true}*/
> 2b) “xyz” -> int *myAttib; /*{pointer=xyz}*/
> 3) “” -> int *myAttib;
>
> Feature or fault?

IMO feature (I would call it a default behavior due to a present limitation in ArgoUML) and a nicely chosen one, although in the future when ArgoUML supports typed TaggedValues, I would model the “pointer” TagDefinition as a UML Boolean and therefore you would only have True or False. The rational behind letting the user model any “pointer” TaggedValue as being true but the actual String “false” is that if the user added the “pointer” TaggedValue in an Attribute, it is because he want the pointer to be present.

> cppAttribute
> ===========
> applying «cppAttribute» to a variable “myAttrib” with the tag “get” set to public leads to the implementation of the int get_myAttrib(); function.
>
> Is there a way to make this “virtual”? GeneratorCpp.java only creates “virtual” for (!leaf && !isConstructor && !static)||abstract. Which rule applies / can be influenced?

This is one of the reasons I dislike TaggedValues being used where the default UML suffices. By adding the “get” or “set” TaggedValues to represent an hint for the generator you put yourself in a position where you step out of the proper language for representation of the Operations. If there was a button for generating get and set operations for a given attribute at the model level you would have afterward the liberty to customize it as for any other operation. Since ArgoUML doesn't have this, we added “get” and “set” TagDefinitions to the «cppAttribute» Stereotype, but, given that these are simply TaggedValues we will be left with the modeling of all the particularities of operations as different values of the “get” and “set” TaggedValues. It isn't a fair deal. The overload isn't only for the implementation, but, also for the users...

I would model it the other way around, having a “get” and “set” TagDefinitions applicable to Operations to which the «cppOperation» is added and the values would have to match the name of the attribute which the operations are related to. A more powerful way would be an association between the Operations and the Attributes, but, I don't know if UML allows that, and I'm almost certain that ArgoUML doesn't.

One of the issues with all this is trying to guarantee symmetry between code generation and reverse engineering. Although it is a bit like utopia, we might be closer to it if we stick as much as possible within the UML proper when possible.

Note to self: TODO: create an issue of type enhancement proposing the deprecation of get and set TagDefinitions in «cppAttribute» and adding the these TagDefinitions to «cppOperation». Model it initially as a String that must match the corresponding Attribute name and afterward as an Association (if and when this is supported).

Dispersion problem – revisited after 7 months

2010-06-25T23:26:00.002+01:00

About 7 months ago I wrote about my dispersion problem. I didn't honored my decision at that time which was to dedicate myself fully to ArgoUML during about one year. For instance, I recently finished some hacking in the friendly user interface for htmled that allows me to say:

python hb2post.py --startdate=2010-06-01 > posts-in-programacao-since-june-1st.txt

Why did I did it? It isn't only dispersion working, it is also a desire to be a better hacker and to know more. But, this takes me away from my dream which is to fulfill one or more remarkable ideas. So, back to initial plan.

But, to see the glass half full instead of half empty, I list all the issues I was involved with in ArgoUML and which are resolved since my decision:

Also, looking in retrospective the past months were good for ArgoUML on several areas:

Linus Tolke finally handled the switch of the ArgoUML license from BSD like to the Eclipse Public License (EPL) 1.0, which means that ArgoUML and ArgoEclipse will move together and that Tom Morris will be more willing to continue to contribute.
Bob Tarling was the main contributor to ArgoUML 0.30.1 and he was able to achieve the replacement of the old model elements property panels by the new implementation which is based on XML definitions. Originally this was developed by Christian López Espínola in a GSoC 2008 project, but, never before matured enough to be a full and stable replacement of the old implementation. Kudos to Bob :-)
Tom Morris returned to active ArgoUML contributions, and although he isn't yet as active as before, his overall understanding and detailed knowledge of UML and plenty of ArgoUML components helps a lot when others need guidance such as I did during 0.30.x bug fixing period. In the last period of 0.30.1 development, he even took issue 6008 on his hands and made some big changes to the reference handling of profile model elements which I would have struggled for months to get right. He achieved it in about one week.
Linus Tolke managed to stabilize the Hudson continuous integration server where ArgoUML nightly builds are executed and continues to maintain the automated builds, project infrastructure and release tasks.
Thomas Neustupny and Andreas Rueckert are actively evolving the argouml-core-model-euml implementation of the model subsystem (the result of a GSoC 2007 project by Bogdan Ciprian Pistol) and therefore moving ArgoUML towards UML 2.x.
I'm happy with the progressive stabilization and polishing of the profile subsystem (yet another result of a GSoC 2007 project, this one by Marcos Aurélio).
ArgoUML's users forum is growing in activity with Thomas Neustupny, Tom Morris, me, daybyter and KiwiCoder being active helpers. Kudos to Lukasz Gromanowski for setting this and the users' wiki for the project and for the continued support. Compared with the argouml-users mailing list the forum is rocking!
Michiel Van der Wulp continued to support the notation subsystem and the state and activity diagrams and although he isn't so actively contributing as he used to he continues to help with his expertise in these areas.
There was also the return of previously inactive contributors such as Alexander Lepekhine.

I may be forgetting some relevant contribution and if so drop me a line to update this post. I think that attributing the kudos to contributors is important for the health of the project. Thank you all for continuing to move forward the project and to our users to keep nagging us about the bugs and annoyances :-)

Learning Clojure – development environment configuration

2010-06-15T23:57:00.001+01:00

I already started learning Clojure some time ago by following the tutorial Clojure - Functional Programming for the JVM by R. Mark Volkmann, a Partner of Object Computing, Inc. (OCI). I also did the casting Clojure tutorial, read a lot of Clojure blog posts and saw some videos about Clojure.

What I was missing was a sane Clojure development environment configuration which could live at peace with my Common Lisp Emacs SLIME development environment. Well, by following the Swank_clojure_setup_for_hardcore_Emacs_users.el I achieved it. But, first I had to ditch my Debian based SLIME installation and go to the SLIME CVS version. That was the base recommendation that hardcore Emacs and Common Lisp hackers give, so, nothing too wild here.

Besides Clojure, I also wanted to have working Common Lisp implementations connected to Emacs. My choice was previously the SBCL version available from Debian repositories and ABCL from the Subversion checkout.

So, enough introduction, follows the objectives and how I did it on a Debian based GNU/Linux distribution and bash.

Emacs snapshot from Debian's repositories.
~$ sudo apt-get install emacs-snapshot-gtk emacs-snapshot-el
SLIME from CVS.
~$ sudo apt-get install cvs # only if you don't have CVS yet
~$ cd programacao/lisp # I have all Lisp related programming sources here
~/programacao/lisp$ cvs -d :pserver:anonymous:anonymous@common-lisp.net:/project/slime/cvsroot co slime
~/programacao/lisp$ cd slime/doc
~/programacao/lisp/slime/doc$ sudo apt-get install texlive # because I want to build an up-to-date slime-doc
~/programacao/lisp/slime/doc$ make
~/programacao/lisp/slime/doc$ gzip slime.info # TODO: this is available as make install, but, my distribution paths are different...
~/programacao/lisp/slime/doc$ sudo install-info slime.info # make it available to info
~/programacao/lisp/slime/doc$ sudo cp slime.info.gz /usr/share/info/
~/programacao/lisp/slime/doc$ cd ~
SBCL from source tarball download, which I placed in ~/programacao/lisp/sbcl.
~$ cd programacao/lisp/sbcl
~/programacao/lisp/sbcl$ tar -xvjf sbcl-1.0.39-source.tar.bz2
~/programacao/lisp/sbcl$ cd sbcl-1.0.39/
Now, check the INSTALL...
Now, check the Getting started...
I already had the SBCL from Debian, so, this would be my Common Lisp host which would be automatically used by make.sh.
~/programacao/lisp/sbcl/sbcl-1.0.39$ sh make.sh # and detach with C-a d, using screen -r to check its state from time to time
An alternative I will try next time is to use a non-GUI terminal by going C-M-F1.
TODOs: install binaries, build and install doc.
~/programacao/lisp/slime/doc$ cd ~
ABCL from Subversion. I already had Subversion and Ant installed via apt-get install.
~$ mkdir -p programacao/lisp/abcl/svnco && cd programacao/lisp/abcl/svnco
~/programacao/lisp/abcl/svnco$ svn co svn://common-lisp.net/project/armedbear/svn/trunk/abcl && cd abcl
~/programacao/lisp/abcl/svnco/abcl$ ant # this creates the abcl executable shell script to launch ABCL
~/programacao/lisp/abcl/svnco/abcl$ cd ~
Ant and Maven binaries downloaded and installed.
~$ sudo apt-get install maven2
Clojure and Clojure-contrib from their Git repositories. Git was already installed.
~$ cd programacao/clojure
~/programacao/clojure$ git clone http://github.com/richhickey/clojure.git
~/programacao/clojure$ git clone http://github.com/richhickey/clojure-contrib.git
~/programacao/clojure$ cd clojure
~/programacao/clojure/clojure$ ant jar
~/programacao/clojure/clojure$ cd ../clojure-contrib
~/programacao/clojure/clojure-contrib$ mvn package
~/programacao/clojure/clojure-contrib$ cp target/clojure-contrib-*.jar clojure-contrib.jar
~/programacao/clojure/clojure-contrib$ cd ~
Leiningen binary downloaded and installed.
~$ mkdir -p progs/lein && cd progs/lein/
~/progs/lein$ wget http://github.com/technomancy/leiningen/raw/stable/bin/lein && chmod u+x lein
~/progs/lein$ cat >> ~/.profile PATH="$PATH:$HOME/progs/lein" # finish editing with C-d
~/progs/lein$ lein self-install
~/progs/lein$ cd ~
Clojure-mode and Swank-clojure also from Git repositories.
~/programacao/clojure$ git clone http://github.com/technomancy/clojure-mode.git
~/programacao/clojure$ git clone http://github.com/technomancy/swank-clojure.git
~/programacao/clojure$ cd swank-clojure && lein jar
~/programacao/clojure/swank-jar$ cd ..
Create a shell script to launch Clojure with all the required goodies in the classpath. Note that this script will be used within Emacs and therefore you don't want fancy wrapping and history with rlwrap. You may create one of those to use in the command line, though.
~/programacao/clojure$ cat > clj-dev.sh #!/bin/sh CLOJURE_JAR=/home/user/programacao/clojure/clojure/clojure.jar CLOJURE_CONTRIB_JAR=/home/user/programacao/clojure/clojure-contrib/clojure-contrib.jar SWANK_CLOJURE_JAR=/home/user/programacao/clojure/swank-clojure/swank-clojure.jar JAVA=$(which java) CLJ="$JAVA -server -cp $CLOJURE_JAR:$CLOJURE_CONTRIB_JAR:$SWANK_CLOJURE_JAR clojure.main" exec $CLJ "$@" # not part of the file, finish with C-d

So, after writing all this in shell language, would it be possible to have it in Clojure, Common Lisp or Emacs Lisp? With Clojure we could get fancy and execute some long lasting tasks in parallel.

Finally, the relevant part of my ~/.emacs file:

;;; SLIME and Lisp and Clojure support
(require 'cl)
(add-to-list 'load-path "~/programacao/lisp/slime/")
(setq slime-backend "swank-loader.lisp")
(setq inferior-lisp-program "~/programacao/lisp/sbcl/sbcl-1.0.39/run-sbcl.sh")
(add-to-list 'load-path "~/programacao/clojure/clojure-mode/")
(add-to-list 'load-path "~/programacao/clojure/swank-clojure/")
(pushnew '("\.clj$" . clojure-mode) auto-mode-alist)
(require 'clojure-mode)
(setq slime-lisp-implementations
      '((sbcl ("~/programacao/lisp/sbcl/sbcl-1.0.39/run-sbcl.sh"))
 (abcl ("~/programacao/lisp/abcl/svnco/abcl/abcl") :coding-system iso-latin-1-unix)
 (clojure ("~/programacao/clojure/clj-dev.sh") :init swank-clojure-init)))
(require 'slime-autoloads)
(setf slime-use-autodoc-mode nil) ; swank-clojure doesn't support autodoc-mode
(slime-setup '(slime-banner slime-repl slime-fancy slime-scratch
       slime-editing-commands slime-scratch slime-asdf))
(setf slime-net-coding-system 'utf-8-unix)
(setf swank-clojure-binary "~/programacao/clojure/clj-dev.sh")
(require 'swank-clojure)
(defun run-clojure ()
  "Runs clojure lisp REPL"
  (interactive)
  (slime 'clojure))
(defun run-abcl ()
  "Runs ABCL lisp REPL"
  (interactive)
  (slime 'abcl))

I still have Paredit configured for the Lisp dialects I use, which is another recommended way to customize Emacs. Definitely, there are pieces missing, but, I reached a target with enough relevancy for me to be worthy of careful documentation :-) I could have earned extra hacking points if it would be automated, though, so, thou shall not halt here!

3rd European Lisp Symposium – a light review

2010-05-12T20:01:00.001+01:00

The symposium was nice, small enough that you were capable of getting acquainted with a large percentage of persons and individually chatting with the presenters after their talks. There were a majority of persons related to academia, but, due to the large participation of SISCOG, I think that industry was almost half the number of persons. It is funny that by the number of academia persons is clearly larger from the point of view of presentations and involvement in the organization. We need more industry involvement not only for paying the checks, but, also for presenting and participating in the organization.

I would like to have seen some specific content related to Clojure. Alas, I should have proposed a lightning talk, but, I still don't have anything to show yet, so, the solution would be to spend one night preparing things, but, I preferred to enjoy the dinners. There is something that should have been added related to cloud computing and web applications. Note that RavenPack although not being that, it is a real time data service for financial companies, so, it isn't a mainstream application, but it is very interesting on its own and it is novel.

The overall feeling which I get of the Symposium is that of a group of persons who still suffer at the fact that being Lisp such a special thing, the Symposium should have a larger number of persons, the companies that use Lisp should be larger and more profitable, the open source libraries more polished and more in number, etc. I think that we like the persons which are part of the community and the accessibility of our stars, such as Kent Pitman. We don't like the fact that Lisp is still foreign in large swathes of the industry. Nevertheless, we are seeing a resurgence of Lisp and its use both in academia and in the industry. Now we need to get scale and solutions, so, like for other languages, we need some killer applications / frameworks. This might be a multitude of them, since there are several Lisp dialects and each one may pursuit something different.

3rd European Lisp Symposium, day 2

2010-05-07T19:57:00.002+01:00

Tutorial: Parallel Programming in Common Lisp by Pascal Costanza

09:00 - 10:30

Parallel programming is the wave of the future: It becomes harder and harder to increase the speed of single-core processors, therefore chip vendors have turned to multi-core processors to provide more computing power. However, parallel programming is in principle very hard since it introduces the potential for a combinatorial explosion of the program state space. Therefore, we need different programming models to reduce the complexity induced by concurrency.
Common Lisp implementations have started to provide low-level symmetric multi-processing (SMP) facilities for current multi-core processors. In this tutorial, we will learn about important parallel programming concepts, what impact concurrency has on our intuitions about program efficiency, what low-level features are provided by current Common Lisp implementations, how they can be used to build high-level concepts, and what concepts Lispers should watch out for in the near future. The tutorial will cover basic concepts such as task parallelism, data parallelism and pipeline models; synchronization primitives ranging from compare-and-swap, over locks and software transactional memory, to mailboxes and barriers; integration with Lisp-specific concepts, such as special variables; and last but not least some rules of thumb for writing parallel programs.

QUESTIONS

I questioned Pascal about the portability of parallel code and there is none up-to-now. This smells like an opportunity.

On a question of mine about the need to sync the functional data structures internally - for instance FSet is portable - I got a book reference: Purely functional data structures - it was suggested to me that I should read this to understand why there is no need for synchronization. THOUGHT: my lack of an academic background in computer science is to blame for my lack of knowledge about things like this, even after having read about it in respect of the Clojure data structures.

Session III (The Language)

11:00 - 12:45

CLoX: Common Lisp Objects for XEmacs by Didier Verna

Debugging CLoX is a living hell.

Didier made an excellent and very dynamic presentation. There should be no problem in moving what he got up-to-now into GNU Emacs. He intends to optimize some parts to C, though, and then it would be a problem, because XEmacs C level is incompatible with GNU Emacs C.

CLWEB: A literate programming system for Common Lisp by Alexander Plotnick

CLWEB is language specific with advantages for Common Lispers. No tracking back to the source file position yet. Complexity due to the different objectives of the CLWEB reader and Common Lisp reader. Common Lisp STREAM libraries and pretty printer are great! Code walker for Common Lisp - based on the one from the macro-expand-all paper(?). It would be nice if there was more standard ways to interact with the Lisp operators, as to have an easier time creating a walker. Works in SBCL, Allegro and another (Clozure ?).

Keynote: Lots of Languages, Tons of Types by Matthias Felleisen, Northeastern University

Since 1995 my research team (PLT) and I have been working on a language for creating programming languages - small and large. Our code base includes a range of languages, and others contribute additional languages on a regular basis. PLT programmers don't hesitate to pick our lazy dialect to implement one module and to link it to a strict language for another module in the same system. Later they may even migrate one of the modules to the typed variant during some maintenance task.
An expressive macro system is one key to this riches of languages. Starting with the 1986 introduction of hygienic macros, the SCHEME world has worked on turning macros into tools for creating proper abstractions. The first part of my talk will briefly describe this world of modern macros and its key attributes: hygiene, referential transparency, modularity of macros, phase separation, and macro specification.
The second part of my talk will focus on how to equip LISP-like languages with a sound type systems and that will illustrate the second key idea, namely, monitoring the interactions between different languages. Our approach to type systems allows programmers to stick to their favorite LISP idioms. It mostly suffices to annotate functions and structures with type declarations during maintenance work. To ensure the soundness of this information even when higher-order values flow back and forth between typed and untyped modules, module boundaries are automatically equipped with software contracts that enforce type-invariants at all levels.

PLT Scheme is now Racket. Types are very important for maintenance work.

Type theory is stupid. Design driven to make typed Lisp programming practical. Combining the macro system and the type system is still an unresolved challenge.

Panel – does Lisp matters?

I'm part of the panel and therefore instead of notes the following is what I prepared to say. Eventually the specifics weren't followed...

My small intervention notes

Name
disclaimer: less Lisp Experience than the majority of the persons in the room. Although I'm a SISCOG employee, what I will say represents my opinions and I don't know if they are aligned with the ones of SISCOG administration or with the ones of the majority of SISCOG employees.
background:
1. Physics Engineering, some experience in software development both for data processing and analysis and for scientific instruments
2. then I started working as a software engineer in telecommunications domain, specifically, in the management of telecommunications networks
3. about 3 years ago I joined SISCOG and started working in the railway planning and management domain and yes, programming in Common Lisp.

So, SISCOG was founded by 2 professors of the IST - an engineering academical institution. They wanted to use Artificial Intelligence and in the 80s that meant Lisp.

Question: Does Lisp matters?

Yes it does, because of the following three things:

Inspiration – it has been an inspiration to lots of persons and languages. This is nothing new, but, many of the new languages still steal from Lisps. And normally they are still crippled copies. So Lisp matters even if it didn't existed anymore, although with open source, as Kent Pitman said yesterday, it isn't possible to kill it.
Edge – it provides an edge for its users. Be it due to its dynamic nature, macros, tools, history, smart people magnet, etc.
Research – Lisp is very important due to its flexibility and ease of experimenting with new ideas. I will just refer as an example to the previous keynote by Matthias Felleisen.

Quote by Matthias Felleisen:

we are the cockroaches of the world, nobody can kill us!

Announcements, Symposium wrap-up

Didier Verna announced that the 4th European Lisp Symposium will be next year in Hamburg, Germany, on March 30 and April 1. Deadline to submissions will be around the end of the year. This time around I will try to have something to present. Theme parallelism and ...

3rd European Lisp Symposium, day 1

2010-05-06T19:50:00.002+01:00

I'm participating in the 3rd European Lisp Symposium. My employer, SISCOG is sponsoring my participation and of a bunch of others, like the other Luís Oliveira of CFFI fame.

What follows are my notes of day one of the 3rd ELS, with an organization which follows the programme.

Welcome

Wifi not working...

The TI Explorer Lisp Machine. It is possible to submit ideas for lightning talks.

Keynote: Going Meta: Reflections on Lisp, Past and Future by Kent Pitman, HyperMeta Inc.

Over a period of several decades, I have had the good fortune to witness and influence the design, evolution, standardization and use of quite a number of dialects of Lisp, including MACLISP, T, Scheme, Zetalisp, Common Lisp, and ISLISP. I will offer reflections, from a personal point of view, about what enduring lessons I have learned through this long involvement.
Both the programming world and the real world it serves have changed a lot in that time. Some issues that faced Lisp in the past no longer matter, while others matter more than ever. I'll assess the state of Lisp today, what challenges it faces, what pitfalls it needs to avoid, and what Lisp's role might and should be in the future of languages, of programming, and of humanity.

Maybe Kent would collaborate in data standards and not language standards – the objective is to have more choice when selecting what programming language and OS you use to do your work...

Interesting, during the AI Winter, due to the risk of Lisp failing altogether (vendors were near to bankruptcy) there was some need to control the news to be more positive about Lisp. Then Gabriel presented Worse is Better and plenty of persons got mad at him.

Quote of a saying someone had at Symbolics:

At Symbolics, we make hard problems easy and easy problems harder.

Lisp has became the nerd of the programming languages. Lisp became detached. At that time Lisp was different and that was very relevant.

Book references: You Are Not a Gadget by Jaron Lanier; Crossing the Chasm

Some people like to be guided, actually they would pay to be guided. Smart people often don't get this.

The effects of free software: languages can no longer be killed.

The effects of the internet: Lisp being used in the server hidden.

The promise of Clojure: multi-core, it is connected (being in the JVM), vision (Rich Hickey).

QUESTIONS

Why is Lisp the language and a Runtime? Why isn't it just the language? One potential problem is CLOS, maybe we need to drop it and actually try to move in a way that it becomes more attached.

Session I (Mathematical Applications)

Verifying monadic second order graph properties with tree automata by Bruno Courcelle and Irne Anne Durand

Hard to understand and I didn't followed it fully...

A DSEL for Computational Category Theory by Aleksandar Bakic

A Software Engineer that worked on this as a hobby. He used CLOS and functions, trying to mix the two to improve the state of the art of the DSL design for this application, based on what was achieved in the other DSLs based in more functional languages. Book reference, the book uses Standard ML.

Keynote: Reading the News with Common Lisp by Jason Cornez, RavenPack

The financial industry thrives on data: oceans of historical archives and rivers of low-latency, real-time feeds. If you can know more, know sooner,or know differently, then there is the opportunity to exploit this knowledge and make money. Today's automated trading systems consume this data and make unassisted decisions to do just that. But even though almost every trader will tell you that news is an important input into their trading decisions, most automated systems today are completely unaware of the news - some data is missing. What technology is being used to change all this and make news available as analytic data to meet the aggressive demands of the financial industry?
For around seven years now, RavenPack has been using Common Lisp as the core technology to solve problems and create opportunities for the financial industry. We have a revenue-generating business model where we sell News Analytics - factual and sentiment data extracted from unstructured, textual news. In this talk, I'll describe the RavenPack software architecture with special focus on how Lisp plays a critical role in our technology platform, and hopefully in our success. I hope to touch upon why we at RavenPack love Lisp, some challenges we face when using Lisp, and perhaps even some principles of successful software engineering.

CTO of RavenPack. No Lisp code in the presentation, but, he is passionate about Lisp and software engineering and still writes plenty of code.

Quants traders. The opportunity - News are important, but, the algorithms didn't used it. News metadata is unreliable. 27000 companies tracked. Manage the historical news database - entity detection and time dependent data.

They use Lisp because they like Lisp and not because it was a problem that only Lisp can solve. Their customers don't care about RavenPack using Lisp. They also don't sell software, they sell data.

They worked with Franz to improve the interface to Oracle DB. Although they were acquainted of some solutions like CL-SQL, it didn't supported some things they wanted, like stored procedures. Other tools being used are: Linux, Git, Windows, Jakarta HTTP client, Java for integration, Apache Server, etc.

Common Lisp technologies: CL-XMPP, Jlinker (Franz), Allegro Server (Franz), Lisp Server pages, Salza compression, CL-store, etc.

Techniques:

Bayesian filters – human experts that classify news as Ham or Spam which serves as training data. Accuracy of around 68%.
Restricted Boltzmann machine – compresses some complex full representation into its minimal representation. Accuracy around 87%. It isn't enough for quanta trading.
Processing Headlines, based on templates or patterns. Kind of rule processing.

Software architecture: boxes for receiving data, boxes for emitting data, boxes for analysis of historical data. Oracle at the center.

Collectors (read news) -> Real-time Analysis -> Event Server -> 
 Lisp                       Lisp + CL-Store        CL-XMPP (chat rooms)

Lisp frustrations: GC (Lisp is behind the curve compared with JVM and CLR), handling of out of memory errors, weak library support for HTTP, Lisp as a scripting language it is chatty on *standard-out* and last but not the least a lot of unfinished libraries.

Lisp Joy: patch live systems, optional keyword parameters, tools (debugger, REPL, tracer, inspector), FFI and macros.

Book reference: Coders at Work by Peter Siebel.

Coffee

15:30 - 16:00

I was indirectly invited via Tiago Maduro Dias to participate in the final panel of 3rd-ELS. After about 1 minute considering if I was the appropriate person to represent SISCOG, I said to myself, yeah, I'll do it, it will be a honor, let me see if I'm capable of it!

Session II (The Outside World)

16:00 - 18:00

Marrying Common Lisp to Java, and Their Offspring by Jerry Boetje and Steven Melcher

How Lisp looks in Java. Very detailed explanation on how Common Lisp is implemented in Java in CLforJava.

THOUGHTS: I would like that there was a similar design overview for ABCL!...

Tutorial: Computer Vision with Allegro Common Lisp and the VIGRA Library using VIGRACL Benjamin Seppke and Leonie Dreschler-Fischer

Offers filters, morphological operations, feature detectors, segmentation, transformations... All at the comfort of an Allegro REPL near you :-)

VIGRA Library - no Google, its not Viagra! C++, template based, unit tested, multi-platform and which is fairly complete in terms of available algorithms.

VIGRACL uses defsystem. It has a multilayer design with 4 layers. In the bottom, there is the VIGRA library in C++, then a C wrapper, then Allegro Common Lisp FFI and finally an abstraction layer implemented in Common Lisp on the top.

Design: multi-layer, slide.

SISCOG is hiring developers

2010-05-01T22:45:00.003+01:00

SISCOG is hiring for our projects department. If you want to program in Common Lisp professionally, are interested in the railway domain (planning and management) and want to be my colleague ;-), apply please.

The Functional Object System idea

2010-03-20T18:28:00.000Z

Functional languages and functional programming techniques are getting into the mainstream of software development these days. Clojure is an example of a recently created language (a Lisp dialect) that although not purely functional, applies the techniques and principles of functional programming very seriously and IMHO with success. Now, how do we combine this in a seamless way with object oriented programming? OOP has been up-to-now very dependent on the objects having mutable states in a destructive way. This isn't compatible with the functional data types which although having state, this is immutable, being the objects' data shared and construction only – and therefore reusable.

My idea is that we need a new object paradigm, which enables easy definition of immutable objects which have the same nature as the functional data types. I've seen this to some degree in a specific SISCOG library defined as an extension to CLOS and that enables an object state tree – much more advanced than the typical command pattern stack based undo/redo functionality you commonly see. It could be implemented in Java with aspect oriented programming (i.e., with AspectJ). Alas, this library suffers from its objective not being specifically of providing a Functional Object System (FOS) and by using the mutable Common Lisp standard types – once you get hold to one of its fields, you can wreck the state indirectly. It also relies on the common with wrapper macros to change from state to state, instead of assuming that all state changes shall be construction only and therefore dropping the use of wrapper macros.

So, what specific concepts must a FOS take to heart in order to work?

Differentiate between query operations and construction operations.
Construction operations always return new objects that shall have one or more of their fields with different values than the objects they clone.
There shall be ways to change the state of the application, pointing some reference to a new root node tree, but, these shall follow concurrency (and maybe distribution) aware protocols, such as the ones defines in Clojure. These aren't necessarily part of the FOS, but, the FOS must play well with these.
The FOS shall provide means for its objects to take advantage of non-FOS objects. E.g., a FOS for Clojure must provide a potentially largely inclusive way for impure mutable Java defined objects to be used with it, even if that means to take advantage of introspection on these objects' operations and expensive quasi-duplication of them without the benefit of reuse.

So, now that I had one more crazy idea thrown into the web, lets check prior art...

OCaml has objects and contains a basis operation called functional update. This provides the basis for maintaining that an object is data plus behavior, but, making it side effect free. The convenience it provides is very interesting, it is almost more terse than actually mutating the objects! Even so, you have the possibility to use an imperative style, but, it isn't the default and you must declare the methods that actually change with mutable.

In Clojure it is all about concurrency, so, you would have to guard against concurrent access to objects that are being mutated. So, there might be additional semantics involved, which weren't obvious in the small part of OCaml that I read.

Gentoo and automated tests

2010-03-20T18:27:00.000Z

With Gentoo Linux you already have the sources for all the software you install. It would be nice if you could also execute the automated tests that the software packages have. If the practice of having also deployment tests in software packages was common enough, you could in the end check if the whole stuff was working as expected by the authors of the software and provide very valuable diagnostic information to open source software projects.

Deployment automated tests

2010-03-20T18:26:00.001Z

A nice thing I read in an agile book was of being able to execute the automated tests after deploying the software as a means of diagnosing if the installation was alright. I think that such a practice should be common place as a means of diagnosing if a certain deployment is correct.

UML representation in Clojure

2010-03-20T18:26:00.000Z

UML representation in Clojure. I.e., create a Clojure domain language for representing UML models and diagrams, which should be serializable to XMI and graphically displayable in several formats, like for instance in ArgoUML format and in SVG. Another idea for ELS 2010...

Distributing Clojure

2010-03-20T18:25:00.000Z

Make a framework for distributed computing with Clojure. Another idea for ELS 2010...

Exploring the clouds

2010-03-20T18:24:00.000Z

Parallel system to explore the infrastructure of cloud providers. With Amazon use its web services to deploy clients and listen to the result. With Google AppEngine ping hosted applications. Use Google Web search to search for hosted applications – site:.appeng.com. Do this with Clojure. How about Microsoft's cloud? ClojureCLR?!?

Common Lisp design patterns

2010-03-20T18:23:00.000Z

Actually catalog of common Common Lisp idioms. Some idioms are generalizable for all major Lisp dialects. Another nice idea for ELS 2010.

reduce map
with-x
defx or def-x
dox or do-x
<conditional-operator>-let or b<conditional-operator> [b is for binding]
...

Provide examples from SISCOG code base?

Each pattern should have an associated implementation strategy for being defined with macros.

Reverse engineering of XML specifications

2010-03-20T18:22:00.000Z

Make a module to handle reverse engineering of XML specifications. One obvious use would be to model XMI's representation of UML in UML. A specific usage interesting for SISCOG's domain would be to reveng RailML specs.

Make this with NSN BicNet Tnml and bring Tnml into UML world as I was proposing internally some years ago.

Change the ArgoUML plugins technology to be based on OSGi

2010-03-20T18:20:00.001Z

ArgoUML has modules (the ArgoUML's terminology for its plugins), as an extension mechanism of the application. The more common use case are the programming language modules, but, you can also have core modules, like for instance the sequence diagram module or the UML property panels module. The problem with the ArgoUML modules as I see it now is that ArgoUML is reinventing the wheel and that this wheel has it share of limitations.

One of the biggest limitations is the problem of not being able to specify a dependency of one module of another.
Another problem is that it is a bit of work to define a module which only purpose is to integrate a third party library into ArgoUML.
The final thing I dislike is that for one reason or another, currently the installation of ArgoUML includes all standard modules in the classpath by generating a hard-coded list of the jars (see META-INF/MANIFEST.MF in argouml.jar in a installation of ArgoUML).

My idea is that we should base our modules or plugins in OSGi. I think that this isn't very hard to achieve because the current scheme doesn't differ very much from what plain OSGi requires. In part this was performed by necessity of the Argoeclipse project – definition of the Eclipse build system based on the MANIFEST.MF files. But, the other part is simply due to the usage of good object oriented design with the Java language, which is related to the interface involved in the definition of the base module (see ) and of specific interfaces for functionality oriented modules, like for instance .

Updating ArgoUML tests to JUnit 4.x

2010-03-20T18:20:00.000Z

We should update ArgoUML tests to JUnit 4.x, is order to take advantage of some of the new features of it. Since ArgoUML now must have compatibility with JSE 5, this should be no problem.

Updating ArgoUML libraries

2010-03-20T18:19:00.000Z

There are several libraries in ArgoUML that need to be updated: easymock, JUnit, etc.

Organizing ArgoUML's automated tests

2010-03-20T18:18:00.000Z

ArgoUML has all the automated tests mixed in a single directory tree for each of the sub-projects of which it is composed. I think that as a project we should differentiate the levels of testing according to the nature of those tests: unit, module, integration, acceptance [non-existing as of now] and deployment. This would enable the TDD cycle, by having unit tests execution in seconds instead of minutes. It would also be very educative for the testing practices in ArgoUML.

UML profile for Lisp

2010-03-20T18:17:00.000Z

Creating a UML profile for Lisp should be very interesting. It would be an excellent exercise for a lightning talk in the ELS 2010. It would be an excellent opportunity to test in depth the ArgoUML profile support. It would be a learning opportunity for me into the depths of the extensibility aspects of UML.

My idea is that it should have some common patterns amongst the several dialects and that those patterns should in principle be modeled in a reusable way in a common profile, maybe a PIM.

Then, each Lisp has a specific namespace system, macro system and library. This must be derived with a PIM to PSM transformation and then developed on its own.

A REPL for each would also be required.

A connector to connect to live Lisps to enable reverse engineering is also interesting. This is something that could take advantage of some sharing of a common base project, but, would naturally diverge for each Lisp dialect.

A multiple languages REPL in ArgoUML

2010-03-20T18:15:00.000Z

Sub-project of ArgoUML that provides a base REPL infrastructure to enable and easy development of multiple language REPLs for ArgoUML. I would make one for each of the dynamic languages modules that exist. Even for the C++ module or other non-dynamic languages modules a special purpose and convenient REPL could be interesting if it contained the interesting imports for interaction with the model. Modeling at the REPL with Common Lisp (ABCL), Clojure or Jython, what a dream!

I'm trying to embed ABCL in ArgoUML, opening a REPL in Emacs, but, because my SLIME setup for ABCL is broken, I'm having difficulties. The idea is to try to develop interactively a ETL from a UML1.4 model into a UML2.2 model to make it easy to update the profiles from UML1.4 XMI into UML2.2 XMI.

One possible solution would be not to use Emacs and SLIME. For instance, I could reuse Netbeans REPL. Since Netbeans already has Jython and JRuby support, I could try to port those easily into ArgoUML.

Auto coordinated traffic

2010-03-20T18:14:00.000Z

System or platform that signals drivers' intent from cars to cars, so that the cars could be smart enough to warn the drivers about what other persons intend to do or even take appropriate measures to avoid accidents.

TODO: elaborate on this.

TODO: develop the idea of developing computational models/simulations where the platform modules could be tested and developed. Do it in Clojure, visualization in Google Maps with site in Google AppEngine. Do this in the programacao handbook.

ArgoUML 0.30 is out

2010-03-09T22:43:00.002Z

ArgoUML 0.30 is out.

Happy modeling :-)

First experiments with ArgoUML's UML2 implementation

2009-12-30T18:00:00.000Z

To answer Thomas' question regarding ditching *.profile file in ArgoUML persisted projects, I started experimenting with the UML2 implementation that is currently being worked on. The problem is that I don't know it well enough to understand if it is possible to do without the file, so, I thought, well, I should experiment with the implementation and start baby stepping the ArgoUML UML Profile for C++ and the C++ module in the path to be UML2 capable.

But, here comes the pain of experimenting with a not production ready implementation – the persistence of the introduced profile projects isn't working correctly for me. Basically, it isn't loading correctly profiles which were persisted. Not so basically, when you load a *.zargo file which model (*.xmi file contained) is a profile, the case is handled exceptionally, but, correctly in org.argouml.persistence.UmlFilePersister.doLoad(File, File, ProgressMgr) (see UmlFilePersister.java:388). But, then, contrary to what I would expect, the org.argouml.persistence.ModelMemberFilePersister.readModels(InputSource) (see ModelMemberFilePersister.java:258), fails to get hold of a list of UML elements with some contents.

XMI format error : org.argouml.model.UmlException: java.io.IOException: Tag uml:Profile not found
If this file was produced by a tool other than ArgoUML, please
check to make sure that the file is in a supported format, including
both UML and XMI versions.

If you believe that the file is legal UML/XMI and should have loaded
or if it was produced by any version of ArgoUML, please report
the problem as a bug by going to http://argouml.tigris.org/project_bugs.html.
 System Info:
ArgoUML version : PRE-0.29.4
Java Version : 1.6.0_16
Java Vendor : Sun Microsystems Inc.
Java Vendor URL : http://java.sun.com/
Java Home Directory : /usr/lib/jvm/java-6-sun-1.6.0.16/jre
Java Classpath : /home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app/build-eclipse-tests:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app/build-eclipse:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-infra/lib/log4j-1.2.6.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model/build-eclipse:/home/luis/programas/eclipse-ganymede/plugins/org.junit_3.8.2.v20080602-1318/junit.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app/lib/commons-logging-1.0.2.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app/lib/gef-0.13.1M3.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app/lib/ocl-argo-1.1.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app/lib/swidgets-0.1.4.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app/lib/toolbar-1.4.1-20071227.jar:/home/luis/programacao/ArgoUML/svnco/argouml/tools/lib/easymock12.jar:/home/luis/programacao/ArgoUML/svnco/argouml/tools/jdepend-2.9/lib/jdepend-2.9.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-mdr/lib/jmi.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-mdr/lib/jmiutils.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-mdr/lib/mdrapi.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-mdr/lib/mof.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-mdr/lib/nbmdr.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-mdr/lib/openide-util.jar:/argouml-core-tools/build-eclipse:/home/luis/programacao/ArgoUML/svnco/argouml/tools/junit-3.8.2/junit.jar:/home/luis/programacao/ArgoUML/svnco/argouml/tools/apache-ant-1.7.0/lib/ant.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app/lib/antlr-2.7.7.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.common_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.ecore_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.ecore.change_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.ecore.change.edit_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.ecore.edit_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.ecore.xmi_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.edit_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.mapping_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/uml2/org.eclipse.uml2.common_1.5.0.v200905041045.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/uml2/org.eclipse.uml2.common.edit_1.5.0.v200905041045.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/uml2/org.eclipse.uml2.uml_3.0.1.v200908281330.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/uml2/org.eclipse.uml2.uml.edit_3.0.0.v200905041045.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/uml2/org.eclipse.uml2.uml.resources_3.0.0.v200906011111.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/lib/emf/org.eclipse.emf.mapping.ecore2xml_2.5.0.v200906151043.jar:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-model-euml/build-eclipse:/argouml-core-infra/bin:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-diagrams-sequence2/build-eclipse:/home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-core-umlpropertypanels/build-eclipse
Operation System : Linux, Version 2.6.29-1-netbook
Architecture : i386
User Name : luis
User Home Directory : /home/luis
Current Directory : /home/luis/programacao/ArgoUML/svnco/argouml/src/argouml-app
JVM Total Memory : 23228416
JVM Free Memory : 5806928


 Error occurred at : Wed Dec 30 08:05:01 WET 2009
Cause : org.argouml.model.UmlException: java.io.IOException: Tag uml:Profile not found
at org.argouml.model.euml.XmiReaderEUMLImpl.parse(XmiReaderEUMLImpl.java:162)
at org.argouml.persistence.ModelMemberFilePersister.readModels(ModelMemberFilePersister.java:258)
at org.argouml.persistence.ModelMemberFilePersister.load(ModelMemberFilePersister.java:112)
at org.argouml.persistence.UmlFilePersister.doLoad(UmlFilePersister.java:389)
at org.argouml.persistence.ZargoFilePersister.doLoad(ZargoFilePersister.java:240)
at org.argouml.ui.ProjectBrowser.loadProject(ProjectBrowser.java:1577)
at org.argouml.ui.LoadSwingWorker.construct(LoadSwingWorker.java:75)
at org.argouml.ui.SwingWorker.doConstruct(SwingWorker.java:139)
at org.argouml.ui.SwingWorker$2.run(SwingWorker.java:267)
at java.lang.Thread.run(Thread.java:619)
Caused by: java.io.IOException: Tag uml:Profile not found
at org.argouml.persistence.XmlInputStream.realRead(XmlInputStream.java:378)
at org.argouml.persistence.XmlInputStream.skipToTag(XmlInputStream.java:226)
at org.argouml.persistence.XmlInputStream.read(XmlInputStream.java:136)
at com.sun.org.apache.xerces.internal.impl.XMLEntityManager$RewindableInputStream.read(XMLEntityManager.java:2933)
at com.sun.org.apache.xerces.internal.impl.XMLEntityManager.setupCurrentEntity(XMLEntityManager.java:739)
at com.sun.org.apache.xerces.internal.impl.XMLVersionDetector.determineDocVersion(XMLVersionDetector.java:186)
at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(XML11Configuration.java:771)
at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(XML11Configuration.java:737)
at com.sun.org.apache.xerces.internal.parsers.XMLParser.parse(XMLParser.java:107)
at com.sun.org.apache.xerces.internal.parsers.AbstractSAXParser.parse(AbstractSAXParser.java:1205)
at com.sun.org.apache.xerces.internal.jaxp.SAXParserImpl$JAXPSAXParser.parse(SAXParserImpl.java:522)
at javax.xml.parsers.SAXParser.parse(SAXParser.java:395)
at org.eclipse.emf.ecore.xmi.impl.XMLLoadImpl.load(XMLLoadImpl.java:181)
at org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl.doLoad(XMLResourceImpl.java:180)
at org.eclipse.emf.ecore.resource.impl.ResourceImpl.load(ResourceImpl.java:1494)
at org.argouml.model.euml.XmiReaderEUMLImpl.parse(XmiReaderEUMLImpl.java:160)
... 9 more
-------
Full exception : org.argouml.persistence.XmiFormatException: org.argouml.model.UmlException: java.io.IOException: Tag uml:Profile not found
at org.argouml.persistence.ModelMemberFilePersister.readModels(ModelMemberFilePersister.java:287)
at org.argouml.persistence.ModelMemberFilePersister.load(ModelMemberFilePersister.java:112)
at org.argouml.persistence.UmlFilePersister.doLoad(UmlFilePersister.java:389)
at org.argouml.persistence.ZargoFilePersister.doLoad(ZargoFilePersister.java:240)
at org.argouml.ui.ProjectBrowser.loadProject(ProjectBrowser.java:1577)
at org.argouml.ui.LoadSwingWorker.construct(LoadSwingWorker.java:75)
at org.argouml.ui.SwingWorker.doConstruct(SwingWorker.java:139)
at org.argouml.ui.SwingWorker$2.run(SwingWorker.java:267)
at java.lang.Thread.run(Thread.java:619)
Caused by: org.argouml.model.UmlException: java.io.IOException: Tag uml:Profile not found
at org.argouml.model.euml.XmiReaderEUMLImpl.parse(XmiReaderEUMLImpl.java:162)
at org.argouml.persistence.ModelMemberFilePersister.readModels(ModelMemberFilePersister.java:258)
... 8 more
Caused by: java.io.IOException: Tag uml:Profile not found
at org.argouml.persistence.XmlInputStream.realRead(XmlInputStream.java:378)
at org.argouml.persistence.XmlInputStream.skipToTag(XmlInputStream.java:226)
at org.argouml.persistence.XmlInputStream.read(XmlInputStream.java:136)
at com.sun.org.apache.xerces.internal.impl.XMLEntityManager$RewindableInputStream.read(XMLEntityManager.java:2933)
at com.sun.org.apache.xerces.internal.impl.XMLEntityManager.setupCurrentEntity(XMLEntityManager.java:739)
at com.sun.org.apache.xerces.internal.impl.XMLVersionDetector.determineDocVersion(XMLVersionDetector.java:186)
at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(XML11Configuration.java:771)
at com.sun.org.apache.xerces.internal.parsers.XML11Configuration.parse(XML11Configuration.java:737)
at com.sun.org.apache.xerces.internal.parsers.XMLParser.parse(XMLParser.java:107)
at com.sun.org.apache.xerces.internal.parsers.AbstractSAXParser.parse(AbstractSAXParser.java:1205)
at com.sun.org.apache.xerces.internal.jaxp.SAXParserImpl$JAXPSAXParser.parse(SAXParserImpl.java:522)
at javax.xml.parsers.SAXParser.parse(SAXParser.java:395)
at org.eclipse.emf.ecore.xmi.impl.XMLLoadImpl.load(XMLLoadImpl.java:181)
at org.eclipse.emf.ecore.xmi.impl.XMLResourceImpl.doLoad(XMLResourceImpl.java:180)
at org.eclipse.emf.ecore.resource.impl.ResourceImpl.load(ResourceImpl.java:1494)
at org.argouml.model.euml.XmiReaderEUMLImpl.parse(XmiReaderEUMLImpl.java:160)
... 9 more

I wanted to prepare a UML2 compatible UML profile for C++ to test that we may live without the *.profile files. But, to make this I can't create it from scratch, I need something like a UML1.4 profile to UML2.x profile conversion. Lets try to do it manually...

Using Emacs, I opened my test profile made with ArgoUML UML2 (MyUML2Profile.xmi), the base UML2.2 profile of ArgoUML (default-uml22.xmi), and the UML1.4 profile for C++ (CppUmlProfile.xmi). One thing I noticed is that the XMI format changed very much. Specifically, in the begin of the file, it is much more noisy. If you don't believe my word, check the following in default-uml22.xmi:

What the heck is the metaclassReference attribute and why does it have so much noise?

It is importing element by element many of the standard UML2.2 metamodel elements. It even does this in duplicate:

  <elementImport xmi:type="uml:ElementImport" xmi:id="_pGIiAMosEd6otN4YcPG1_w" importingNamespace="_PB5O8MoqEd6otN4YcPG1_w">
    <importedElement xmi:type="uml:Class" href="http://schema.omg.org/spec/UML/2.2/uml.xml#Abstraction"/>
  </elementImport>
  (...)
  <elementImport xmi:type="uml:ElementImport" xmi:id="_wcazEMosEd6otN4YcPG1_w" importingNamespace="_PB5O8MoqEd6otN4YcPG1_w">
    <importedElement xmi:type="uml:Class" href="http://schema.omg.org/spec/UML/2.2/uml.xml#Abstraction"/>
  </elementImport>

Does this mean that you have to make this dance twice for it to work?!?

Design of the ArgoUML's projects recovery tool

2009-12-05T17:21:00.004Z

I was starting to try to hack my way to implement the ArgoUML's projects recovery tool which I proposed in issue 5862: Support for moved/renamed/merged profiles when I started to hesitate on what to do. So, I did the right thing, went to ArgoUML 0.28.1 and started a lightweight design session.

I decided that the tool should exist as a sub-project of ArgoUML core. For now its use case(s) is very simple:

Picture 9 – ArgoUML's projects recovery tool use cases.

This is a high level view of the static structure I arrived:

Picture 10 – ArgoUML's projects recovery tool core high level static structure.

This is the activity diagram for it:

Picture 11 – ArgoUML's projects recovery tool happy path activity diagram.

Design sence – deep lessons in software design by Michael Feathers

2009-12-05T17:03:00.002Z

I watched Michael Feathers' talk Design sence – deep lessons in software design, and I what follows are my notes for future reference.

Software normally has a characteristc of being driven by power laws.
- The shape of java – research project that studies the source of both open source proprietary projects in Java.

Everything is an object or may be considered as such.
- Smaltalk – everything is actually and object.
- Ruby – it goes a long way into almost everything being objects.
- C and other procedural languages may be considered as object oriented if you consider the whole program as an object.

A type is a set of values. Covariance and contravariance.
You can't make software more correct with redundancy.
Protection is a social problem and not a technical problem.
There are no requirements. There is only design.
Design by laundry list.
Names are provisional.
Physical architecture shapes logical architecture.
Physical architecture can influence the kind of problems we are able to solve.
Conway's law.
You can finess error handling with good design.
Error policy is as important as the main line.

Keep errors at the boundaries or handle errors at the boundaries of the system.
Null object pattern.

Logging is a first class design consideration.
Databases are good for more than storing data.
Objects want to be asynchronous.

UML profiles management issues

2009-11-20T23:12:00.001Z

I'm currently handling two issues related to ArgoUML management of profiles:

Issue 5041: provide core profiles via the website – finished this today, by verifying that ArgoUML 0.28.1 was working as expected in that it correctly retrieves the profiles from the URL when it can't resolve them locally, and by placing the C++ UML profile available in the ArgoUML C++ module web site.
Issue 5862: Support for moved/renamed/merged profiles – This issue contains a large body of work and I expect that it will keep me entertained for a while.

Other software ideas

2009-11-16T23:50:00.000Z

These aren't related to ArgoUML, but, since they are strongly related to software, they'll be registered here.

Emacs Lisp Unit

Build a unit test framework for Emacs Lisp and with that learn more about Emacs Lisp. Upsss, there is already ElUnit and behave.el.

Contribute to jnil

jnil is an open source project by a colleague from SISCOG, Tiago Maduro Dias. Initially I wanted to join some open source Common Lisp project and the prospect of being able to pair program an open source project with a more experienced Common Lisp developer was very interesting. Unfortunately, I didn't want to leave ArgoUML without reaching a feeling of closure, so, I never joined. It is still an interesting idea...

Genetic programming based in the Common Lisp Condition System

Since I read about the idea of evolving software with genetic algorithms, I was fascinated by it. When I really learned about the Common Lisp Condition System and its capability to offer restarts I wandered if it would be possible to combine the two to provide a way to avoid the need to have mutations to generate correct Common Lisp. It might be a good way to make safe boundaries between mutated code and stable code, to avoid infinite loops, deadlocks, etc.

FitNess Common Lisp adapter

Create an adapter for Common Lisp for FitNess, to enable using this acceptance test framework in Common Lisp projects. With ABCL maturing very fast and being well supported, I wonder if this would be difficult at all.

Learn Clojure

Give myself some time to learn Clojure.

Develop organization absences planer in Google App Engine

The process(es) that organizations normally use to plan their collaborators vacations and absences are usually document driven and the verifications and checks of accordance with the rules and legislation manual. I suffer from this at SISCOG and in SIEMENS, although it wasn't document based, it lacked considering the organization needs, like to have a minimum number of persons in a certain development team available at all times in a year. It didn't considered previous history, like a certain person always not getting his vacations in the Christmas season while others always get them.

It would be a perfect opportunity to learn web development techniques in a restrained platform such as Google App Engine, but, possibly using a JVM based language, such as Clojure or Jython. I wanted also to show this at SISCOG, to have a demo-able example of a Cloud based application, which someday SISCOG may want to try with more commercial purposes...

Online git repositories

I started using distributed revision control systems (DRCS) a while ago, first with mercurial (hg), then with Git, when my ex-colleague Tom Schutzer-Weissmann created a system to import the SISCOG repositories from the in-house defined format (CRM/CRI) into Git. Currently the Git repositories are being used by several persons in SISCOG, but, I still haven't been able to proceed with the work enough to consider the proposal of a switch or a pilot.

Currently I'm more familiar with Git, but, my problem is that I'm not cooperating online using one of these DRCSs. So, I wanted to setup a GitHub account and move in there some of my repositories and potentially host there a fork of ArgoUML. By having a Git based ArgoUML fork, I would have a much easier life in working offline with contributions and a much nicer sandbox to experiment ideas and patches. This I know for sure, because I have been using the branching features of Git in SISCOG for some time with a huge success and satisfaction.

Finish reading Practical Common Lisp

I stopped reading Practical Common Lisp in the chapter 23. Practical: A Spam Filter. I should give myself some time to finish reading and exercising the book. While at it, I should buy a copy of it, since it is excellent and I would have something physical to borrow to newcomers at SISCOG.

Proceeding with ideas on books to read, On Lisp, by Paul Graham is high on my Lisp related books and several others I placed in my Amazon wish lists.

Two ideas related to ArgoUML

2009-11-16T23:47:00.001Z

Following with my write-up of ideas to avoid neurological garbage collection before delving into ArgoUML for some time, follows a list of ideas related to ArgoUML, in which I won't elaborate as much as in the entry about medeia.

abstracter

The idea is to register in the background decisions that the ArgoUML modeler does, so that we may deduce from his actions a set of steps that might be used to solve similar problems. This is similar to a refactoring system that my colleague Rui Patrocínio explained to me. This system, takes a set of programmer actions and may apply them to a similar problem upon a programmer request.

This is called abstracter, because the goal would be to give such a tool the reverse engineering information from a software project and let it abstract away the details, creating easy to use diagrams and perspectives about the software. Kind-of something like pointing it to the OpenOffice.org source and letting it create some meaningful abstractions of it. The part where it is learning or being corrected by a developer is interesting, because it would allow experimentation with machine learning principles...

ArgoUML Lisp module

Implement a Lisp language module for ArgoUML. Probably this could have dialect specializations (Common Lisp, Scheme, Clojure, etc), but, have a reusable base. My idea is that this should be implemented in the specific languages and not in Java, in order to more easily receive contributions from developers that are primarily interested in the module.

Note: Rui Patrocínio referred a related project he was considering to do which is a static analyzer for Common Lisp so that it would be possible to support code browsing and refactoring.

The reverse engineering of Common Lisp, Scheme and Clojure should be based in the same communication protocol as the one used by SLIME, which allows things like running APROPOS.

medeia

2009-11-15T21:44:00.002Z

From all the ideas my idiot's head has had in the past few years, one has been buzzing very strongly and that is medeia. The name Medea comes from the Argonautica book, so, it is related to ArgoUML and it is the name of a woman that helps the Argonauts and Jason in particular to get the Golden Fleece. She knows one thing or two about magic and uses it. Medeia is Medea in Portuguese related to mediate. Well, the name points a bit to what the idea is about...

medeia is a good name because it is similar to idea in Portuguese, which is written ideia.

As the responsible and main contributor to the ArgoUML C++ module, in the past 5 years, I've seen that this – making a language module – is a hard task. There is a lot that must be considered to provide production ready code generator, reverse engineering, notation and round the horn language module(s). Normally the effort is single handed and when you reach the end, there will always be loopholes and needs to extend it. But the worst part is how much of reinventing the wheel goes into it. Lets put the things in a clear way, by enumerating each part of a typical language support module:

UML Profile for the language:
- You need a core language profile with stereotypes that may be used for tagging UML model elements, in order to apply tagged values to the model elements.
- To use the profile in a programmatic way you need some wrapping classes, such as the class ProfileCpp in the C++ module.
- Potentially you would also want to place in the module UML profiles for libraries that are used in plenty of projects that use the language – in the case of C++ we may have boost.
Language generator:
- Use of a template engine for formatting the generated code. (For an example see StringTemplate.)
- A code generator, which maps the UML model into an Abstract Syntax Tree (AST) which would be handed over to the template engine.
- A way not to trash the code that already exist, like the current protected sections in the C++ generator.
- Some form of mapping the documentation in the UML model into the language standard(s) format(s). And you need this to be customizable because projects typically develop specific variants of the documentation standards or there is some company standard that they must use. I would say that this fits more or less in the same problem/solution as the code generator being made by two parts – a mapping from UML to an AST and a template engine which is fed by the AST – but, I think that here there might be more needs for giving customization options for enhancing the AST generator.
- Potentially there is the need to create code from specific UML diagrams or the model elements beneath specific diagrams. For instance, generating the classes that implement the state design pattern for a state machine (check also this nice article by Robert C. Martin (aka Uncle Bob) on finite state machines and UML.
  As a side note, you may not need to do this if you use the ArgoUML Pattern-Wizard module.
Language reverse engineering:
- There must be a language grammar, typically, in ArgoUML, this is based in ANTLR and it is common that there is something for your target language.
- With the language grammar you can generate a Parser, it might even be possible that an AST walker is generated for you, but, your mileage may vary and the available Parser and AST walker might not be fully customized to your needs. For instance, I was capable of getting a ANTLR C++ grammar ported to Java, but, this wasn't prepared to make an AST and I failed to change it into one. It has some bugs which up-to-now I didn't solve. Finally, I'm the one that must keep it evolving with the original grammar which was made for C++. Even the original grammar is now unsupported, which is problematic with the evolution of the C++ standard to C++ 0x.
- Even with the AST walker there is the need to perform the mapping from language constructs to UML model elements. This mapping must be performed in a way that doesn't create duplicated model elements when the same source files are imported multiple times.
- The grammars are normally created for blue sky situations where you have all the information, the source code is well formed, etc, etc. The reality is that the reverse engineering modules must be designed to handle malformed sources and work with incomplete information – i.e., partial imports.
- In C++ you need a C preprocessor. Fortunately there is one open source C preprocessor implemented in Java which the C++ module now uses.
- Users normally aren't satisfied by simple import and they normally want that the reverse engineering creates some simple UML diagrams from code. The Java module has this.
- Finally, the killer feature of a UML reverse engineering module is for a user to point it to a build definition file – for instance a make file for C++ or an Ant build.xml file – and the reverse engineering module would interpret it and import the underlying project fully into a UML model.
Language notation – this enables the user to edit UML with the language notation.
- There is a simple way to create a read-only notation for the language, which is basically to use the code generator in a partial way. That is what the C++ module does in the notation package.
- The complex part is to create a parser for the notation. The best example is to check the parser that Michiel van der Wulp developed for UML notation. Neither C++ nor Java have a notation parser. If there is such a parser for the language notation it would enable fully editable UML models in the programming language.
Round the horn engineering for the language.
- This is the Lucy in the sky with diamonds scenario. You edit the model and say update code and the code is magically updated without trashing the existing code and potentially adapting the dependent code to the changes you made. Even better, it would understand enough of the build definition to add new files to it or remove unused ones.
  My knowledge about tools that support this is that Together did a good job and that Rational Rose for M$ VC++ did a bad job at it. It is a long time since I tried tools such as these in a professional setting.
Language module settings user interface – finally, for each of these things you need to consider how the user is going to interact with it and configure it to his needs.
- A nice GUI for some things, like the generator options concerning the mapping from UML model elements into the language constructs (e.g., see SettingsTabCpp, but, this has some mixture of several parts of the generator).
- The reverse engineering also has a GUI which is placed in the dialog that is shown to the user when importing code. Currently the C++ reverse engineering module has no such GUI, but, you can see an example in the Java module – JavaImportSettings.
- Then there are parts of the UI that may have the form of a template file, but, this is UI and, as such, the template engine must deal with the potential errors introduced by changes the users did.
- All of this and more must somehow be documented in the user manual, which potentially is translated into other languages...

Description of medeia

So, enough of complaining myself about the fun, but, hard and difficult to finish work of developing language support for ArgoUML in the classic way. Lets now delve into what medeia is!

The medeia idea came to me a long time ago, but, in a gradual way. First I thought about a different solution to develop the reveng C++ module, which was to base it in the reuse of libraries made by the Eclipse CDT project. Then, the obvious stroke my mind and I thought of this as a potential solution for several other language modules, just as the Eclipse guys add support for more and more languages, the ArgoUML could grab it and reuse it. Recently, with the evolution of polyglot software development and the dynamic language boom, both Eclipse and NetBeans are adding support for multiple and interesting languages.

Then, with the Argoeclipse project, I thought that this would be a perfect opportunity to revisit this, but, instead of reusing libraries by placing them in the ArgoUML modules, we could just mediate the things that the existing Eclipse environment knows about the projects the user has in his Eclipse workspace and map those into ArgoUML and back, reusing for this the whole infrastructure that Eclipse has. Note that this is also possible for an eventual Argonetbeans.

Finally, while working at SISCOG and understanding the way Emacs connects via SLIME or ELI to a live Lisp and how that enables you to discover on a live and fully consistent software program about its static structure, I came to the conclusion that medeia could be a bit different for languages that have reflexion built-in (Java included)! You just need to place a little piece of software within the program you want to know about and inquire it from the ArgoUML side. No need to parse source files, understand build systems, etc, etc. Well, you still have some work for generating code and to provide a language notation, but, the medeia idea solves a large part of the problem of reverse engineering modules for a language. It creates some new, though...

Classical reveng module	medeia reveng module
Language grammar, AST walker, parser, etc	Interface with the IDE (for languages that don't have powerful enough reflexion facilities, such as C++, C, Fortran and etc) or with the live program (for languages that do have such reflexion facilities), that communicates with the ArgoUML module or with Argoeclipse or with Argonetbeans or with Argowhatever.
Mapping from language to UML.	Ditto, also needed here.
Robust software to deal with incomplete information or malformed source code.	Software that must support some way to filter the information that matters, maybe by allowing the user to specify that the import must be from specific packages or / and by allowing to get the information by specifying incomplete names – similar to IDEs' find type.
C preprocessor or similar things, largely dependent on language quirks.	Nothing like that needed on this side, thanks :-)
UML diagrams auto-magically created by the import sources process.	Ditto in here too, but, with the difference that probably the user might need to ask for diagram creation and update or offer some settings and try to do the correct action for different user actions.
Understanding build definitions to import full projects with the minimum work by the user.	No need for this just for reverse engineering, but, in complex multiple-project scenarios, maybe the users want that the correct UML elements go into the correct UML models... The filtering described above might be a good way for certain languages, but, for languages that simply support namespaces or that are used in a flat package way, like Lisp, this wouldn't work so nicely.

Do you like this idea? Have you seen it applied to other UML tools or to solve similar problems? I recall that this is already used in the context of Emacs and Lisp / Scheme / Clojure, with the SLIME project or others similar to it. But for a UML tool you normally go the way of the classical reverse engineering design described above. Well, maybe Together worked this way when integrated within Eclipse...

Dispersion problem – why am I contributing so little to ArgoUML?...

2009-11-04T22:58:00.003Z

At SISCOG some of the employees – I included – attended a leadership workshop that lasted 3 days and was distributed by February, March and April of 2009. It was very interesting and useful for the development of my soft skills, which I need as part of my role as a team leader. The person giving the workshop was Teresa Roseta of MQI, whom I strongly recommend. SISCOG developed the leadership principles and values in the workshop.

One of the things that was referred there was the need for a person to know himself better. This because it seams that normally good, natural leaders do know themselves very well. One exercise we did for each of us was our professional coat of arms. It is a bit like a personal SWOT analysis, but, the idea was to minimize the number of things that go into each quadrant and to have a middle row with your motto. The things that go into the quadrants are different too. To make a long story short here is my professional coat of arms (the words in [emphasis] are just legends for the contents):

[Strength] easy learning and appreciation for knowledge	[Dream] to fulfill one or more remarkable ideas (hint: MEDEIA)
[Motto] do things right (i.e., well/correctly)
[Vulnerability] dispersion	[Facilitator] persistence

My vulnerability is dispersion. This causes some problems for my average rate of contributions for anything that isn't my primary activity and currently for my contributions to ArgoUML, which are too few and too slow. Issue 5864 illustrates this. I was given a patch, so, I looked into it and thought, OK, lets help this person scratch his hitch and maybe ArgoUML can get a new developer aboard. Then a difficulty came and I feared that it was something that was related to a part of the code that I never delved into and I placed it on hold until I had enough energy for it. But, in the meantime I had enough energy to do a Programming Praxis problem, to start developing a friendly user interface for htmled, to start a crazy attempt to update all the software in my old Windows XP laptop and to investigate the possibility to move some personal Subversion repositories into Git! At least these are the significant things I remember about between 7th and 30th of October. Why didn't I finished the thing I started in the first place? Dispersion!

I disperse because I'm the kind of person that loves to learn and I have lots of ideas. These ideas are all very interesting for me, but, they take some time to look into, develop and document. They are mostly related to software development, but, they don't intersect as much as possible for them to be developed together or in order for some parts to add to the others. So, these things start conflicting with each other and I don't get much done of anything unless at my work, where I managed to finish some significant things.

I like ArgoUML. The developers there aren't the greatest community ever, but, they are nice persons who care most about making ArgoUML incrementally better and some are pretty decent software developers with high commitment level. I think that I contributed some important work for the C++ module and did some nice work in the UML profile support. But, I'm involved in ArgoUML since 2004 and the pace of my contributions has been very snail like or even slower. Even worst, both the C++ module and the profile support seam a bit of an half-finished business. I think I know where the problem lies – dispersion!

So, I do I fight this? I do it by setting up a challenge for myself – spend one year focused at contributing to ArgoUML. Forget about the software blogs, software books and exercises. Blog about ideas I have, take some notes, so that they don't get neurologically garbage collected, but, then go back to work. In the end, take some ArgoUML vacations for some undetermined time, look at one of these ideas and pick it up if I want to give it a try. (Probably I will want to do something related to my work at SISCOG and if so, it may take one year or more to finish, but, I don't know and for now don't care what that will be.)

So, my aim is mainly to move profile support in ArgoUML up into something that looks a lot like finished business and try to do the same thing for the C++ module (this one is harder, though).

But first, as a last bit of devilish concession to my dispersion I'll spend some time writing and publishing some of the significant ideas in either Argonaut's life if they are ArgoUML or software development related, or in Idiota if they aren't.

Oh, and I have an idea for a trick that will help me not to get distracted. I'm going to get myself an ArgoUML bracelet, just like Uncle Bob has his green wrist band to remember himself that code must be clean and tests green. Maybe I should get a green ArgoUML wrist band!

Solution for Programming Praxis' Beautiful Code

2009-10-22T23:21:00.002+01:00

The following is my solution to the Programming Praxis' Beautiful Code problem in Common Lisp. (The final code is also in pastebin.com.)

I started from a solution in which I ported the code from C to Common Lisp as directly as possible. For instance, the code for the matchhere function was this mess:

;;; matchhere: search for re at beginning of text
(defun matchhere (re text)
  (if (= 0 (length re))
      1
      (if (and (< 1 (length re)) (char= #\* (elt re 1)))
   (matchstar (elt re 0) (subseq re 2) text)
   (if (and (char= #\$ (elt re 0)) (= 1 (length re)))
       (= 0 (length text))
       (when (and (< 0 (length text))
    (or (char= #\. (elt re 0)) (char= (elt re 0) (elt text 0))))
  (matchhere (subseq re 1) (subseq text 1)))))))

Then I changed the above to use cond and abstracted (= 0 (length seq)) to empty, which resulted in this:

(defun matchhere (re text)
  "search for re at beginning of text"
  (cond ((empty re))
 ((and (< 1 (length re)) (char= #\* (elt re 1)))
  (matchstar (elt re 0) (subseq re 2) text))
 ((and (char= #\$ (elt re 0)) (= 1 (length re)))
  (empty text))
 ((and (not (empty text))
       (or (char= #\. (elt re 0)) (char= (elt re 0) (elt text 0))))
  (matchhere (subseq re 1) (subseq text 1)))))

Finally, I turned the loop based match and matchstar into tail call form. For illustration, this is what matchstar initially was:

;;; matchstar: search for c*re at beginning of text
(defun matchstar (c re text)
  (loop when (matchhere re text) do (return 1)
       while (and (not (equal 0 (length text)))
    (or (char= c (elt text 0)) (char= #\. c)))
       when (not (= 0 (length text))) do (setf text (subseq text 1))))

And this is how it is after the refactoring:

(defun matchstar (c re text)
  "search for c*re at beginning of text"
  (cond ((matchhere re text))
 ((and (not (empty text))
       (or (char= c (elt text 0)) (char= #\. c)))
  (matchstar c re (subseq text 1)))))

All done, I'm pretty happy with the result I have now. It is very similar to the Scheme solution by the Programming Praxis author and it certainly is very Lispy.

Customizing Eeebuntu GNU/Linux 3.0 Standard into a development environment

2009-09-21T23:55:00.006+01:00

I documented previously the Eeebuntu GNU/Linux 3.0 Standard installation. My intent now is to document the process to make this into a development environment. Since this is an ongoing process, it is possible that I will make new entries that supplement this one, but, for now I hope that this will make the process repeatable and potentially automated.

An important note is that I used the Synaptic Package Manager instead of the command line apt-get package handling utility, so, the commands I'll place bellow maybe won't lead to the result I currently have. This is nevertheless an attempt to automate the process and for this a command line is always better than a list of steps to be performed in some GUI tool.

Install latest Emacs, which is the basis for the majority of text editing and Lisp development.

 sudo apt-get install emacs-snapshot-gtk emacs-snapshot-el

Several version control systems:

 sudo apt-get install git-core git-doc git-gui git-svn subversion

Common Lisp implementations and support for its development:

 sudo apt-get install cl-swank cl-asdf common-lisp-controller sbcl sbcl-doc sbcl-source slime

Standard C++ development support (maybe I should install boost also).

 sudo apt-get install g++ g++-multilib gdb gdb-doc

Python 2.6 development environment (in the future I will probably install the latest Python 3.x also):

 sudo apt-get install idle-python2.6 python2.6-doc python2.6-examples

For future reference I leave here the log of the day when I picked and installed the tools for software development environment.

Commit Log for Fri Sep 18 00:25:50 2009

Installed the following packages: 
blt (2.4z-4.1) 
cl-asdf (1.111-1) 
cl-swank (1:20080223-2) 
common-lisp-controller (6.17) 
emacs-snapshot (1:20090320-1ubuntu1) 
emacs-snapshot-bin-common (1:20090320-1ubuntu1) 
emacs-snapshot-el (1:20090320-1ubuntu1) 
emacs-snapshot-gtk (1:20090320-1ubuntu1) 
g++ (4:4.3.3-1ubuntu1) 
g++-4.3 (4.3.3-5ubuntu4) 
g++-4.3-multilib (4.3.3-5ubuntu4) 
g++-multilib (4:4.3.3-1ubuntu1) 
gcc-4.3-multilib (4.3.3-5ubuntu4) 
gcc-multilib (4:4.3.3-1ubuntu1) 
gdb-doc (6.8-1) 
git-core (1:1.6.0.4-1ubuntu2) 
git-doc (1:1.6.0.4-1ubuntu2) 
git-gui (1:1.6.0.4-1ubuntu2) 
git-svn (1:1.6.0.4-1ubuntu2) 
gitk (1:1.6.0.4-1ubuntu2) 
glibc-doc (2.9-4ubuntu6) 
glibc-source (2.9-4ubuntu6) 
idle-python2.6 (2.6.2-0ubuntu1) 
lib64gcc1 (1:4.3.3-5ubuntu4) 
lib64gomp1 (4.3.3-5ubuntu4) 
lib64stdc++6 (4.3.3-5ubuntu4) 
libapr1 (1.2.12-5ubuntu0.1) 
libaprutil1 (1.2.12+dfsg-8ubuntu0.3) 
libc6-amd64 (2.9-4ubuntu6) 
libc6-dev-amd64 (2.9-4ubuntu6) 
libdigest-sha1-perl (2.11-2build2) 
liberror-perl (0.17-1) 
libpq5 (8.3.7-1) 
libstdc++6-4.3-dev (4.3.3-5ubuntu4) 
libsvn-perl (1.5.4dfsg1-1ubuntu2.1) 
libsvn1 (1.5.4dfsg1-1ubuntu2.1) 
python-tk (2.6.2-0ubuntu1) 
python2.6-doc (2.6.2-0ubuntu1) 
python2.6-examples (2.6.2-0ubuntu1) 
realpath (1.12) 
sbcl (1:1.0.18.0-2) 
sbcl-doc (1:1.0.18.0-2) 
sbcl-source (1:1.0.18.0-2) 
slime (1:20080223-2) 
subversion (1.5.4dfsg1-1ubuntu2.1) 
tcl (8.4.16-2) 
tcl8.4 (8.4.19-2) 
tcl8.5 (8.5.6-3) 
tk (8.4.16-2) 
tk8.4 (8.4.19-2) 
tk8.5 (8.5.6-3)

I have also some more software that currently is installed in my$HOME:

Sun JDK 1.6 – for Java development and building from source, which I currently use mainly for ArgoUML and Armed Bear Common Lisp (ABCL);
Eclipse Ganymede (Eclipse 3.4, TODO, update to Eclipse Galileo which is 3.5) – which I use for ArgoUML development;
PLT Scheme – to try out Scheme;
Second Interpreter of Scheme Code (SISC) – ditto;
ArgoUML – this is both installed and checked out from Subversion;
Armed Bear Common Lisp (ABCL) – a Common Lisp implementation for the JVM checked out from Subversion repository.

Installing Eeebuntu GNU/Linux 3.0 Standard on my Asus Eee PC 901

2009-09-21T10:00:00.004+01:00

I bought an Asus Eee PC 901 with an Asus customized xandros GNU/Linux distribution back in December 2008. I meant to switch to a more “normal” Debian based GNU/Linux distribution right from the start, but, my initial strategy was to use only the Asus Eee PC 901 to make the switch and I started having difficulties, so, this effort stalled for a couple of months. Now, I successfully made the switch to Eeebuntu GNU/Linux 3.0 Standard (which is based on Ubuntu GNU/Linux 9.04 Jaunty Jackalope, being Ubuntu GNU/Linux based on Debian GNU/Linux), and what follows is the successful recipe I used.

I bought a 4GB Kingston DataTraveler USB stick to place there the Eeebuntu GNU/Linux 3.0 Standard for installation.
In an old Compaq Presario 2500 laptop I used KNOPPIX 6.0 / ADRIANE 1.1 - Live CD (another Debian based GNU/Linux distribution) to:
1. rewrite the partition table of the USB stick as a single primary partition, using the bundled gParted;
2. format the USB stick as a FAT16 partition by issuing the command
  sudo mkfs.vfat -F 16 /dev/sda1
  (note that my USB stick was identified as sda, in another situation it may be different).
In the same notebook, using UNetbootin in Windows, I created a boot-able USB stick from the Eeebuntu GNU/Linux 3.0 Standard ISO image.
Finally, start-up the Eee PC 901, pressing Esc key to get into the boot device selection menu and choose the USB stick as the boot device. (Note that I changed the BIOS settings, disabling the fast boot and changing the boot priority order, although in retrospect I suspect this wasn't needed.)
Select the default option in the UNetbootin boot menu (still before Linux image in the USB stick starts or wait some seconds.
After the Eeebuntu GNU/Linux 3.0 Standard ISO image starts, double click the Install shortcut in the desktop.
The installation procedure is very simple, and I only made some complex decisions in the manual partitioning, having the following:
- /dev/sda – this is the master SDD disk with 3.75 GB of memory and it is faster than the secondary SDD disk. I partitioned it in two as follows:
  - /dev/sda1 – with a size of 2.88 GB contains all top folders (/ mount point), except linux-swap, /usr and /home;
  - /dev/sda2 – ~ 900 MB for linux-swap.
- /dev/sdb – this is the slave SDD disk with 15 GB of memory. I partitioned it in two as follows:
  - /dev/sdb1 – with a size of 6.22 GB, contains /usr;
  - /dev/sdb2 – with a size of 8.81 GB, contains /home.
I used ext4 file system for all the partitions (except linux-swap).

In retrospect I think that I would be able to do all the steps in the original Eee PC 901 with xandros, but, originally, in December 2008 I had an 8 GB USB stick for which a FAT16 file system isn't possible. Also, the xandros with which the Asus Eee PC 901 comes is based in an old Debian distribution and I wasn't able to execute UNetbootin in it.

I already made some customizations, like removing some programs and installing additional ones (I'm writing this in emacs-snapshot-gtk) and development libraries, but, I'll document this in a different post.

bash hints – for loops

2009-09-04T23:00:00.002+01:00

Today I had to process some files in a similar way in a bash shell. After trying using pipes, I reverted to for loops. First iterating for all files in a directory and extracting its contents (they were *.tar.bz2):

(...)/pcl-book/c23-spam/sa-pub-corpus> ls 
20030228_easy_ham_2.tar.bz2  20030228_hard_ham.tar.bz2  20030228_spam.tar.bz2 
20030228_easy_ham.tar.bz2    20030228_spam_2.tar.bz2
(...)/pcl-book/c23-spam/sa-pub-corpus> for f in *; do tar -xjf $f; done

Then, I discovered that the archives contained a file which I didn't wanted, so, I removed the files (the files were named “cmds”):

(...)/pcl-book/c23-spam/sa-pub-corpus> ls 
20030228_easy_ham_2.tar.bz2  20030228_hard_ham.tar.bz2  20030228_spam.tar.bz2  easy_ham_2/  spam/ 
20030228_easy_ham.tar.bz2    20030228_spam_2.tar.bz2    easy_ham/              hard_ham/    spam_2/
(...)/pcl-book/c23-spam/sa-pub-corpus> for f in `ls --ignore=2003*`; do `rm $f\cmds`; done

Some sw dev links

2009-08-30T23:00:00.000+01:00

Cédric Bouhours, Hervé Leblanc, Christian Percebois: "Bad smells in design and design patterns", in Journal of Object Technology, vol. 8, no. 3, May-June 2009, pp. 43-63 – Interesting paper regarding automated detection in UML models of opportunities for using design patterns.
Programmer Competency Matrix – A very complete and interesting list of competencies that a programmer must have with concrete ways to check in what level someone fits for each competency.
Douglas A. Lyon: "The Discrete Fourier Transform, Part 1", in Journal of Object Technology, vol. 8. no. 3, May-June 2009 pp. 17-26 – After reading this I was refreshed in the basic ideas behind the Fourier Transform. Previously I thought of solving the Rail-Fence Cipher problem based on a Fourier transform, but, now I think that what is needed is something different.
Debasish Kundu, Debasis Samanta: "A Novel Approach to Generating Test Cases from UML Activity Diagrams", in Journal of Object Technology, vol. 8, no. 3, May-June 2009, pp. 65-83 – Presentation of an approach to generate test cases from UML 2.x activity diagrams. It is mainly theoretical and considers coverage of loops and concurrency, providing an algorithm to generate paths in the generated activity graphs from the activity diagrams. This is somewhat related to my UML Unit idea.

Common Lisp dynamic variables

2009-05-07T08:00:00.003+01:00

One thing that Common Lisp has which is very powerfull is its dynamic variables. The following code ilustrates the concept:

CL-USER(124): (defvar *x* "Hello") ; *x* is a dynamic variable*X* 
CL-USER(125): (progn
                (let ((*x* "Ola")) ; establishes a dynamic environment for *x*
                  (format t "~a~%" *x*)
                  (setf *x* "Ciao")
                  (format t "~a~%" *x*)) ; end of the dynamic environment
                (format t "~a~%" *x*)) ; back to the initial dynamic environment
                                       ; *x* assumes its original binding 
Ola 
Ciao 
Hello 
NIL 
CL-USER(126):

Now if this is used with multiple processing and/or closures you get very powerful ways to separate things and a great amount of flexibility almost for nothing.

ArgoUML 0.28

2009-05-06T23:52:00.001+01:00

Some time ago ArgoUML 0.28 was released. This is a release that contains some new features and plenty of bug fixes. Please come aboard if you're still on land and give us some feedback via ArgoUML mailing lists, ArgoUML users' wiki band forums or via a bug or enhancement report.

Common Lisp hacking with ABCL

2009-05-06T23:51:00.004+01:00

I'm riding on a Linux Eee PC 901. For now I haven't installed a different distribution than the customized Xandros that comes with it... The freaking thing isn't booting from a FAT32 USB that I have...

So, and because the main flash drive is almost full, I don't have GCC to build a more mature Lisp. I'm therefore using Armed Bear Common Lisp (ABCL) for some entertainment hacking like solving Programming Praxis problems and reading Peter Seibel's Practical Common Lisp for a second time. ABCL has some quirkcs, like when I tried to build an SVN ccheckout with Sun's JDK 1.6, it had some compilation errors. Nothing serious, and, after some minutes, I was at the REPL in Emacs. For now I tested it with a basic subset of imperative and functional Lisp and it stood well. I wonder if someday I try to setup a Lisp REPL for ArgoUML with ABCL (check issue 3082: evaluating GEF support for template notation spike)...

Solution for Programming Praxis' Rail-Fence Cipher

2009-05-06T23:51:00.002+01:00

I found Programming Praxis via Planet Scheme. The following is my solution to the Rail-Fence Cipher problem in Common Lisp [check out the excelente Common Lisp tutorial by Peter Seibel for learning the language].

My solution doesn't follow the solution proposed in Programming Praxis, because, after looking at the proposal, I think there might be a way to express it more mathematical. With this I mean that what we have is a transformation via a discrete wave pattern. That sounded a bit familiar to fourier transformation. If so, if it can be expressed as such, maybe it would be the cleanest way to do it...

So, for now, the solution I present here is based in the straight-forward non-functional algorithm that one gets if analysing the problem as manipulating a string based on a ciclic list of indexes.

ArgoUML 0.26 enters alpha

2008-06-28T23:41:00.002+01:00

Recently ArgoUML 0.26.alpha1 was released. This is another step forward to a much anticipated ArgoUML 0.26. It contains some new things and one of these is the profile subsystem, to which I made a modest contribution.

I'm now working in priority 2 issues of the profile subsystem, which block the stable release. I'm also working in documenting this subsystem, first in the cookbook and then I'll do updates to the user manual. I hope I can still give a bit of of attention to the C++ module...

So, here is a list of things I would like to try to fix before 0.26:

issue #4994: Editing loaded profile should be prevented

ExplorerPopup.isRelatedToProfiles(Project, Object) is used to detect if a element is related to the profiles configured in the current project. In the same package is the support for drag-n-drop, class DnDExplorerTree, which method isValidDrag(TreePath destinationPath, Transferable tf) contains the validation of valid and invalid drags. We may make impossible for profile model elements to be dragged by checking if the Transferable contents contain profile model elements. On the other hand, this would make it impossible to add a profile contained model element to a diagram and this would limit the usefulness of the profiles. FigNodeModelElement is the base class of many of the model element figures in the diagrams. Here the are two things needed: disable the menus that can modify the model element and disable the editability of the model element in-place. Such as the editing of names.
issue #5017: profile model elements are absent from diagrams on reload
issue #4991: Profiles subsystem missing in the cookbook
issue #4992 – this is the one related to the update of the user manual for inclusion of the profile related functionality
issue #3771: Add tag definitions for tags used by the cpp generator – for this it is only needed to update the user manual to reflect the usage of the UML profile for C++ instead of the previous way of copying into the model the model elements of the included profile.

issue #27 of argouml-cpp: anarres-cpp: dependencies caused ArgoUML loading failure – I thought I had fixed this, but, in 0.26.alpha1 there is still the following warning:

 2008-06-27 19:17:48,526 ERROR: Unable to find required class while
      loading org.anarres.cpp.Main$Option - may indicate an obsolete
      extension module or an unresolved dependency (ModuleLoader2.java:719) 
java.lang.NoClassDefFoundError: gnu/getopt/LongOpt at 
java.lang.ClassLoader.defineClass1(Native Method) at 
java.lang.ClassLoader.defineClass(Unknown Source) at 
java.security.SecureClassLoader.defineClass(Unknown Source) at 
java.net.URLClassLoader.defineClass(Unknown Source) at 
java.net.URLClassLoader.access$000(Unknown Source) at 
java.net.URLClassLoader$1.run(Unknown Source) at 
java.security.AccessController.doPrivileged(Native Method) at 
java.net.URLClassLoader.findClass(Unknown Source) at 
java.lang.ClassLoader.loadClass(Unknown Source) at 
sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source) at 
java.lang.ClassLoader.loadClass(Unknown Source) at 
java.lang.ClassLoader.loadClass(Unknown Source) at 
org.argouml.moduleloader.ModuleLoader2.addClass(ModuleLoader2.java:714) at 
org.argouml.moduleloader.ModuleLoader2.processEntry(ModuleLoader2.java:680) at 
org.argouml.moduleloader.ModuleLoader2.processJarFile(ModuleLoader2.java:614) at 
org.argouml.moduleloader.ModuleLoader2.huntModulesFromNamedDirectory(ModuleLoader2.java:554) at 
org.argouml.moduleloader.ModuleLoader2.huntForModulesFromExtensionDir(ModuleLoader2.java:512) at 
org.argouml.moduleloader.ModuleLoader2.huntForModules(ModuleLoader2.java:435) at 
org.argouml.moduleloader.ModuleLoader2.doInternal(ModuleLoader2.java:311) at 
org.argouml.moduleloader.ModuleLoader2.doLoad(ModuleLoader2.java:164) at 
org.argouml.moduleloader.InitModuleLoader.init(InitModuleLoader.java:55) at 
org.argouml.application.SubsystemUtility.initSubsystem(SubsystemUtility.java:49) at
org.argouml.application.Main.initializeSubsystems(Main.java:430) at 
org.argouml.application.Main.main(Main.java:169) Caused by: 
java.lang.ClassNotFoundException: gnu.getopt.LongOpt at 
java.net.URLClassLoader$1.run(Unknown Source) at 
java.security.AccessController.doPrivileged(Native Method) at 
java.net.URLClassLoader.findClass(Unknown Source) at 
java.lang.ClassLoader.loadClass(Unknown Source) at 
sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source) at 
java.lang.ClassLoader.loadClass(Unknown Source) at 
java.lang.ClassLoader.loadClassInternal(Unknown Source) ... 24 more 2008-06-27 
19:17:48,546 ERROR: Failed to find any loadable ArgoUML modules in      jar 
X:\ArgoUML\0.26.ALPHA_1\ext\anarres-cpp-no-dependencies-1.2.3.jar     (ModuleLoader2.java:627)

There is a problem in JCPP from anarres that it doesn't close the files when the contained CppReader is told to close itself. This is causing 5 tests in argouml-cpp to fail with an error, when the tearDown() is trying to delete the files.
There are some more argouml-cpp issues I would like to solve, but, this is a fair cry...

Google Summer of Code 2008

2008-06-28T23:38:00.002+01:00

I'm a Google Summer of Code 2008 mentor for ArgoUML. It is fun and, as stated over and over, one learns a lot by teaching and in my case mentoring.

The student I'm mentoring is Bogdan Szanto and he is working in fixing diagram usability issues. This includes fixing some existing problems and adding new features, that hopefully will make ArgoUML users happier.

Bogdan already helped fix some problems found in the new sequence diagrams implementation – argouml-core-diagrams-sequence2. I was a bit late in this game, because he started working in this during the community bonding period and we both wanted him to “bond” with other developers than me. But, now it is long finished and I started supporting his work directly by reviewing patches and testing code and learning about the specifics of the implementation. So, while I was debugging I found the following issues that must go into the DB:

Summary: Broom causes ClassCastException when used in a seq2 diagram that contains a Note “connected” to a ClassifierRole

ModeBroomMessages thinks that all edges in the diagram are messages, but, there can be connections between Notes and ClassifierRoles. The following exception happens when the Broom is used in a seq2 diagram that contains a Note “connected” to a classifier role:
```
 java.lang.ClassCastException: org.argouml.uml.diagram.static_structure.ui.FigEdgeNote
 at org.argouml.uml.diagram.sequence2.ui.ModeBroomMessages.getAllFigMessages(ModeBroomMessages.java:198)
 at org.argouml.uml.diagram.sequence2.ui.ModeBroomMessages.getAllFigMessagesDownward(ModeBroomMessages.java:177)
```
Summary: destroy action cleans the lifeline of the caller

When a destroy action is created between two classifier roles, the lifeline of the caller becomes fully dashed. I think that the opposite shouldn't also occur, but, that the lifeline of the callee either should become dashed from the point where the message arrives onward or that it should finish there (preferable).

See the attached figure “destroy-action-clears-lifeline-of-caller.png”.
Summary: selected create Action + “Alt” key cause repositioning of created CR

When you draw a create Action between two classifier roles, leaving it selected, and, afterwards press the “Alt” key, the created CR is repositioned in the top position. If the create Action isn't selected this problem doesn't occur.

Resolving and persisting profile references

2008-04-05T15:08:00.000+01:00

In the context of issue 4946 (Loading project which references non-default profile doesn't work) I needed to make some design changes to the profile sub-system and to the MDR implementation of the model sub-system of ArgoUML. At first I used what I now see as a brute force approach, banging the existing code to try to make the problem go away. I'm glad it didn't worked and I started thinking and designing my way out of this priority 1 bug.

Basically the problem aroused when we tried to finish the profile sub-system to have a developer release of ArgoUML, the release 0.25.5. Originally the UML profile for C++ was contained in the ArgoUML core. There were two types of profiles:

ArgoUML core profiles – these are XMI files contained in ArgoUML, being physically part of the argouml.jar.
User defined profiles – these are XMI files saved by the user, which he intends to use as his own profiles, normally for reusing in several models.

It was agreed that part of the work would be to enable the language modules to contain the corresponding profiles, and as such I tried to put the C++ profile in the ArgoUML C++ module. So, ArgoUML would now have three types of profiles:

code profiles;
module profiles;
user defined profiles.

Now I need to explain the idea of resolving references when loading XMI files...

A XMI file is a XML file. Being so, it is possible to make a reference from one XMI file to another and this is how in the future ArgoUML you can have a model and several profiles referenced from this model. But, the references take the form of URL#ID, being the URL the reference to a different XMI file where there must exist a definition of a model element with the identifier ID.

To enable offline work in the case of core and module profiles and flexible user defined profile directories locations in the case of user defined profiles, you need to add a midle man resolving these beautiful URLs to system paths - enter the XmiReferenceResolverImpl.

The XmiReferenceResolverImpl was based on the AndroMDA code that did the same thing. It has some complex code that is able to resolve a reference from the net, local disk or even in the classpath. But, the resolving of a reference to a profile was hard coded, being the base URL and the base system path constants of XmiReferenceResolverImpl.

So, when the C++ profile was moved, the reference resolving didn't worked any longer for it since its system reference was now different. It broke the initial solution of having the reference resolving somehow hard coded in the MDR model implementation.

I tried very much to make it work again, doing some more hard coding in the profile loading side and in the MDR implementation side:

[2008-01-28 to 2008-02-05] Hack, hack, debug, debug, and I made the C++ profile module work :-)
[2008-02-26 to 2008-03-04] Hack, hack, debug, debug, hack, hack and the user profiles work too :-))
[2008-03-??] But wait, my automated test for the C++ profile persistency is now failing :-(
[2008-03-?? to 2008-03-23] Debug, debuug, hack, haaack...
[2008-03-24] Stop! Think a bit, and think a bit more and... This design for resolving references is broken.

So, I went back to the drawing board and started thinking a bit on what is required to enable the reference resolving that we needed. There were some lessons learned:

the XmiReferenceResolverImpl must not have hard coded base URLs and base system paths to resolve the profiles references;
when the XMI for a profile is read, the XmiReferenceResolverImpl must replace the given system reference with a public reference which is handed to it;
the best place to know about what are the system and public references for a given XMI is the place where the call to load the XMI is done.

Enter the ProfileReference, although, as Marcos Aurélio commented, it would better to be called ModelReference.

Picture 7 – ProfileReference class diagram.

As seen, to enable DRY, I added the CoreProfileReference and the UserProfileReference, but, the language modules will in principle use directly the ProfileReference, or define their own XxxProfileReference. The ProfileModelLoader.loadModel(String path) method is deprecated and the ProfileModelLoader.loadModel(ProfileReference reference) replaces it.

But, now, how do I get all these neat references into the realm of XmiReferenceResolverImpl? Well, some more design and I hope the ArgoUML powered sequence diagram of the interesting part of loading a profile XMI explains it.

Picture 7 – profile loading sequence diagram.

As with many sequence diagrams, I only kept the important steps, but, one significant is that there is a map of public to system references involved, which is kept at the MDRModelImplementation level. And this is important, since the XmiReferenceResolverImpl and its creator, the XmiReaderImpl are short lived - they are only kept around while the XMI is being loaded.

So, when I find myself working very hard at the debugger and hacking cycle I will try to stop and think. I recall already having stated this to myself some time ago, but, sometimes I forget this kind of things for which there is nothing like a bump with the head (or several as in this case) for one to remember the basics again ;-)

ArgoUML's repository restructuring

2008-03-08T15:21:00.000Z

ArgoUML core is undertaking a repository restructuring and I'm working in adapting the argouml-cpp build to the new structure.Issue 4625 is where the requirements for the changes are documented and there has been some dev mailing list activity on this. Linus Tolke is heading the effort.

We want to keep two build mechanisms:

Plain Ant build via command line and without eclipse.
eclipse based build, being the idea for this to make easier for new contributors to start.

I have been adapting the Ant build file to the new structure, but, I had some problems with making it work for both purposes. The big issue is to generate the source files from the ANTLR grammar. In the end we figured out a good way to do it and it is now documented in the ArgoUML cookbook.

Distributed version control systems

2008-03-08T15:19:00.000Z

Recently I had to use Mercurial to checkout the NetBeans sources. Well, since the instructions were for the whole NetBeans repository, I followed them and I have a local checkout of it. Now NetBeans is big, so, you could think it would take me some hours to get the whole thing, even more, if you consider that it clones the whole repository with the full history. No, it was surprisingly fast and its command line interface is very easy to use.

Alas, I have currently no project where this or other distributed SCMs are used, but, when I get a break from ArgoUML and start experimenting with open source projects from common-lisp.net I'll have a good change that they'll be darcs based.

Debugging model-mdr

2008-03-08T15:14:00.000Z

In the past 2 months I have been in and out working with other persons to fix the problems in the ArgoUML's subsystem model-mdr (see issue #4946). This is a core part of the ArgoUML implementation and it basically wraps NetBeans MDR into an implementation of the ArgoUML model subsystem.

MDR is based in JMI (a standard from the Java Community Process), which is itself based in MOF (a standard from OMG). I was more or less familiar with the ideas behind MOF, but, as always, the devil is in the details and I'm now reading the standard so that I'm not bumping so much on problems.

My lack of knowledge about MOF was made worse by the sources of the several jars from MDR not being included in the ArgoUML repository. Also, unusual for open source projects MDR doesn't make it available as a download - you must checkout the sources with Mercurial (more on this latter) or CVS. Even so, it doesn't contain the sources for jmi.jar and mof.jar. The MOF and JMI standards don't have a zipped javadoc to help when you bump into unexpected problems in the debugger. All this is making the whole exercise harder than needed!

TODO: get my hands on the jmi.jar and mof.jar sources!

2007-12-05

2007-12-05T01:22:00.000Z

I'm working now on issue #4923 and this requires some measurements of the time the automated headless tests take to run. Thanks to Linus' efforts in setting up a continuous integration server this isn't very difficult, I will simply take the latests 10 results from the revisions of the JUnit reports summary and compare them with the next 10 results after making my change in the model-mdr implementation.

So, here are the values and the total average before the change:

Before changes, Java 5 tests.
revision	Tests	Failures	Errors	Success rate	Time (s)
rev=4456	1115	1	0	99.91%	3065.731
rev=4443	1115	1	0	99.91%	2921.652
rev=4431	1115	1	0	99.91%	2899.956
rev=4408	1117	2	0	99.82%	2792.906
rev=4392	1116	3	0	99.73%	2789.595
rev=4378	1116	0	0	100.00%	2866.223
rev=4367	1116	0	0	100.00%	2842.319
rev=4355	1117	0	0	100.00%	2861.930
rev=4345	1117	0	0	100.00%	2887.080
rev=4340	1101	0	0	100.00%	2787.845
Average time:					2871.524

Before changes, Java 6 tests.
revision	Tests	Failures	Errors	Success rate	Time (s)
4462	1115	1	0	99.91%	2715.539
4448	1115	1	0	99.91%	2665.635
4437	1115	1	0	99.91%	2665.288
4400	1116	3	0	99.73%	2526.352
4383	1116	0	0	100.00%	2627.562
4372	1116	0	0	100.00%	2596.418
4360	1117	0	0	100.00%	2651.676
4350	1117	0	0	100.00%	2654.227
4332	1101	0	0	100.00%	2514.612
4318	1101	0	0	100.00%	2509.551
Average time:					2612.686

Tomorrow I'll make tests with ArgoUML running to check if the MDRModelImplementation constructor is called during its execution and if not I'll commit my changes to MDR. Then, it is a matter of waiting 10 days for the veredict of the performance hit.

Update on 2007-12-19: added averages and results after changes.

Afer changes, Java 5 tests.
revision	Tests	Failures	Errors	Success rate	Time (s)
4611	1116	0	0	100.00%	2910.440
4594	1116	0	0	100.00%	2917.587
4581	1116	0	0	100.00%	2905.284
4570	1116	0	0	100.00%	2903.603
4559	1116	0	0	100.00%	2898.110
4546	1116	0	0	100.00%	2909.500
4533	1115	0	0	100.00%	2906.624
4521	1115	0	0	100.00%	2904.351
4508	1115	0	0	100.00%	2939.427
4496	1115	0	0	100.00%	2903.854
Average time:					2909.88

Afer changes, Java 6 tests.
revision	Tests	Failures	Errors	Success rate	Time (s)
4586	1116	0	0	100.00%	2665.922
4575	1116	0	0	100.00%	2665.115
4564	1116	0	0	100.00%	2660.793
4552	1116	0	0	100.00%	2677.356
4538	1115	0	0	100.00%	2668.918
4526	1115	0	0	100.00%	2677.958
4514	1115	0	0	100.00%	2699.183
4501	1115	0	0	100.00%	2687.672
4488	1115	0	0	100.00%	2630.221
4474	1115	1	0	99.91%	2757.297
Average time:					2679.04

So, a ~2.5% performance hit in Java 6 and a ~1.3% hit under Java 5.

2007-11-19

2007-11-19T08:00:00.000Z

While I was testing a patch by Lukasz Gromanowski, found a bug in org.argouml.ui.SettingsDialog. This one is interesting. The contract established by GUISettingsTabInterface is that implementers will be called when the user saves the configurations. But, that wasn't happening for SettingsTabCpp. After some debugging and seeing the bug in my front several times I finally understood.SettingsTabCpp does not extend JPanel and the SettingsDialog was only invoking the callback methods of tabs contained by its component tabs (an object of type JTabbedPane), which were of type GUISettingsTabInterface.

My promotion to core developer

2007-11-12T23:50:00.000Z

I was promoted to core developer by Linus Tolke and I believe in agreement with the other active core developers – Bob Tarling, Michiel van der Wulp and Tom Morris. I'm very happy about this and it will be motivating to start working more often in the core of ArgoUML.

Tom sent a very warm welcome message to the developers mailing list. Specifically for my part he refers two features I'm keen to get involved into, the profiles and the support for parameterized classes and UML templates in general. Well, I was already involved, but, now I'm much more motivated to work directly in the core to advance these two features. These are central for ArgoUML to be a good basis for C++ model driven development, which will continue to be my main focus for the future.

Refactoring org.argouml.uml.profile

2007-11-12T23:45:00.000Z

As stated in issue #4885 and in the dev mailing list thread "org.argouml.uml.profile - success in working from models and improvement proposals", I'm working in refactoring the profile sub-subsystem of ArgoUML so that it is possible for modules to define their own profiles. The main problem to get rid of is that there are singletons in it, such as the ProfileManagerImpl. This class is a singleton and besides some very few exceptions singletons are an abused design pattern. More so in Java projects, since Java doesn't support global variables and, guess what, a singleton is a replacement of the humble global variable, even if it is very clumsy and pernicious.

Before proceeding with my rambling about singletons being bad, let me say that I'm very happy with the work contributed by Marcos Aurélio, one of the developers that joined in the Google Summer of Code 2007. The package org.argouml.uml.profile is congruent, being absent of monster classes and methods, with a nice balance between abstractness and implementation classes and with a very pleasant distribution of responsibilities amongst the classes. Furthermore, so far I haven't found a single defect!

The refactoring will be much more easy than what I will have to do to improve the GeneratorCpp – which is a singleton :-( ... and that bring us back to my rambling...

Singletons are clumsy, because instead of one line of code declaring a variable at global scope¹, one line initializing it in some appropriate place of your code and a direct reference from where you want to access it, you now have to define a private constructor, a static accessor method and then, call this method from wherever you need to access it from. It is pernicious because if you wanted to abstract the implementation of the global variable, it won't be possible – every single user object will now refer to the singleton class directly, even if they don't need to, because one of their owners or more closely related objects could have provided it themselves. Another bad effect is that when eventually the application evolves and you would like to have more than one of those objects, or to have a fresh one for another piece of work or for unit testing, you'll have the singleton and the singleton accessing code stopping you from doing it.

Today I found yet another pernicious effect – loss of control of initialization order. In my checked out copy I have made a spike to check if the plan of having the C++ module providing the UML profile for C++ would work based on the recently contributed support provided by Marcos Aurélio. So, in C++ module I have defined a new ModuleInterface implementation that registers a ProfileCpp object in the ProfileManagerImpl instance. Now, guess who is now instantiating indirectly both ProjectManager and ProfileManagerImpl? Yeah, the humble C++ module or better indirectly the ModuleLoader2 is doing it! Worst, while at it, I noticed that the order of initialization of modules by ModuleLoader2 seams to be arbitrary. Because SettingsCpp is also loaded as a module, and it accesses the GUI instance, this will also be initialized not by the Main.main in an explicit way, but, indirectly by the SettingsCpp module.

Isn't this bad?!?

The way to solve this is via explicit initialization of subsystems and subsystems which keep the details for themselves. The best example is the org.argouml.model subsystem. It provides means for explicit initialization and access to it is via static functions of the Model class.

Alas, the Profile subsystem may not need to have several implementations as required from the Model subsystem, so, I won't restrict its implementation so much, such as having only interfaces available for clients, but, I think it will be easier to use and maintain if it looses some of its singletonitis. Check the ideas in issue #4885 and please send some feedback if you have ideas on how to deal with this differently.

¹ In modern programming languages, "global variables" aren't normally global anymore, since normally they are contained in a specific package or namespace. A pair of good examples is the java.lang.System in Java and std::cout in C++. These "globals" aren't frown at and the libraries were design by developers above the average for sure, so, why is an accessible variable so bad?!?

Uff! I finished the GeneratorCpp feature sketch

2007-10-03T22:43:00.001+01:00

Previously I stated that I wanted to refactor the GeneratorCpp class. A good way would be to use some techniques I learned from Working Effectively with Legacy Code by Michael Feathers (2004), particularly, his feature sketches. Well, I worked hard to put the whole class under scrutiny and the result is very depressing (see bellow). Very different from the ones Michael has in his blog post.

Note that I used rectangles for functions and ellipses for variables. This is exactly the opposite from the convention Michael uses in his feature diagrams. My diagram is made in OpenOffice.org Draw and I had to use a A2 page so that everything could fit in a single one. I like this approach because, although it is harder to draw in the first place, when you have it you may drag things, group and ungroup, etc. This is important to identify and make clear the clusters that may be extracted from the monster with less pain. I put it in argouml-cpp doc directory, so, if you get curious, try it out.

Picture 6 – Feature sketch of GeneratorCpp. Rectangles are for methods, ellipses for variables, blue for non-static and red for static. The yellow rectangle to the left denotes a cluster of methods that could easily be extracted, the yellow rectangle in the bottom center contains the methods I wanted to extract related to Associations, but, which are hard to extract from the class.

Don't misunderstand me, feature sketches are one more good thing that I will add to my tool box, but, they must be complemented with other things Michael talks about in his book, such as identifying responsibilities. This is more important if you are dealing with a monster class such as this. Nevertheless, the feature sketch enabled me to see the clusters in the class. Even more important, while I was doing it I reviewed the code in a way I never did before – actually this was the first time I looked at it from start to end. There are variables that keep pure processing state or context (generatorPass and actualNamespace), others that are mostly read and that keep configuration editable by users (e.g., indent, lfBeforeCurly, verboseDocs) and others that store processing results, which are used to generate code that deals with dependencies (e.g., includeCls, predeclCls, systemInc, extInc and localInc).

As a bonus I discovered some non-documented features of the generator that might come handy to solve some issues that are mounting up in the issues list. For instance, issue #22: provide a tagged value for user includes with angle brackets is handled by method addUserHeaders if the user places either in source_incl or header_incl tagged values the header name within angle brackets.

Refactoring GeneratorCpp

2007-09-17T23:43:00.000+01:00

The GeneratorCpp class contains almost all the code that is used to provide C++ code generation in the C++ module. The file is over 2900 lines! It will start to get even worst since the support for C++ notation will reuse it, so, we might need to add even more code to it.

It is a monster class. I know that the responsibility of that class is generating C++ code from a UML model. So, a distant observer could say that this respects the Single Responsibility Principle (SRP). But that would be like saying that log4j could be implemented in a single class because it is software that has the responsibility to support logging.

I read the book Working Effectively with Legacy Code by Michael Feathers (2004) and there he describes very useful techniques on how to refactor such code. I'll apply the feature sketch in my current task, where I have to fix a bug related to the way the generator deals with associations, in order to extract some of the methods into a separate class. Then, I'm planning to test if the result is friendly from the perspective of client code from the notation package.

But, before starting to apply a specific technique, I must reason about the responsibilities of the C++ generator. Follows a – probably incomplete – list:

conversion of the UML constructs into C++ equivalent code
- operations and methods
- attributes
- packages
- associations – includes aggregations, compositions, generalizations
documentation
tagged values
coordination of the code generation for a class
C++ notation support
indentation
generation of header files
generation of source files

Many of these responsibilities interact and depend on each other. Because it is all contained in one class, all is getting mangled into a huge mess, although I can understand that it seams easier this way, I also think that this is simply at the surface.

My idea for now is too separate the aggregation and composition parts from the rest. But, it is difficult because there are parts in the methods that deal with these two things that also deal with indentation and documentation. This is messy because when I'm generating code I want it to use the indentation options selected by the user, but, when I'm providing C++ notation support I want them not to indent things and not to insert C++ headers into the required headers list. So, I'll look at the methods that support these things and use the feature sketch technique to understand how to isolate some parts.

New job and Common Lisp

2007-05-12T23:47:00.000+01:00

I recently started in a new job where we use Common Lisp as the programming language for all the core work. The company is SISCOG and it sells software for planning the Human Resources of train companies. In SISCOG they provided an intense 3 weeks course on Common Lisp, but, due to legal and project schedule constraints in my previous work at Nokia Siemens Networks, I only participated in the last day of the course. So, now, I'm learning on the job and by my own in my free time. I'm reading Practical Common Lisp, using Lisp in a box, and Franz's Allegro CL and it is going alright.

Because I was used to developing in Python I'm not finding so hard to get used to Common Lisp, even with the very different syntax. The main thing is being used to working in a dynamic language. Ah, and the Lisp prompt – or REPL in Lisp terms – is very good.

The hard thing is to get used to the libraries and toolset to the point where I'm so productive as I was in my previous environment (Java and Eclipse). Now I'm using emacs as the editor and Allegro/emacs as the IDE. Besides the GUI framework that comes with Allegro, everything is internal to SISCOG, so, I have a lot to learn. And from my previous experience, the best way to do it effectivelly is by participation in an open source project. There you normally get into contact to the best software engineering practices and best user / developers relationship that is possible. So, I already looked around and my two candidates for now are:

Maxima – a computer algebra system.
Closer – contains a framework for Aspect Oriented Programming in Common Lisp.

Past and near future development activities in the C++ module

2007-04-29T23:00:00.000+01:00

I didn't progressed much in the development of the C++ module during 2006. It was a fire fighting year in terms of my day to day job and I invested a lot of time and energy in getting the fire down and (IMHO) trying to get a rightfully deserved raise in salary. Alas, I'm now in a different job, but, lets talk about the progresses (humble, but, nevertheless some) in the C++ module...

The main problem I worked on was the fact that the C++ notation was gone by mid of the previous year. I think that in ArgoUML 0.22 it wasn't available. So, I worked on fixing it for ArgoUML 0.24 because I hate regressions!

Some minor bugs were found (4, 5, 6, 7, 4541), some of them were fixed (5, 6), there is a request for enumeration support (not yet done), etc.

Now, my main focus is in getting an old issue fixed and unify the handling of special TaggedValues in the generator and reveng modules into the UML profile for C++. This is turning out to be easier than I expected due to the improvements introduced during the last year into the model sub-system. I'll simply put the UML profile for C++ (UMLprof4C++) into the C++ module jar, load it into a separate model and use its services from the generator, reveng and ui modules.

Many hard coded values for TaggedValue names are going away, the code of generator and reveng modules will deal with similar problems by using common services and the users will have an easy way to import the full UMLprof4C++ Stereotypes from the C++ Settings. And I think that now that I have more energy to devote to ArgoUML this will be available for 0.26.

Improving the usability of htmled

2007-04-29T22:46:00.000+01:00

I have to improve the usability of my htmled Python module! Currently I have to do something like this:

>>> from htmled import *
>>> hbf = HbFile(open("c:/luis/documentos/cadernos/programacao/ficheiro04.html"))
>>> pe = PostExtractor(hbf)
>>> from datetime import date
>>> posts = pe.getPosts(date(2006, 12, 1), date(2007, 5, 1))
>>> print posts[0]
### here a pretty print of post 0, easy to copy paste into Blogger will be available
>>> print posts[1]
### ditto for post 1

I'm not very put off by having the python shell as UI. It is comfortable for me and I like its feeling as much as other more normal persons like their GUI applications such as ArgoUML. But, there are some things which I could easily optimize such as not having to write the name of the Handbook File, just select which Handbook I want to make blog posts from. Another thing is to have the posts immediately available for selection with an easier way to specify.

In addition there is a nasty bug in the parser, which includes the original Handbook File footer into the last post. These are sufficient reasons for an additional iteration on htmled. I'll plan for it as soon as I finish some stuff in the ArgoUML C++ module I've been working on in the past weeks.

Argonaut's life lost its images

2007-04-26T23:45:00.000+01:00

My previous e-mail and static web hosting provider (zmail) was discontinued by its parent company Zsystems.It was a pitty because at the time it actually worked, they were ahead of Google in what concerns advanced functionality – 10 GB of space for shared services such as e-mail, static web hosting, XFTP (important in Portugal because the internet service providers have international traffic ceilings).It seamed to me that they even had some non-portuguese customers paying 12 euros per year.

It is a common lack of vision and courage over here not to invest in such a popular and front runner service.They probably were a bit scared when Google started to be a no-cost competitor, but, for a person like me their service offering isn't yet equaled by Google or by any other service provider...

Alas, now the Argonaut's life blog has no pictures. I'm considering my options for placement of this kind of content, but, I would like to improve my online presence a bit, like having a CV online as well as references to this blog.

So, if you were wondering why these pages have no carefully crafted diagrams from ArgoUML, here, you now know why!

Making icons for ArgoUML

2007-04-26T23:30:00.000+01:00

This entry comes a lot after the fact, but, nevertheless, it contains important details on how to get good icons for the ArgoUML GUI.Thanks to Michiel van der Wulp for supporting me on this work with icons in specific and implementing the C++ Notation in general.By mid of 2006 I detected that the C++ notation wasn't working no more in the ArgoUML diagrams and created issue #2 in the C++ module issues DB.The whole Notation sub-system was refactored by Michiel and the C++ module had to adapt.So, to make a long story short, I needed to create an icon for the C++ notation as part of the work and what follows is a recipe on how to do it:

Note: these instructions are for Windows. If you're on Linux, you'll have to look elsewhere.

Start from one of the icons stored in the Images directory of the source code.
Using MS Paint, you'll draw the icon according to your artistic capabilities. For this you'll have easier time by using gigantic zoom like 800%.
Then, use IrfanView to reduce the color depth to 4 colors and to set the transparent colour.

But, if you want to see the whole story of having Notation icons working from ArgoUML modules, you'll have to use the a different loading code than what is used in core argouml code. Please check the code in NotationModuleCpp.java.

I hope this tiny cookbook helps others and avoids core developers having to answer to trivial questions again. And once more, all credit besides writing this tutorial goes to Michiel, who helped me a lot while I was doing this.

ArgoUML and OpenUsability

2006-11-06T23:32:00.000Z

I found out about the OpenUsability initiative in one of the ThoughtWorks blogs – Josh Evnin's– and immediately proposed it for ArgoUML. Linus finds this a good idea and I'm going to act now as a proxy between ArgoUML and OpenUsability.This is somewhat more work, but, due to one reason and another I'm getting much more sensitive to this whole usability issue and it is growing in importance in my internal priority queue.

One reason is due to my current work, where I'm working in the development of a planning tool for WDM networks. For historical reasons the usability wasn't a concern in the beginning and it continued to be so for a while (years) until the negative feedback from the users started hitting the development project. One of the issues is the lack of Undo\Redo capability, which is also a problem in ArgoUML.

Another reason is that I'm reaching a time in my professional life where I've been sufficiently exposed to good and nice to use user interfaces and bad ones to give this usability issue the importance it deserves. I now see and understand that usability isn't only about GUIs. Quite the contrary, usability may reveal itself in a command line interface, a library API and whatever is the interface to the users of some given software deliverable.

An example was shown to me just some minutes ago, when I tried to automate the build steps in the Windows shell. I have a batch file which fails to do what I ask and simply doesn't provide any help! That's a bad user interface and I just got hit... I tried to fix it by trial and error to quit and switch to the cygwin environment, where AFAIK these things work better.This is what usability is all about, helping our users to solve their problems in using our software.It is THAT important!

The root cause for some software to be bad to its users is lack of a user oriented attitude of the development project.I've found some of the signals of this to be:

The management doesn't use the software and its attitude is more oriented to fulfilling the contract and process than to actually help the users to fulfill their objectives.
The developers don't have a global concern for the usability of the application, being more preoccupied with their little small component than to the emerging consistency of the user interface of the application. [Frederick P. Brooks in his "The Mythical Man-Month" book, chapter 9, page 100 of the 20th anniversary edition, says Fostering a total-system, user-oriented attitude may well be the most important function of the programming manager.] You may check it by the way the application provides error information and the differences in behavior from one functional area to another.
The development process doesn't include steps where feedback is gathered from the users. They only get access to the software when the development project thinks it is finished or they get it sooner, but, with a whole list of disclaimers basically stating that if it gets out of the box and bites your head off bad luck for you. It doesn't include a polite message asking for feedback from users and how they can do it.
Direct contact between the development team and users of the software is discouraged, unless explicitly organized and carefully controlled by the management.
There is no access (or it is relatively hard to get it) to the bug and issues list. There are no users forums and no FAQ.

I think that one of the positive things of the agile manifesto is the focus on providing value to the users and fostering conversation and collaboration. I contrast this with the typical silo approach of the majority of the development projects in the industry, where there are a bunch of persons who are allowed to interact with the users. These screen out direct communication, not because it affects negatively the productivity of the persons developing the work, but, because it enables "better" control of the user/client interaction.

It isn't something that only the development side must work out, also it is common that the user side has the tendency to get inside info from informal communication channels and use it for finger pointing and contract revoking, so, this new old way of working requires maturity and good common sense from both sides.

Automating the svn update and build process of ArgoUML

2006-11-06T08:28:00.000Z

As for the majority of persons working in open source projects I get to work only some 2 or 3 hours in ArgoUML at a time. When I start working I like to get up-to-date with the current trunk of ArgoUML and its projects. This is a process that takes normally about 20 minutes and includes:

svn update of all checked out projects of ArgoUML
build and run the tests of all relevant (for me) projects
check the results and fix problems (this isn't needed normally :-))

The first and second steps are easy to automate, just create shell scripts that contains the individual updates and build commands.

<dir_for_co>\svnupdt.bat:

svn update argoeclipse
svn update argouml
svn update argouml-andromda
svn update argouml-classfile
svn update argouml-cpp
svn update argouml-csharp
svn update argouml-gen
svn update argouml-idl
svn update argouml-python

<dir_for_co>\build.bat [Note that this isn't working yet, help would be appreciated!]:

cd argouml\src_new
build package alltests
cd ..\..\argouml-cpp [fails here, this step isn't executed]
build tests
cd ..

2006-11-02

2006-11-02T23:32:00.000Z

I've finally been able to restart working in ArgoUML! The module is in the new Subversion repository, and I tried to follow the instructions to checkout with eclipse. It was after several failures that I got back to the good old command line and in 1:30 hours it was checkout (argouml and argouml-cpp) with my tigris user, built and unit tested.Here follows the steps:

<dir_for_co>>svn co --username USER --password PASS http://argouml.tigris.org/svn/argouml/trunk argouml
<dir_for_co>>svn co --username USER --password PASS http://argouml-cpp.tigris.org/svn/argouml-cpp/trunk argouml-cpp
<dir_for_co>>cd argouml\src_new
<dir_for_co>argouml\src_new>build package
<dir_for_co>argouml\src_new>cd ..\..\argouml-cpp
<dir_for_co>argouml-cpp\>ant tests

Then point your browser to file:///<dir_for_co>/argouml-cpp/build/tests/reports/html/index.html and check if all is well. Note that I had to use Ant directly, because there is something wrong for me in the way the BAT files are working.

On Algorithms

2006-10-06T23:51:00.000+01:00

Almost after 4 months of silence its time to get back at taking notes about ArgoUML and my adventures in software development. I'll do a retrospective on what I've been doing another time. Currently I want to document one very interesting thing that is common knowledge, but, that have reveal to me again today. Don't optimize without having measurements before. Or stated in its full glory: Premature optimization is the root of all evil.

I was working in solving one of the Google Code Jam 2006 excercises. –If you are curious I was very unsuccessful in my attempt to solve this in the one hour they give you to solve. – It is the SquareCounting problem and I tried to solve it in Java, in a Test Driven Development way. After my failure to provide anything near a solution to the problem, I kept trying to solve it and I think that now I have a solution and I was making some simple efficiency measures to check what was the performance of my solution according to the Big O notation.

After having this setup and with 10 different measures, I started making a very simple change that I thought would bring immediate improvements. Alas, it made it worst by a factor of 3 for some cases! I'm very happy to have started measuring before any changes. So, now have a personal experience backing the idea that premature optimization is evil.

My solution doesn't use any linear algebra ideas, but, I think it should. The thing is, now I have the possibility to decide on the best based on actual measurements and detailed test cases. This kind of problem solving is proving to be fun.

Oh, forgot to show you the measurements. N is the number of elements in the square. Sol is the number of squares and the time in miliseconds for executing the tests 100.000 times. The results before the change:

N	Sol	Time (ms)
4	4	391
9	6	593
6	2	360
9	1	422
100	1	3843
90	12	5672
16	16	1297
25	25	1766
36	30	3156
42	35	3625

And after the "improvements":

N	Sol	Time (ms)
4	4	265
9	6	438
6	2	281
9	1	297
100	1	2656
90	12	7047
16	16	1610
25	25	3859
36	30	6594
42	35	8625

Design of htmled and improvement opportunities

2006-06-13T17:11:00.001+01:00

So, how complicated do you think htmled might be? This simple 1000 liner program does very simple content extraction and transformation (see htmled, the handbook editor blog and publisher and htmled revisited – Handbook entries to blog posts automated). It doesn't leave the HTML format, no concurrency, no database and no distribution. So, if you're a Python developer you might simply look at the code.

But, as an ArgoUML developer and user, prior to start doing TDD on htmled, I made some simple diagrams which I kept up-to-date for documentation purposes. The following UML class diagram shows the basic data structure, with correspoding classes existing in htmled.py. The HbFile represents a Handbook file, using HbFileParser to parse the file into HbDailyEntries which by thenselves are composed of HbSubjectEntries. I normally load htmled in the Python shell, create HbFile(s) and then use a PostExtractor to extract Posts from the handbook files.

Picture 4 – htmled main classes diagram.

The complexity lies a bit in the PostExtractor and very much in the HbFileParser and its associated classes. Specifically, for parsing a handbook file I used the HTMLParser module contained in the Python standard library and the State design pattern I read about in Robert C. Martin's Agile Software Development book. For this you may check the UML state diagram I draw when trying to model the Finite State Machine for handbook file parsing – check the HbFileParsing class in htmled.

Picture 5 – htmled Handbook File Parsing Finite State Machine.

The use of the state pattern and HTMLParser for parsing the handbook files is definitelly better than a "reinvent the wheel" approach, but, I think it isn't the most appropriate way of solving this problem. I think that I should have tried to use ANTLR for parsing, creating an AST and then extracting the required info from there, e.g., DailyEntries. If I revisit this project again due to ambitions related to imroving its functionalities I might very well do just this as a warm-up!

Postmorten of htmled

2006-05-03T17:07:00.000+01:00

I measured the recent work on htmled with Process Dashboard's PSP0. Since I want to continue evolving the project, I think I'll have a good opportunity to try to improve the effort estimations and the planning.

So, lets resume the results:

Time

	Plan	Actual	Actual %
Planning	24	93	9.35%
High-level Design	0	0	0%
High-level Design Review	0	0	0%
Detailed Design	120	46	4.62%
Detailed Design Review	0	0	0%
Code	240	546	54.9%
Code Review	0	0	0%
Compile	24	8	0.8%
Test	48	275	27.6%
Postmortem	24	27	2.71%
Total	660	995	-------

Defects Injected

	Plan	Actual	Actual %
Planning	0	1	5%
High-level Design	0	0	0%
High-level Design Review	0	0	0%
Detailed Design	0	5	25%
Detailed Design Review	0	0	0%
Code	0	9	45%
Code Review	0	0	0%
Compile	0	0	0%
Test	0	5	25%
Postmortem	0	0	0%
Total	0	20	-------

Defects Removed

	Plan	Actual	Actual %
Planning	0	0	0%
High-level Design	0	0	0%
High-level Design Review	0	0	0%
Detailed Design	0	1	5.26%
Detailed Design Review	0	0	0%
Code	0	7	36.8%
Code Review	0	0	0%
Compile	0	1	5.26%
Test	0	10	52.6%
Postmortem	0	0	0%
Total	0	19	-------

More time and defects than I would expect and I knew the code basis and the requirements very well. I think that it is OK if I take into account the fact that I'm not very experienced with Python and that I had plenty of interruptions.

htmled ready for production use!

2006-05-02T23:52:00.000+01:00

After a while working on this I think I will be able to make my blog update based on the current status of htmled. It processes correctly this Handbook file, being that I even found and corrected some errors in the HTML with it. As stated previously I'm using Test Driven Development (TDD) and using the Process Dashboard to track time and defects. It was fun, mainly because I used Python, TDD and knew very well the requirements ;-).

Mainly I hope it improves dramatically the readability of my blogging. I'm not following full commercial blogging rules, but, heck, I don't intend to earn money with this, just publicize properly my playground.

htmled – the work done up until now

2006-04-10T01:48:00.000+01:00

In my very limited free time I've been working in htmled. It is a Python program that is being developed using test driven development (TDD), which currently is capable of parsing my Handbook files and fill HbDailyEntry and HbSubjectEntry objects. I have created also a PostExtractor which creates blogger posts out of a list of HbDailyEntries. It still doesn't convert the links correctly, but, that is the last step missing for it to be working.

To manage versions of htmled I'm using Subversion, which seams very versatile and simple to use. I'm also using the Process Dashboard scripts, to try to get a feeling on what this tool can make for me besides helping me track the time I use for my hobbies and work.

htmled revisited – Handbook entries to blog posts automated

2006-02-06T01:38:00.000Z

I'm again revisiting my idea of developing automation for transforming content developed in my handbook into Argonaut's-life blog posts. The way I blog until now is seriously flawed, in that it does not follow the feeling that these entries are actualy made in the moment. This is the truth, with the catch that I will only put them in the blog when I'm online and in a batch way. It gives the wrong feeling to persons reading it and I must change this.

But, alas, to change it I must automate a bit and it is here that the problem begins. The high level requirements are identified here, although I'm now less ambitious and just want to automate the transformation of the content of my programmer's handbook entries into Argonaut's life posts.

Details of my handbook entries:

I write in a daily oriented way, always starting with H2 tag and with standard european date format – yyyy-mm-dd.
As stated previously the entries are written in a last in goes to the end manner.
The handbook is made of several HTML files, all in the same directory.
I also include several pictures that are stored in the handbook directory.

I would be happy if in a first step, the converter simply creates single posts out of the handbook entries. The end result could be a group of posts, structured around a directory tree of dates/posts. I may put the content by hand in the blog and the pictures in my website. One problem is the post title. Here I would choose to use H3 level tags. These are the normal heading level within the daily entries.

The automation makes also some formating that satisfies blogger requirements, such as one HTML post must be all within one line. It must fix my handbook intra-links into links that work in the blog, etc.

Executable List of Limitations

2006-02-03T01:30:00.001Z

Another idea I had today is to put the List of Limitations of a program into the program. This would warn the user about some specific limitation only when he uses functionality that contains a limitation. I have done this with the C++ module reverse engineering part.

I did this because it was a module I wanted to integrate, but, it has so many limitations that providing this possibility with warning users of the limitations would be too frustating for anyone than myself. But, it is a rather interesting way of explicitly warning users about something that could annoy them. Today I had the idea of inserting this for all limitations! It is something for the user like TODO and FIXME markups are for developer. With the advantage that he may turn off the LoL warnings after seeing them for the first time. This could be easy with the new technologies such as Aspect Oriented Programming and Attribute Oriented Programming (e.g., Java 5 Annotations).

The kind of user warning depends on the type of program, e.g., ArgoUML would present a warning message while a server application adds a warning sentence in the log. This is also a much better way to manage limitations than using LoL list within the change management tool or a document sent to the user / customer.

2006-02-03

2006-02-03T01:28:00.000Z

I helped finding and fixing [Issue 3917] unit tests failing - default model not initialized. It is very good that ArgoUML has unit tests. Without them I think that release problems would increase a lot. Near release almost everyone who cares will be a bit stressed and the possibility for errors will increase. For this we have the automated unit tests, acting as a safety net.

I should state that ArgoUML developers don't do as much as they should test driven development and test driven bug fixing. This is a practice that isn't enforced by the leader and by the commit rules. But, given time it might be...

Now, imagine that it was. Imagine that commiting a change in the production code should be done with a companion test or at least should be covered by tests. How difficult it would be to verify and automate this? We would need to mark commits to repository as atomic, make a complete build with unit tests executed with coverage and check that the commit is according to the coverage criteria. The commit is rolled back if it is sub-standard, being the commiter warned about this by email.

This requires atomic commits, something CVS does not have, but, Subversion does. It requires integration between the tools used in this scenario: version control system and build tool; build tool and coverage tool; build tool and coverage tool results details related to a set of specific changes; build tool and email system; mapping between version control system user IDs and users details (i.e. email).

Looking into the above requirements, I think that almost everything is possible with open source tools. It would require heavy build knowledge and a dedicated server with rollback rights, but, it is certainly possible.

One problem is the dependencies between one commit and the following. One much more important problem is the total lack of human review in all this!

No, in the end I think this is a bad idea. We should educate persons to follow good practices and then measure. Not put a machine enforcing this!

Am I a Software Engineer?

2006-02-01T07:45:00.000Z

About two years ago I decided to change my job title to Software Engineer. I did this because I think that what is missing in the Software Development field is the application of Engineering practices.

Now I found out this paper about Software Engineering Myths. The author certainly has a point and I am indeed one person that according to him is abusing of the Software Engineer title. But, you can only say this if you agree with his central point that you only are doing Software Engineering if your work is derived from some formal basis. This is a rather biased view! What I've seen in other Engineering fields is that what more establishes their common ground is the set of practices they follow. I would even say that they aren't close to science, but they use recipes derived from this formal basis. Them they mix and match according to experience to do their work.

What are the practices that we are using today that would conceed a person the Software Engineering title? I think these are things like

requirements management
modeling
testing
metrics
use of a software development process

Some of these have indeed a formal and theoretical basis. Some don't. But, they are accepted practices by the whole field. They categorize the Software Engineer.

So, although I agree with some of the observations of Sahil Thaker, I will continue to use this title, since I belive what I do is Engineering and not plain development.

ArgoUML next release

2006-02-01T06:28:00.000Z

ArgoUML is arriving the next stable release. Its a very interesting time since this is the first version that we have support of UML 1.4 and XMI 1.2 with the MDR library. The active core developers base has grown now with Ludo and Tom (kudos to them), which makes a big difference. We have development in installers and the new ArgoUML AndroMDA module.

I wouldn't say that our sail is fully inflated by a good steady wind, but, we're certainly going in that direction :-))

The C++ UML profile

2006-01-23T01:25:00.000Z

The problem above was included in issue #3829 and I already provided patches and tests for this to Tom Morris (the developer to whom the issue is assigned). – Well, there is an exception which is Parameter model elements, that I'll try to fix in the context of 3829. I also think that we have other problems related to namespace, ownership and undocumented behavior of my proposed solution...

With this in place I am already capable of using tag definitions owned by stereotypes in the C++ UML profile in the model elements to which the stereotypes are applied. This should satisfy issue #3771 and the planned objective for C++ reveng, but, it falls short in the context to my previous ambitions: 2005-08-16 andModel C++ in UML according to guidelines accepted in common by the community. I also think that we are buying lots of manual synchronization work to be done in the near future, which should be avoided!!! Currently we have the readme file in the C++ module source, the ArgoUML manual and the source code. With issue #3771 I'm adding the UML profile for C++ which is an additional place where these things go into. So, this means that whenever something changes I have to update four places – to be more correct its more than four since the source code for generator and reveng should be counted as two at least.

Another thing that worries me is the fact that we could be moving into a island and a not invented here syndrome. The UML profile for C++ should be something developed outside of the ArgoUML umbrella, so that it is shared with other communities, creating more reuse opportunities and improving reviews. After finding that there is no effort in the world going into this direction, I will not start with this before having other things like 1446 ready, but, it is indeed important for the overall vision realization... A possible way to start with this is to make it a kickoff step in adding support to C++ to one of the existing open source MDA tools.

TODOs

I must update the C++ reveng code to use the profile. The C++ reveng plan also needs an update.
The C++ module documentation must be updated to include this notion of using the UML profile for C++.
Make a review of non-working tags in the C++ generator, create an issue to handle this and coordinate things with Daniele.

2006-01-09

2006-01-09T01:24:00.000Z

I'm working on issue #3771: Add tag definitions for tags used by the cpp generator. The way to go for solving this is by defining a C++ profile that could be imported automatically by projects for which C++ code generation is intended. This C++ UML profile will be stored within the module jar and support for importing it will be added to the C++ module preferences dialog.

Now, there are some problems with ArgoUML support of tag definitions (TDs). It is not possible define the tagType of a tag definition. This is relevant for the C++ UML profile, where I want to restrict to Boolean the range of values accepted by some tag definitions.

Another problem I'm having is that if I define tag definitions associated with a stereotype (their owner), these don't show as options to be applied to model elements that have the stereotype. Lets say cppClass stereotype has TDs constructor, header_incl and source_incl. When I create a class and apply the cppClass stereotype to it, the tagged values defined in cppClass aren't available to be applied to the class. Well, this takes the value out of associating the TDs to stereotypes, but, this is also an obvious bug that I may easily fix...

To enable users not to polute their models with stereotypes, the C++ UML Profile will have TDs both nicely associated with stereotypes and at top level. This might cause problems when I fix the error I identified above, but, we should try to please the users. It is no problem if the stereotypes aren't applied to model elements, since this way only the tag definitions defined at top level are available. When the user applies the stereotypes he will get one defined at model level and the ones that come from the stereotype. We could define here some type of rule, so that ArgoUML filters the top level values...

2005-12-15

2005-12-15T01:22:00.000Z

The template notation spike is documented in a issuezila task (#3802).

Today I contributed my eclipse project files to ArgoUML list, in a reply to a discussion about shared eclipse projects.

Reorganization of ArgoUML eclipse projects

2005-12-12T01:16:00.000Z

While working in the template notation spike I had to advance some work in the model support for parameterized classes. This implied in making some changes to the ArgoUML model sub-system interfaces and in the NetBeans MDR implementation of the model sub-system. With my previous organization of the eclipse projects this became very cumbersome. I have one eclipse project for ArgoUML, which contained everything bellow cvs/argouml and another with argouml-mdr. The later depended on the former, in order to have the model interface in the class-path - localted in cvs/argouml/src/model. To have the MDR implementation accessible I put argouml-mdr.jar and the other jars from which it depends into the main ArgoUML eclipse project. It was a way to fool eclipse's circular dependency detection. The problem was that I had to do external builds of the MDR jars everytime I made a change in the MDR implementation!

So, after bumping my head against this problem some times I decided that I could benefit from a re-organization of the ArgoUML eclipse projects. Considering the CVS organization of the ArgoUML projects I have defined the folowing eclipse projects:

argouml-lib – contains the ArgoUML libraries from cvs/argouml/lib
argouml-model-api – contains the ArgoUML model sub-system API, from cvs/argouml/src/model; depends on argouml-lib
argouml-mdr – contains the MDR implementation of the model sub-system, from cvs/argouml-mdr/; depends on argouml-lib and argouml-model-api
argouml-src_new – contains the core ArgoUML application, from cvs/argouml/src_new; depends on argouml-lib, argouml-model-api and argouml-mdr
argouml-tools – contains the tools used in ArgoUML, from cvs/argouml/tools
argouml-tests – contains the unit tests of ArgoUML, from cvs/argouml/tests; depends on argouml-lib, argouml-model-api, argouml-mdr, argouml-src_new and argouml-tools
argouml-cpp-module – contains the C++ module, from cvs/argouml/modules/cpp; depends on argouml-lib, argouml-model-api, argouml-mdr and argouml-src_new; the other modules within cvs/argouml/modules are loaded in projects similar to this

One thing that I needed was to filter out the NSUML implementation from argouml-src_new. Shouldn't this be removed alredy?!

I think I'll propose this organization in the argouml-dev list, as a possible way to have shared eclipse projects in CVS. I think that this way we will have a much simpler setup for newcomers.

starting with parameterized classes and UmlUnit

2005-11-24T22:30:00.000Z

2005-11-05

I think I need a spike in what concerns working with GEF. It is certainly possible to make the composition of two figures – the class rectangle and the dashed rectangle with the template parameters. But, I never worked with GEF and graphical programming isn't my game. So, just for fun, lets make this spike.

2005-11-04

1446 User stories

I'll start now with the user stories for 1446. The rules for writing are stated above.

Create parameterized class

Provide a UI action to create a parameterized class. This should be similar to what is currently used to create a normal class. After creation, the parameterizable class properties shall be editable, as usually ocurs for the rest of the model elements. The user may immediatly enter the parameterized class name.

Create template parameter

It is possible to create a parameter for a template. This should work in a similar way as creating / adding attributes to a class. By default the template parameter type is a Classifier, its name is PARAM and it has no default value.

Edit template parameter properties

The properties of a template parameter are visible and editable in similar ways as properties of other model elements.

Parameterized class constrains

Parameterized classes are constrained to have associations only with classes, being uni-directional from the template to the class. An exception is that a bound class is associated through a bind association to the template, being this directed from the bound class to the template.
NOTE: this is too restrictive for common use with programming languages that support templates and maybe we should relax the specified constrains.

Parameterized class graphical presentation

The parameterized class is represented graphically as specified in the UML spec. It is possible to add parameterized classes in class diagrams. The template parameters are editable, but, must respect the rules of the UML spec. It is possible to hide the list of parameters, but, the dashed rectangle remains visible [I'm not totally sure if the spec realy means this].

Create bound class

In the context of a parameterized class it is possible to create a bound class. The parameters must be bound to actual values according to their types. ArgoUML must enforce this either by using default values or by rejecting the creation of the bound class.

Bound class properties

The bound class is similar to a class with the added properties of the template parameters values and the bind association to the template. All the properties are visible and editable, with the exception of the bind association, the attributes and operations of the template which are read only.

Bound class presentation based on name

The UML spec allows to have a bound class with the name explicitly showing its nature, e.g., ParameterizedClassName<Param1Value, Param2Value>. With this presentation it is possible to edit the parameter values in a very simple way. So, it is not needed to have a non-explicit name.

Presentation of a bind association

The bind association may show explicitly the parameter values in brackets, as exemplified in the UML spec.

Use of template parameters within parameterized class

The parameterized class template parameters are usable within the parameterized class for parameterizing its attributes and operations. This means, for instance, that the type of an attribute may be a template parameter.

Delete parameterized class from model

It is possible to delete a parameterized class from the model. The usual model element deletion rules apply, which means, all bound classes are also deleted. A warning is shown to the user stating this, but he may silent it permanently.

Delete template parameter from model

It is possible to remove a template parameter from the model. The usual model element deletion rules apply, which means, all depending attributes, operations and operation parameters are also removed.

2005-10-27

I'm now reviewing the UML support for Parameterized Classes. I'll simply take some notes here about my findings before starting to write User Stories. First a disclaimer, I used UML 1.5 spec since I don't have 1.4 available now. When I get the chance I'll look at that to see if there are changes in this area.

UML defines the Template concept as a "parameterized model element". Strangely a restriction to this is that it "cannot be used directly in a model". Does this means that I cannot say that a Parameterized Class specializes a normal Class? No, the spec explicitly allows two exceptions: "a template may be a subclass of an ordinary class" [ufff!] and one way associations from Templates to other classes.

More strangely, the "«bind»" association is what is used in UML to create a normal class from a Template, by specifying the parameters. Guess what, the association is from the resulting class – the Bound Element to the Template, thus violating the rule expressed just above. Well, I guess this should be the third exception: one way association with stereotype bind from Bound Elements to Templates.

All model elements may be Templates, but normally, in addition to Classes, the model elements that are parameterized are Colaborations and Packages. I think that adding support for these two isn't much more effort since the semantics and notation are very similar.

While considering this I had the idea of a simple refactoring that is usualy done in programming languages that support templates and which may be supported by ArgoUML: creating a Parameterized Class from a Class. This is something interesting because UML does not allow it since the class normally has associations. So, it must be something specific to the tool.

`ModelerImpl` until now was just a huge Spike!

Now that I've studied a bit XP and learned about the concept of Spike, I must consider the work up to now on ModelerImpl as a huge Spike. The proof is my note when it was started after a big analysis effort that resulted just in some inconsistent ideas. The Spike, resulted in some very strong ideas:

ModelerImpl must delegate its reverse work to a tree of objects, each specialized in its own constructs, acting on a current context.
ModelerImpl must reverse to something else than the actual user model. Preferably it should do it to a new empty model that is in a subsequent step reconciled with the user model. Note that this should not preclude future optimization paths like simply checking if some file was already imported and comparing the previous taken MD5 signature with the current.
Importing Context smells more and more like an aspect of the way I've implemented the importing, being based on callbacks from the parser. I wonder if I was using a built AST of the code, if I would recur to this...

2005-10-26

XP Practices to be used in the development of support for parameterized classes

I've reviewed the high level information on XP (the 2nd step of the plan) in www.extremeprogramming.org and chose the following limited set of practices:

User Stories – I'll be the writer and creator, instead of being the result of input from a customer. The User Stories will be included each in the issue to enable gathering feedback early in the development for modifications and prioritization. It is possible that some will be grouped and handled in separate issues, with #1446 depending on those. I'll develop acceptance tests only when these are possible in a small ammount of time. The acceptance tests will be stored in ArgoUML as Unit Tests. Apart from these details I'll try to keep then as described in XP.
Spike Solution – Support for parameterized classes implies changes in almost all the most important ArgoUML sub-systems. Due to the fact that I'm not acquainted with many of them I'll need to make quick and dirty attempts to know if some devised solution works. These will be my Spike Solutions; I'll record then in a minimum with small notes, the time spent on this will be accounted as part of the story implementation, the planning or whatever, and in the end their results will never be incorporated in the code directly.
Test Driven Development (TDD) – This will be followed fully. I don't know how I'll do it for GUI (JFCUnit isn't used in ArgoUML), but, this must be done without exceptions.
Refactor Mercilessly – Refactoring will be followed fully. The problem is code without tests that exists in ArgoUML and that committers may feel insecure to patch with my refactorings. So, this will probably be difficult, but, I'll try to make it happen!

Its a pity to leave out Continuous Integration, Acceptance Tests and other practices, but, some reasons lead me to this:

I don't have commit rights to ArgoUML, so, I can't enforce the integrate often rule because someone must commit my future patches;
my time availability is variable and scarce, so, some times I leave unfinished parts during week time spans;
state of the art support for both acceptance tests and continuous integration requires infrastructure that I don't have and that possibly would take very much time to set up with others' help, since I'm being pragmatic I won't try this for now.

Last but not least, the methodology taken as a whole seams to be more appropriate to teams than it is to individuals, even if working for an open source project with a good community. I would like to see examples of XP applied to open source projects by hobbyists. Probably these would not take the whole thing, even if all team members follow XP.

That's why I will continue to use the Process Dashboard and be inspired by its functionalities and underlying process. I must read the book one of these days!

Now I remember that I know of an open source project that follows XP, its the JyDT. I wonder if Red Robin would provide some feedback on his experience... It was XP before going open source, so, I wonder how he is doing it now...

2005-10-24

I'll start now with issue #1446 – Lack of support for Parameterized Class (Template). This is a complex issue and so, I must handle it as such, by having a plan where I must define iterations for partial deliveries. I think I'll follow some of the eXtreme Programming (XP) practices in this development, such as Test Driven Development (TDD), small iterations for delivering complete user stories, Refactoring and simplicity.

Plan for Parameterized Classes support

Planning the development of 1446. For this activity I'll use the Process Dashboard tool to measure the time I spend in each of the tasks and a scheme similar to what I've developed in the previous work for C++ reveng support. The main difference is that I'll use user stories to drive the development, being the iterations necessarily more formal and regular. This step must be revisited as often as possible (in the end / start of a user story development cycle should be the norm), being sub-sequent updates to the plan documented here.
EE 25 Mh; SN – Planning
Review the XP practices that I'll use in this development – TDD, Refactoring, User Stories, automated builds and possibly more if applicable. The selection of practices will follow the pragmatic objective of choosing the ones that are possible with a minimum effort. For example, I've left out the continuous integration and acceptance tests since I don't have infrastructure for this. Some of the practices will be adapted to be practical, like the definition of user stories might be defined by me. This isn't subverting the practice totally since I'm also a user of ArgoUML ;-). In the end of this task I must have a list of the chosen XP practices, with descriptions of how some of these will be applied, where I can't follow closely the practice as defined elsewhere.
EE 8 Mh; SN – Review XP practices
Review the UML support for parameterization using the UML 1.4 specification. I must check also other UML elements where parameterization is possible, so that I'm able to develop a good set of user stories that is representative of the work. My objective is just to develop an overview, so, writing one paragraph with the conclusions is enough.
EE 4 Mh; SN – UML support for parameterization
Writing the set of user stories for guiding the development of support for parameterized classes in UML. I don't know very well what will be the result of this activity, since I'm not acquainted with user stories, but, after this step I must have a decent set of them written. It is likely that the first set of user stories won't be complete or correct. Any additional writing will be done here, unless it occurs just for the correction of one user story while developing it. In that case the time spent with this is accounted in the step of the given user story.
EE 10 Mh; SN – Writing user stories

UML Unit - Enabling Test Driven Modeling

This idea is buzzing inside my head for some months. Why not specifying test cases in UML? We may use the object representation to specify the instances involved in a test case. Then, a collaboration or sequence diagram may represent a test case. Also, test cases might be grouped in classes that have the TestCase stereotype.

In my view we can support this by defining a UML profile called UML Unit and adding mapping for code generation and reverse engineering to ArgoUML to the existing unit testing frameworks: JUnit, CppUnit, NUnit, PyUnit, etc. It would be interesting to add support to this idea to AndroMDA also, since an obvious target is to enable Test Driven Modeling (TDM) at the PIM level. I know that the Executable UML supports this for years, but, this isn't available in open source tools. So, by having a simple mapping to POJO like PSM that could even be the source code, we could have the same thing without the need to have a UML virtual machine.

The assertion and verification may be modeled as OCL statements. But, this implies code generation support for OCL statements. This is something that isn't yet supported in ArgoUML, although OCL is supported for some years.

2005-10-14

So, after verifying that issue #3552 isn't correct I'll change it to the documentation and fix the docs. Its name will be "header_incl warning in manual's C++ appendix is wrong and solving TODOs".

2005-10-10

Michiel van der Wulp commited my patch to the documentation which includes the C++ generator documentation. Daniele Tamino created two of the above issues, but, I must check the problems I had with duplicate tagged values. In the ArgoUML GUI the duplicated values are shown and reloaded correctly. Maybe this is only replicable when the tagged values are queried like when the C++ module tries to find it... No, it works correctly, so, the warning and TODO will be replaced with a hint to use multiple times the tag.

The issues are:

3552 – header_incl allows to include only one header
3553 – handle multple return parameters

C++ module documentation

2005-10-14T00:10:00.000+01:00

2005-10-10

The issues are:

3552 – header_incl allows to include only one header
3553 – handle multple return parameters

2005-09-23

I have already successfully created the appendix. DocBook is very verbose and for an unexperienced person like me it is awkward to have a slow iteraction to see what errors exist in the file – I'm generating the documentation and this takes very long because the manual is the last to be processed; it also bails on the first error, so, each error cost me a lot! I know that some nice eclipse plugin exists, but, I would like to have the functionality of verifying the syntax in Vim. I guess I must look for this...

Another option is to use a separate validator, like the NetBeans XML module, but, that seams to be a bit overkill! There must be something in the Vim plugin universe ;-) On second thought, I'll give a chance to Netbeans... Yeah, it works like a charm! Just open the argomanual.xml file and validate :-))

2005-09-16

New issues: C++ generator limitation, duplicated tags in ArgoUML and inaccuracies in the documentation readme

While working in the documentation of the C++ module I found that there exists a serious limitation in the way some tagged values are used. The problem is with tagged values for things that the modeler might want to introduce multiple times. An example is the header_incl tag which value is set to a file name that will be included in the header. Well, this is something that is typically done several times.

Although ArgoUML allows entering the same tag more than once with different values, its internals get confused and every tag disappears. I think that this qualifies as a bug and I'll try to fix it.

So, without the option to repeat the same tag several times with different values, one as the possibility to either use tag prefixes or assume some separation character in the tagged value value. I think the latest is better and will propose it in a possible fix.

TODO: create issue for ArgoUML allowing creation of duplicated tagged values.

TODO: create issue for C++ module use of some tagged values so that it allows multiple values to be specified.

TODO: submit the documentation readme corrections.

2005-09-10

I finished the test for DerivedFromAbstract.cxx translation unit and made a new test that looks for duplicates when reverse is repeated. The ModelerImpl now passes the tests defined in TestCppImport. I will now take some time off from implementing reverse engineering for C++ in ArgoUML and write the C++ module appendix of the ArgoUML user manual (issue #2857).

The ArgoUML documentation is written in the DocBook format. It takes the form of a group of XML files according to the DocBook XML. The cookbook explains very well this and I will try to follow those instructions. As stated above, the C++ module will be documented as an appendix, so, this means that I'll create a new XML file in /cvs/argouml/documentation/manual, which I'll name app_cppmod.xml. I'll try to keep the appendix simple, and mainly put in there the information for the code generation users. Latter I might ask collaboration from Daniele to review and add details regarding his new developments.

Drop 1 updated plan - Version 5

2005-08-18T23:41:00.000+01:00

2005-08-16

Much time went by without any news noted here. I've been working in the reverse engineering, having added a new translation unit (DerivedFromAbstract.cxx) that has more constructs to be reverse engineered to UML.

While at it, I've followed the work in the MDR implementation of the Model sub-system of ArgoUML. The developer who is more actively contributing is Ludo (Ludovic Maitre), who, among other things, proposed a GUI extensions model to enable ArgoUML to work with several UML versions. This is very interesting, as it would make ArgoUML more flexible, customizable and modular. The proposed approach to do it is documented in his post. I have sent a different proposal, MDA based, which I think would fit better to ArgoUML (see my post here).

These days ArgoUML development is more active than usual, with work progressing in several fronts. I hope that the interoperability provided by a MDR based implementation of the Model sub-system will attract even more newcomers and previous developers so that this community is boosted to a higher level!

That said, I must complete the TestCppImport.testParseFileDerivedFromAbstract() test case to start working with Daniele in a common UML profile for C++ that will be used in the module. Maybe if this is developed outside of the ArgoUML project, it might provide a great opportunity for experimentation - Maven instead of Ant - and for reuse outside of ArgoUML. The definition of this profile and its use in both the GeneratorCpp and the CppImport is very important for the documentation of the C++ module in the cookbook. It could be described as "the C++ generator uses the conventions defined in the UML profile for C++ for generating C++ specific constructs, such as pointers and references".

2005-07-03

I delivered yesterday the first version that actualy includes reverse engineering. It reverses the SimpleClass.cpp file which is in the argouml/modules/cpp/tests/org/argouml/language/cpp/reveng directory. Sure, it is just a very limited part (even less than the tip of the iceberg), but, it shows that the reverse engineering work is progressing and that the full concept works! So, now I must re-plan, introducing what I already know about the future work. This is an update to the previous version of the plan.

5th version of the plan for C++ reveng drop 1

Learn how to make the ANTLR parser for debugging and build one.
Estimated Effort (EE) = 4 Mh; Short Name (SN) – ANTLR parser 4 debugging
2005-02-25 DONE – Although not actually a fully debug enabled parser, but, using the trace capabilities of the ANTLR generator. Note that this makes the parsing much slower and is only usable with small files!
Actual Effort (AE) = 2:36
Debug the C++ grammar and make it pass the tests.
EE = 20 Mh (see bellow); SN – Fix the C++ grammar
2005-03-07 PARTIAL – It parses cleanly a simple class and a code snippet with which I was attempting to reproduce the current error in parsing of quadratic.i.
AE = 2:51
2005-05-13 PARTIAL – I've postponed fixing the parsing of quadratic.i, since it seams to be complex to solve. Instead, I've started to fix the grammar in order to provide the parsed information to the Modeler. The test case TestCppGrammar.testGrammarCallbacks2Modeler() shows the partial fix. This problem makes the effort estimation for this to change in a dramatic way, since it introduces a huge amount of work that must be done.
New EE = 140 Mh
AE = 15:54 Mh
Commit the result of this work and send it to Yolanda. Update the issue.
EE 3 Mh; SN – Commit, Yolanda and issue
2005-03-09 DONE – I committed the work in progress and updated the issue. Due to the release of a stable version of ArgoUML the work was committed in branch cpp_reveng_work_while_0_18_release. I only sent to Yolanda an e-mail of thanks. I'll send her the version that will be sent to the ANTLR list.
AE = 1:36
2nd re-planning of C++ reveng drop 1
EE 2 Mh; SN – 2nd re-planning of C++ reveng drop 1
2005-03-12 DONE – Re-planned and updated the ProcessDashboard phases.
AE = 1:39
Update the model to reflect the new package and the grammar use.
EE = 2 Mh; SN –Module model update for the C++ grammar
2005-03-16 DONE – Updated and committed.
AE = 2:14
Make tests that show how the parsed information may be used for reveng. If some issue exist, analyze how it is done in java reveng and fix the grammar as needed. This includes creating, or improving the current, test cases, which prove how the parsed information may be used for reveng.
EE 5 Mh; SN – Prove that parsed information is useful for reveng
2005-03-18 DONE – a big issue exists, as documented in the above step.
AE = 1:47 Mh
Planning of C++ reveng drop 1. This task includes all the subsequent plan updates of drop 1, instead of having the planning tasks spread throughout the plan. I estimate I'll have 3 more plan updates, including the final, in the end of drop 1.
EE 6:00 Mh; SN – Planning of C++ reveng drop 1
2005-05-13 PARTIAL – 4th version (3rd update) of the plan.
AE = 1:25
2005-07-03 PARTIAL – 4th update of the plan (5th version).
AE = 3:15
Model the implementation of org.argouml.application.api.PluggableImport interface in the C++ reveng module. Generate the realization of the designed classes. If there are issues in the generation, report them in issuezilla.
EE 5 Mh; SN – Model and generate the realization of the PluggableImport interface
2005-05-20 PARTIAL – the model contains this and ArgoUML was used to generate the implementation skeleton. I found issues in the generation, but, didn't report them, so, this isn't finished.
AE = 3:22
Close the circle, by making the module support reveng of preprocessed C++ files.
EE 15 Mh; SN – Module support of reveng of preprocessed C++
2005-07-02 DONE – The module now reverses the argouml/modules/cpp/tests/org/argouml/language/cpp/reveng/SimpleClass.cpp file. I consider this a proof that the circle is closed. The work is far from finished though, so, we need to add more steps, related to what I learned while making this part of the work...
AE = 9:45
A warning popup box must be shown to the user, warning him about the limitations of the C++ reveng module. This happens when the user selects C++ in the drop down box of the "Import Sources..." dialog. (If this turns out to be difficult, the popup may be shown just before doing the import, when the CppImport.parseFile(xxx) method is called.) It provides an option for the warning to be shut down forever. Even if the user doesn't select it, the CppImport instance will remember that the warning was shown and will not repeat it as long as it "lives".The warning should be self explainable, but, may also direct the user to the manual section that describes the C++ modules functionality (see bellow related issue).
EE 6 Mh; SN – Warning pop-up about the C++ reveng limitations
Extend the C++ translation unit files used in the tests to contain a representative C++ sub-set. These files must contain a basic subset of C++ that is the one used by a person the learning C++. They aren't fancy examples of the powerful language C++ is! All should be compilable with gcc > 2.9x and VC++ 6. All are translation units.
EE 8 Mh; SN – Extend C++ translation unit test files
Support clean reveng of the test C++ translation units. This will obviously be the driver task that will require the UML profile for C++ and the Fix the C++ Grammar steps to move forward. I'll consider that as soon as this is finished, the other two will also. This step is dependent of the template support in ArgoUML issue.
EE 30 Mh; SN – Support reveng of test C++ translation units
Develop a UML profile for C++. It should be as much as needed, but, contains everything that is needed to model the elements that are contained in the C++ subset that will mark the capabilities of the module (see above). [Check my note above regarding this step.]
EE 20 Mh; SN – Develop a UML profile for C++
Send a working vanilla version of the grammar to the ANTLR list and announce its use within the ArgoUML project. Provide feedback as appropriate. Automate the adaption of the files in the module build script.
EE 5 Mh; SN – Send grammar 2 ANTLR list
Enjoy and celebrate the achievement! Go back to planning next drops.
EE 4 Mh; SN – Plan next drops

Some of the above steps depend of two of the following issues. These, obviously must be tackled on their own.

make available to users the module documentation (issue #2857) – I'll use this to also document a bit the reveng part. This will be a great exercise, since it defines the functional requirements of the C++ reveng module.
Create a section in the cookbook about the C++ module. [TODO: create the issue!] (issue #????) – This should be done at the same time that I'll work in the manual. I'll contribute also to the modules part.
Lack of support for Parameterized Class (Template) (issue #1446) –

ModelerImpl and new MDA ideas

2005-06-20T23:29:00.001+01:00

2005-06-20

Now, getting back to the work in reverse engineering module for C++, I'm working in the part that will make the information parsed from the C++ translation unit go into the UML model. Previously I worked in the analysis of this problem. Several design solutions were proposed, but, I don't see them with a clear vision... So, instead of falling into an analysis paralysis situation, I'll start working in the problem in the pragmatic test driven development way! I'll remember my ideas that spawn from the previous analysis excercise, though, so that if I see some pattern to arise I'll easily map it to these ideas.

2005-06-17

I'm working in yet another (see here the other two) proposal for the a future C++ module(s) development according to MDA. Now, what I'm considering is to have the C++ module developed according to its own medicine. With this I mean, have the C++ module implemented in C++! For this, and to enable the investment in the java not to be thrown away, I'm considering to have the module developed according to MDA, with two alternate, platform specific implementations and one common abstract model which would be a PIM.

Picture 3 – Proposal for the development of a C++ implementation of the C++ module according to MDA.

The above picture is very self-explainable. For persons less familiar with MDA, I would say that the PIM and PSM stereotypes stand for Platform Independent Model and Platform Specific Model, respectively. So, we'll have a common PIM of the C++ module, and two implementations. One is the current, or an evolved one already supporting some scriptable capabilities to enable easy customization (I've put Jython, but, with JSR 223 out, we could have any compliant java based dynamic language). The other is an alternate implementation, based in C++ and uses some of the C++ libraries like Boost.Python (to enable the customization of the code generation) and Boost.Spirit (a C++ mean parsing machine). The use of SWIG would make the integration between the C++ code and the rest of the java powered ArgoUML easier than using plain JNI.

So, what do you think? Is this utopic enough for you to jump along and help me prove there are no impossibles?! This will enable the C++ fans to work in the C++ module tasting their own medicine ;-)... Herrr, of course it must be the MDA way!

3295 crushed!

Michiel commited my patch proposal. I synchronized with the repository – update overwrite – and it is working fine. Now, I remember that I forgot to run the checkstyle tests on top of my code before sending the patch!!! Big mistake, when the bug was reported and the patch attached to the issue I was in the end of a big 19 h day. This was a missed opportunity to hold on the horses a bit and wait to have a fresher mind...

The issue is now marked as FIXED and I'm happy to have my initial itch gone from ArgoUML ;-))

2005-06-16

I created the # 3295 issue which is the Stereotypes contained in packages aren't available for selection problem.

2005-06-14

One of the things that are limiting my use of ArgoUML for modeling is its UML version support. Argo is at UML 1.3 and this has some annoyancies. One that I dislike very much is the fact that you can only apply one stereotype in a model element. In UML 1.5 I may apply several stereotypes to a model element. This, for MDA work is very important, I think...

2005-06-09

There are more problems with stereotypes than I thought of. While testing my fix I have the following:

Stereotype created from a package properties panel isn't shown in the package's figure – it happens when you create a stereotype from the package properties panel, after creating the stereotype, it isn't shown in the package figure. As a work around you have to select the model element in the diagram, right click it, then "Show" / "Hide Stereotype", then do the same thing, but, "Show Stereotype". The correct behavior is what happens for classes.
Duplicate built-in stereotypes are shown in list for selection – this occurs after choosing one of the built-in stereotypes for a first time, it seams that it is added to the model and them it is shown twice in the stereotype drop down box of the model element's properties panel.
Created non-top level stereotype from a model element properties isn't applied – this occurs when you are creating a stereotype in the properties of a model element and it isn't in a top level package. The stereotype isn't applied to the model element. DONE This went away after my fix to the non-top level stereotype problem.

I had a problem with my working setup in ArgoUML. The WinCVS, after an update of the Python installation, didn't worked anymore. It crashes almost immediatly and just leaves a small core dump file (I think because I'm driving a windows box). Because of this I attempted uninstalling and installing, but, no can do! I wonder if the WinCVS crew would like to receive my trouble report?!?

So, I made a clean checkout directly in Eclipse and this worked very well. Now, the catch(!) only after a painful process of reconfiguring my all environment I discovered this nice feature of eclipse – select a project, right click, then choose "Team" / "Shared Project...", and, if the project contains some CVS directories it asks if you want to configure CVS for it! Great! So, I re-discovered the following maxima: know your tools!

2005-06-06

I'm still fighting against the Stereotypes contained in packages aren't available for selection bug. The test case I'm developing for testing the problem is the TestExtensionMechanismsHelper.testGetAllPossibleStereotypesStereotypeAndMEContainedInSubPackage(). It tests exactly what was previously done for the TestUMLModelElementStereotypeComboBoxModel.testStereotypesContainedInPackagesAreAvailable4Selection(), but, this one puts the emphasis in being an ExtensionMechanismsHelper test. Since it doesn't use NSUML classes I put it in the org.argouml.model package. It is really a test to the org.argouml.model.ExtensionMechanismsHelper interface and not to a specific implementation, like the previously existing org.argouml.model.uml.TestExtensionMechanismsHelper test is.

Now, all tests are running and it should be OK to make the changes to the model according to what I was trying to do in the C++ module, in the first place. I'm modeling some ideas about the architectural organization for future C++ module development. Some ideas, like the MDA specification of programming languages, are much wider than the C++ module, but, could be a bit utopic...

2005-06-03

Stereotypes contained in packages aren't available for selection

I found a new bug in ArgoUML! If you create a stereotype in a package, it won't be available for selection and assigning it to a model element. This occurs in ArgoUML 0.18.1. I'm going to try to reproduce with HEAD and maybe fix it!

I have an example of the problem. Loading it with Argo HEAD... Yeah, it is still present. So, lets see if this is fixable...

Alright, I have a suspect! The org.argouml.uml.ui.foundation.core.UMLModelElementStereotypeComboBoxModelclass is used in org.argouml.uml.ui.foundation.core.PropPanelModelElement and should be responsible for the drop down combo box contents for the stereotypes. It does use an org.argouml.model.ExtensionMechanismsHelper. Now, the only implementor is the org.argouml.model.uml.ExtensionMechanismsHelperImpl. Let us check if this guy has some tests... Nope! So, no test driven debugging available here.

Let's check if the user UMLModelElementStereotypeComboBoxModel has tests... Jackpot! It is the TestUMLModelElementStereotypeComboBoxModel Now I have something to start with... Lets write a unit test to reproduce the problem.

Upsss, found a dependency from a NSUML class (ru.novosoft.uml.foundation.extension_mechanisms.MStereotype)! This must also go away! DONE

Alright, after some time I already have a failing test, it is testStereotypesContainedInPackagesAreAvailable4Selection(). Now, lets debug and check what is going wrong...

The function where all interesting action is happening is UMLModelElementStereotypeComboBoxModel.buildModelList(). This is triggered by the UMLComboBoxModel2.targetSet(TargetEvent e) function, which I call in my test. Now, the model list building has the error I'm trying to fix and something I might call hand crafted code obfuscation! It contains code which looks suspiciously useless, but, rather complicated... I've marked it with background red color.

    protected void buildModelList() {
        Object elem = /*(MModelElement)*/ getTarget();

        Set paths = new HashSet();
        Set elements = new TreeSet(new Comparator() {
            public int compare(Object o1, Object o2) {
                try {
                    String name1 = o1 instanceof String
                        ? (String) o1 : Model.getFacade().getName(o1);
                    String name2 = o2 instanceof String
                        ? (String) o2 : Model.getFacade().getName(o2);
                    name1 = (name1 != null ? name1 : "");
                    name2 = (name2 != null ? name2 : "");

                    return name1.compareTo(name2);
                } catch (Exception e) {
                    throw new ClassCastException(e.getMessage());
                }
           }
        });

        Collection models =
            ProjectManager.getManager().getCurrentProject().getModels();

        addAllUniqueModelElementsFrom(
           elements,
           paths,
           Model.getExtensionMechanismsHelper()
                .getAllPossibleStereotypes(models, elem));

        setElements(Model.getExtensionMechanismsHelper()
           .getAllPossibleStereotypes(models, elem));
    }

Then it calls the method ExtensionMechanismsHelper.getAllPossibleStereotypes(models, elem) which seams to be the origin of the bug. So, I'll remove the useless code (if it proves as such) and make another test on the failing function that should retrieve all stereotypes applicable to the model element within the specified models.

Argo is a processor hog

Hell! Today I can't work with Argo! It is dragging! After some changes in a middle sized project - the C++ module model, argouml/modules/cpp/doc/ArgoUML.zargo - it started to toggle high processor cycles. When I found the previous bug and wanted to save the model and close ArgoUML 0.18.1, it went full load on the processor and I had to kill it the dirty way. So, yesterday I did two things, update the JRE to 1.5.0_02, and downloaded ArgoUML 0.18.1 so that I would work in the model with the stable version(!). Clearly something went wrong! Here is the System Information:

Java Version  : 1.5.0_02
Java Vendor  : Sun Microsystems Inc.
Java Vendor URL : http://java.sun.com/
Java Home Directory : C:\Programas\Java\jre1.5.0_02
Java Classpath  : C:\luis\programas\ArgoUML\0.18.1\argouml.jar
Operation System : Windows XP, Version 5.1
Architecture  : x86
User Name  : luis
User Home Directory : C:\Documents and Settings\luis
Current Directory : C:\luis\programas\ArgoUML\0.18.1
JVM Total Memory : 7729152
JVM Free Memory : 3209392

I'll try to work a bit with a new model to see if the same thing happens...

Nothing, no peek processor loads! Well, at least I have my example for the other problem. The final test, lets try to save the example... No problem!

2005-06-01

I previously considered about spell checking in Vim and I've found about the vimspell plugin for Vim. The plugin isn't working with my Vim version (6.3). There are some errors in the plugin installation, maybe related to this script not being up-to-date with Vim... All the other plugins for spell checking don't seam to be better. So I'm giving up on this for now :-(

As a better replacement for my current spell checking approach, I use aspell directly with the command:

aspell -c file.html

2005-05-31

`ModelerImpl`: the Java's `Modeller` design and recall of discussion with Andreas Rueckert

Andreas Rueckert is the author of the ArgoUML reverse engineering for java and classfile. I previously discussed with him my plans for the C++ reveng work. He warned that reusing the java Modeller would not work since it is specific for the java semantics. This Modeller was originally made by Marcus Andersson, in the context of his java reveng project.

It refers to the JSR 26, which should be the Java language mapping to UML. [I'm currently traveling by train and offline, so, I can't confirm this.] The current state of the Modeller is very little configurability. This isn't totally bad, since the user might post-process the reversed model with some MDA tool to get a more abstract model. This would be interesting if you are working with an enterprise application, where, e.g., you want some group of files to be associated with an EJB. I will browse a bit in the original javare project, to see if it is still going.

It is stopped, since it achieved its goal of providing a reveng implementation according to the JSR 26 spec for ArgoUML. Now, maintenance continues in the ArgoUML project.

The java Modeller uses the notion of Context to store information about the parsing context. It is designed as a class hierarchy of contexts, with a ClassifierContext and a PackageContext. These context classes are tied to ArgoUML reveng, being dependent of org.argouml.model package. The Modeller stores a stack of parsing states (ParseState) which have context information. I think that even if I can't reuse directly the classes, I might reuse the idea, implementing it in a more general and decoupled way and them make it available for reuse to other reveng modules.

2005-05-25

I previously started analyzing the requirements of ModelerImpl, but, left it incomplete. Now I'm going to continue with this here.

`ModelerImpl`: analysis of responsibilities

A Modeler implementation must:

Understand very well the C++ syntax and semantics.
The syntax is in its method names and arguments, although without the clear order in which calls might be made. This could be improved by adding a clear contract to the interface, but, for now I'll leave it as it is and just state that complete syntax information should be looked up in the grammar.
The semantics is something that will be built within, as part of the implementation. I would say that knowing about semantics is, for instance, to know that a method of some class which has the virtual modifier is polymorphical and that if some derived class (direct or indirect) has the same method (name and args) even if it does not have the virtual keyword, it is polymorphical. This knowledge is important since this semantics has representation in UML and therefore it should be created in the model.
Keep the state of the parsing in a way that when it is called about some parsed construct it models it according to the context.
Understand very well UML and the specific ArgoUML representation of it (this is available in the org.argouml.model package).
Model C++ in UML according to guidelines accepted in common by the community.
Maybe there exist already some UML profile, maybe even a standard one defined by OMG... I googled a bit on "UML profile for C++" and couldn't find one, apart from the UML tool vendors. Objecteering has defined one, but, this certainly comes associated with some copyright. It is also proprietary, due to their notion of a UML profile as a MDA component. I prefer to see a UML profile as a model that one may import into our model. ArgoUML should have a UML profile for C++!
Be flexible, i.e., it should be possible to configure it according to the user's preferences.
One could have default configurations on the module that might be overridden by the user's preferences. Things that should be possible to configure are: model pure virtual class as interface or as abstract class, array or STL container modeled as DataTypes or as association with multiplicity, model references and pointers as associations or as DataTypes, etc.
More, it would be interesting to configure the reverse engineering to use different options for different packages and / or classes. This would be kept persistently in the model, so that in a future import the user would not need to specify it again.

This seams to be too much responsibility to put on top of just one class! I could start already developing and deal with a functionally overloaded and crowded class when it gives problems, but, I think I may start decomposing the problem into smaller parts, just looking at the above list of responsibilities.

Clearly the understanding about C++ syntax and semantics should be close to the Modeler implementation, since its interface is already loaded with these details. Now, about keeping state of the parsing, maybe this should be abstracted from the part of the code that actually makes the translation, since, in a future evolution I might add AST functionality to the grammar, therefore, the Modeler might be capable of navigating back and forth as it models the parsed code. So, maybe I should have something like a component that records the parsed information and is able to provide the context on demand of the actual modeler. I see this as a need when the modeler has full data to model an attribute of a class, and it has to add details regarding the containment and visibility of the attribute.

Now a use case, what if parsing of a given translation unit fails? Should the Modeler undo the import? I think I would like that in this case the parsing just warns about not being able to parse and to issue a clear message about the place where it is failing, with no changes being made to the model. Better it should be configurable! In this case, I think this responsibility should be moved to the CppImport class.

PluggableImport implementation and 4th plan update of reveng drop 1 (also some new ideas)

2005-05-24T23:46:00.001+01:00

2005-05-23

I finished reading the book The C++ Programming Language 3rd edition, by Bjarne Stroustrup, the creator of C++. This was one important step to master this language. Previously I read introductory books by Bruce Eckel, which put me on track, but, having read Stroustrup's book was needed in order to have a definite understanding of the language. One thing I may regret was not having solved the exercises. At least I should have solved a selection of three or four per chapter.

So, next steps? I think that continuing with the work in the C++ module is a nice complement to the book. After reverse engineering is working satisfactorily, working in a C++ profile, which makes the standard library available to be used in models, is something that would naturally make my knowledge improve. I could also get involved in an open source project where C++ is the language of implementation. Another possibility is to work in the Doer enterprise pattern. We'll see...

2005-05-20

htmled, the handbook editor blog and publisher

I take notes in my personal programming handbook. This handbook is digital and written in HTML. It is from the handbook notes that I create the Argonaut's life blog. It isn't something that takes much effort, but, this is the kind of repetitive task that I, as a Software Engineer, should consider for automation. Doing it manually is boring and error prone.

Previously I considered automating the edition of my handbook. My idea is to write a plugin for eclipse or a module for Netbeans, where all the things I make manually while adding content in the handbook automated. Also automated is the task of copying and adapting content from the handbook to the blog.

The handbook as a different structure from the blog, since I normally write top down and it is usually offline. The storage is as HTML files, and I try to keep these files under 100 KB. In the blog the last entry is made in the top of the page. It contains some automation that archives previous entries by month or year. Pictures and files aren't allowed and so I store them in my website. Also, I must take care to change the links I make internally and also to censor some parts of the handbook that I don't want to publish.

In a perfect solution, I would edit my handbook, creating entries and changing others within the IDE, while I work in ArgoUML or some other thing. I have support for automating some specific tasks, such as entering portuguese accentuation. It enables easy adding linking of content, distinguishing internal (within the handbook), local (within my PC) and external links. It must provide many of the basic functionalities of Web editors, but this isn't very important, since I'm comfortable with working in HTML source.

When I go online (yes, I'm not always connected!) and want to put some content in the blog, it will connect to the blog, discover what is changed and update it. The parts in my handbook I've marked as censored would not go online. A nice to have is for the plugin to warn me about some new comments and bring, as in a inbox scheme, show the headers and a small preview and allow me to see what people have been saying.

So, as with everything, I'm lazy and I should look for something that already exists, so that I may get back to my C++ module. Since I'm right now in the train, it will have to wait for some future opportunity.

`CppImport`: some notes on the current state of the implementation

I previously wrote that this is done. It is just partially done. There are issues which I documented in the source file as TODOs. These are easily detect by the IDE and I will remember about them, but, I shouldn't write things that aren't true, hiding future work.

Check spelling in Vim

I use Vim for many things. Most importantly to write these words. Since English isn't my mother language I have to check spelling after writing. This I do in the Mozilla Composer. This isn't very productive, so, is it possible to do it in Vim?

TODO

Another possibility would be to tweak the Mozilla Composer until it makes the editing as it should be: configurable, respectful of source code formating, support for automation, etc. The main reason I always rejected using these WYSIWYG editors since they make such a bad HTML source! Maybe its the time for me to make them the way I want!

`ModelerImpl`: starting-up

Now I'm going to start to put the parsed information into the model. After the grammar, this will be the hardest part of this issue. A Modeler implementation must:

understand very well the C++ syntax and semantics
keep the state of the parsing in a way that when it is called about some parsed construct it models it according to the context
understand very well UML
model C++ in UML according to guidelines accepted in common by the community –
be flexible, i.e., it should be possible to configure it according to the user's preferences

2005-05-16

Starting with `PluggableImport` implementation

So, going ahead with this... I already found some problems with the java generator:

The java generator doesn't generate the standard javadocs correctly. I will try to fix this, but, first I must report it in an issue.
I must find a way to use the generator with a template, or make it more customizable. If there exist the chance for this I must know about it. The manual doesn't contain description of this possibility. Alas, it doesn't have anything describing specifically the java code generation... I'm going to look in the GeneratorJava source for possible hints... At least from what I see in the generateHeader method, this is marked as a TODO. It seams I have an opportunity to do work both in the java generator and in the C++ generator, which from the readme.txtfile seams to be ahead.

Now, I have the CppImport implementation, but, the module only publicizes the GeneratorCpp class and therefore the org.argouml.application.modules.ModuleLoader doesn't find it. One question remains to be answered: is it possible to have two modules in one jar file? If so, then I may just make the needed adjustments in the manifest file of the C++ module. If not I may have to implement a facade that implements both modules and delegates according to the appropriate methods, but, this will be messy. By adding a new entry group with Name: org/argouml/language/cpp/reveng/CppImport.class to the manifest it already works. Nice :-))

OK, apart from reporting the issues above (and probably working in fixing them), this is finished. So, proceeding with the next step.

2005-05-13

I finished today a initial part of fixing the grammar – to provide information from parsing to the Modeler. Instead of proceeding right now with a complete fix I'll address another area of the drop 1 plan, start the implementation of PluggableImport.

But before I'll update the plan according to the execution evolution.

4th version of the plan for C++ reveng drop 1

This is a plan update that is less radical than the previous one, but, reflects the improved knowledge I have on the scope of the problem. I'll update the efforts, both the estimated and the actual until now.

Learn how to make the ANTLR parser for debugging and build one. Estimated Effort (EE) = 4 Mh; Short Name (SN) – ANTLR parser 4 debugging
2005-02-25 DONE – Although not actually a fully debug enabled parser, but, using the trace capabilities of the ANTLR generator. Note that this makes the parsing much slower and is only usable with small files! Actual Effort (AE) = 2:36
Debug the C++ grammar and make it pass the tests. EE = 20 Mh (see bellow); SN – Fix the C++ grammar
2005-03-07 PARTIAL – It parses cleanly a simple class and a code snippet with which I was attempting to reproduce the current error in parsing of quadratic.i. AE = 2:51
2005-05-13 PARTIAL – I've postponed fixing the parsing of quadratic.i, since it seams to be complex to solve. Instead, I've started to fix the grammar in order to provide the parsed information to the Modeler. The test case TestCppGrammar.testGrammarCallbacks2Modeler() shows the partial fix. This problem makes the effort estimation for this to change in a dramatic way, since it introduces a huge amount of work that must be done. New EE = 140 Mh AE = 15:54 Mh
Commit the result of this work and send it to Yolanda. Update the issue. EE 3 Mh; SN – Commit, Yolanda and issue
2005-03-09 DONE – I committed the work in progress and updated the issue. Due to the release of a stable version of ArgoUML the work was committed in branch cpp_reveng_work_while_0_18_release. I only sent to Yolanda an e-mail of thanks. I'll send her the version that will be sent to the ANTLR list. AE = 1:36
2nd re-planning of C++ reveng drop 1 EE 2 Mh; SN – 2nd re-planning of C++ reveng drop 1
2005-03-12 DONE – Re-planned and updated the ProcessDashboard phases. AE = 1:39
Update the model to reflect the new package and the grammar use. EE = 2 Mh; SN –Module model update for the C++ grammar
2005-03-16 DONE – Updated and committed. AE = 2:14
Make tests that show how the parsed information may be used for reveng. If some issue exist, analyze how it is done in java reveng and fix the grammar as needed. This includes creating, or improving the current, test cases, which prove how the parsed information may be used for reveng. EE 5 Mh; SN – Prove that parsed information is useful for reveng
2005-03-18 DONE – a big issue exists, as documented in the above step. AE = 1:47 Mh
Planning of C++ reveng drop 1. This task includes all the subsequent plan updates of drop 1, instead of having the planning tasks spread throughout the plan. I estimate I'll have 3 more plan updates, including the final, in the end of drop 1. EE 6:00 Mh; SN – Planning of C++ reveng drop 1
2005-05-13 PARTIAL – 4th version (3rd update) of the plan. AE = 1:25
Model the implementation of org.argouml.application.api.PluggableImport interface in the C++ reveng module. Generate the realization of the designed classes. If there are issues in the generation, report them in issuezilla. EE 5 Mh; SN – Model and generate the realization of the PluggableImport interface
Close the circle, by making the module support reveng of preprocessed C++ files. EE 15 Mh; SN – Module support of reveng of preprocessed C++
Send a working vanilla version of the grammar to the ANTLR list and announce its use within the ArgoUML project. Provide feedback as appropriate. Automate the adaption of the files in the module build script. EE 5 Mh; SN – Send grammar 2 ANTLR list
Enjoy and celebrate the achievement! Go back to planning next drops. EE 4 Mh; SN – Plan next drops

2005-05-10

I have some strange errors when parsing the SimpleClass::newAttr declaration. For some reason it isn't reported from the parser as was the SimpleClass::newOperation declaration...

2005-05-04

MDA based programming languages specification and development

While developing the C++ module for ArgoUML I started to think about how many repetitive and low level work I would have to make the yet-to-start Python module. How about the amount of work that would go to maintain the java and classfile modules? This is something that should be better supported within ArgoUML than to just provide a template, e.g., the dummylanguage and existing implementations. We could provide some MDA support for this kind of work, such as the possibility of specifying a PIM of the language support module, with Generator, Importer – for reverse engineering – and Synchronizer – for Round Trip Engineering (RTE) (this one is dependent of the other two being available) – as components. This Platform Independent Model (PIM) would then be transformed into the PSM that would target ANTLR based reverse engineering, a StringTemplate based code generator and a common generic GUI based synchronization. This would make life a lot easier for the development of language support modules and would also, hopefully, provide more reuse opportunities out of this development!

This idea led me to yet another bigger, which is, how about taking a Model Driven Architecture (MDA) approach to the specification and development of programming languages? This would imply having reverse engineering of programming language grammars into a UML profile for language grammars. Then we could define a MDA transformation between the Computation Independent Model (CIM) which is the MOF based grammar model for a given programming language into PIMs that would be based in a UML profile for doing something with the specified language. We could define a PIM for compilers, another for RTE of the language in the context of a Model Driven Design (MDD) tool like ArgoUML, and another for Integrated Development Environment (IDE) support of the tool. These PIMs could then be transformed into PSMs for specific targets, e.g, respectively the Jython compiler, the ArgoUML python module, and the eclipse plugin for python or Jython support within eclipse.

For this idea to work a MOF based domain language must be specified to enable the specification of programming language grammars in a MOF repository. We would also need the support for including semantics of the language constructs to the CIMs. For this we could use a ontology that would be used to enrich the CIMs. This ontology may be based on something existing or something based in the UML spec.

2005-05-03

I'm now delving deep into changing the grammar to make the needed info available to the Modeler. The header and implementation files aren't available since the parser works with the translation units therefore the modeling of source file components will be left out for now.

2005-05-02

Updated issue #2947 – support for C++ reverse engineering to include the details of the merge and about the option taken retrieve information from the parsing of files.

2005-05-01

I have created the following issues for problems I found previously:

#3201 – non-console log4j configurations should include date. This is the previously referred problem I found with the non-console log4j configurations.
#3202 – Support of UML foundation types.

I'm going to commit the work in progress to the branch cpp_reveng_work_while_0_18_release and, since the 0.18 release is done, merge the branch into the HEAD. After that I'll continue development in the HEAD.

2005-04-20

The interface will be defined outside of the grammar. This will provide a compile time verification between the grammar and what is expected. It will also enable future independence if the current grammar and parser design is replaced. So, lets use ArgoUML a bit to model...

2005-04-19

The successful test org.argouml.language.cpp.reveng.TestCppGrammar.testCastExpressions proves that something is wrong in the grammar, but, that this isn't obvious. I can't reproduce the error with a small example of what is failing to be parsed – the CastExpressions.cpp file. Being so, I'll proceed to the next part of the fixing the grammar task, to create a generic modeler interface that is called from the grammar.

fixing the grammar II

2005-04-19T00:01:00.000+01:00

2005-04-18

I'm going to give a try with ANTLR 2.7.5 again. Maybe the error wasn't related to 2.7.5 and due to the state ArgoUML was when I attempted revenging of commons logging. When testing with 2.7.2 it was in the initial state...

Nope, it is there... Here is a piece of the stack trace:

  [argouml] Exception in org/apache/commons/logging/Log.class : null
[argouml] java.lang.NullPointerException
[argouml]     at org.argouml.uml.reveng.classfile.ClassfileParser.u4(ClassfileParser.java:490)
[argouml]     at org.argouml.uml.reveng.classfile.ClassfileParser.magic_number(ClassfileParser.java:287)
[argouml]     at org.argouml.uml.reveng.classfile.ClassfileParser.classfile(ClassfileParser.java:258)
[argouml]     at org.argouml.uml.reveng.classfile.ClassfileImport.parseFile(ClassfileImport.java:358)
[argouml]     at org.argouml.uml.reveng.classfile.ClassfileImport.processJarFile(ClassfileImport.java:276)
[argouml]     at org.argouml.uml.reveng.classfile.ClassfileImport.processFile(ClassfileImport.java:228)
[argouml]     at org.argouml.uml.reveng.classfile.ClassfileImport.startImport(ClassfileImport.java:113)
[argouml]     at org.argouml.uml.reveng.classfile.ClassfileImport.parseFile(ClassfileImport.java:95)
[argouml]     at org.argouml.uml.reveng.Import.parseFile(Import.java:431)
[argouml]     at org.argouml.uml.reveng.Import$ImportRun.run(Import.java:582)
[argouml]     at java.awt.event.InvocationEvent.dispatch(InvocationEvent.java:178)
[argouml]     at java.awt.EventQueue.dispatchEvent(EventQueue.java:454)
[argouml]     at java.awt.EventDispatchThread.pumpOneEventForHierarchy(EventDispatchThread.java:201)
[argouml]     at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:151)
[argouml]     at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:141)
[argouml]     at java.awt.Dialog$1.run(Dialog.java:540)
[argouml]     at java.awt.Dialog.show(Dialog.java:561)
[argouml]     at org.argouml.uml.reveng.Import.doFile(Import.java:399)
[argouml]     at org.argouml.uml.reveng.ImportClasspathDialog.doFiles(Import.java:935)
[argouml]     at org.argouml.uml.reveng.ImportClasspathDialog.access$200(Import.java:855)
[argouml]     at org.argouml.uml.reveng.ImportClasspathDialog$OkListener.actionPerformed(Import.java:968)
[argouml]     at javax.swing.AbstractButton.fireActionPerformed(AbstractButton.java:1786)
[argouml]     at javax.swing.AbstractButton$ForwardActionEvents.actionPerformed(AbstractButton.java:1839)
[argouml]     at javax.swing.DefaultButtonModel.fireActionPerformed(DefaultButtonModel.java:420)
[argouml]     at javax.swing.DefaultButtonModel.setPressed(DefaultButtonModel.java:258)
[argouml]     at javax.swing.plaf.basic.BasicButtonListener.mouseReleased(BasicButtonListener.java:245)
[argouml]     at java.awt.Component.processMouseEvent(Component.java:5100)
[argouml]     at java.awt.Component.processEvent(Component.java:4897)
[argouml]     at java.awt.Container.processEvent(Container.java:1569)
[argouml]     at java.awt.Component.dispatchEventImpl(Component.java:3615)
[argouml]     at java.awt.Container.dispatchEventImpl(Container.java:1627)
[argouml]     at java.awt.Component.dispatchEvent(Component.java:3477)
[argouml]     at java.awt.LightweightDispatcher.retargetMouseEvent(Container.java:3483)
[argouml]     at java.awt.LightweightDispatcher.processMouseEvent(Container.java:3198)
[argouml]     at java.awt.LightweightDispatcher.dispatchEvent(Container.java:3128)
[argouml]     at java.awt.Container.dispatchEventImpl(Container.java:1613)
[argouml]     at java.awt.Window.dispatchEventImpl(Window.java:1606)
[argouml]     at java.awt.Component.dispatchEvent(Component.java:3477)
[argouml]     at java.awt.EventQueue.dispatchEvent(EventQueue.java:456)
[argouml] Exception in org/apache/commons/logging/LogConfigurationException.class : null
[argouml]     at java.awt.EventDispatchThread.pumpOneEventForHierarchy(EventDispatchThread.java:201)
[argouml]     at java.awt.EventDispatchThread.pumpEventsForHierarchy(EventDispatchThread.java:151)
[argouml]     at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:145)
[argouml]     at java.awt.EventDispatchThread.pumpEvents(EventDispatchThread.java:137)
[argouml]     at java.awt.EventDispatchThread.run(EventDispatchThread.java:100)

So, to fix the C++ grammar, the first thing to do is to show what the error is:

testParseQuadratic Error unexpected token: (

line 5960:25: unexpected token: (
at org.argouml.language.cpp.reveng.CPPParser.unary_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.cast_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.pm_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.multiplicative_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.additive_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.shift_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.relational_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.equality_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.and_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.exclusive_or_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.inclusive_or_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.logical_and_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.logical_or_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.conditional_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.assignment_expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.expression(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.jump_statement(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.statement(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.statement_list(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.compound_statement(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.function_definition(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.member_declaration(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.class_specifier(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.type_specifier(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.declaration_specifiers(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.declaration(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.external_declaration(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.decl_namespace(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.external_declaration(Unknown Source)
at org.argouml.language.cpp.reveng.CPPParser.translation_unit(Unknown Source)
at org.argouml.language.cpp.reveng.TestCppGrammar.parseFile(TestCppGrammar.java:116)
at org.argouml.language.cpp.reveng.TestCppGrammar.testParseQuadratic(TestCppGrammar.java:92)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:324)
at junit.framework.TestCase.runTest(TestCase.java:166)
at junit.framework.TestCase.runBare(TestCase.java:140)
at junit.framework.TestResult$1.protect(TestResult.java:106)
at junit.framework.TestResult.runProtected(TestResult.java:124)
at junit.framework.TestResult.run(TestResult.java:109)
at junit.framework.TestCase.run(TestCase.java:131)
at junit.framework.TestSuite.runTest(TestSuite.java:173)
at junit.framework.TestSuite.run(TestSuite.java:168)
at org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner.run(JUnitTestRunner.java:231)
at org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner.main(JUnitTestRunner.java:409)
1.23

The parser complains about the line 5960, column 25 of quadratic.i. Which is (marked in red):

                {return ((char)_Narrow((_E)(_C))); }

Well, this is perfectly legal C++. So, lets try to fix it!

2005-04-14

Log4j configurations should have date

I previously solved this problem. The original text might be used to create an issue. I'll have to make a diff to apply the patch.

Fixing the C++ grammar

Upgrading to ANTLR 2.7.5 didn't fixed the problem as I expected. It also doesn't seam to have broken anything, even for the java and classfile modules. I must now make some manual tests to make sure.

The java reveng works fine with ANTLR 2.7.5, but, the classfile reveng failed when parsing the commons logging jar. I must check if the same happens with ANTLR 2.7.2... So, I must get back to the default.properties and revert the change to antlrall.jar.path to use the 2.7.2 jar. Then argouml/src_new/$ ./build.sh clean package argouml/modules/classfile/$ ant clean install argouml/src_new/$ ./build.sh run and test reverse engineering again commons-logging.jar.

And it works! So, something is going wrong when the ANTLR 2.7.5 is used... Since it didn't fixed the problem with C++ parser, I'll stick with version 2.7.2 and maybe create an issue for upgrading with the information that it breaks the classfile reveng.

2005-04-12

After discovering that I had to make some work on the grammar to enable reveng, I been off of development for some time. Now its time to get back and grab this issue!

Fixing the C++ grammar

I think that before starting to change the grammar by adding callbacks to the grammar, to support reverse engineering as the original C++ and java grammars do, I must fix the grammar. Mainly because I think the problems it has to parse the quadratic.i file are related to ArgoUML using an old version of ANTLR. So, to try to fix this I must use the current version of ANTLR to generate the parsers. I may try to replace the global ANTLR instead of adding the newer version to the C++ module.

[It would be nice, though, to try to check if ArgoUML module runtime model handles several versions of the same libraries. But, I think I should not open this new front of work!...]

half way to drop 1

2005-03-30T00:04:00.000+01:00

2005-03-18

After looking a bit into the grammar I realized that it is only parsing the information! It doesn't store it in a AST for later processing. So, this means that currently there isn't parsed information! It isn't this that would make me throw away the current grammar. The main problem is parsing the information and that is being done in a very good way, as is shown in the current working tests!

Just for curiosity I'll look at the original C++ grammar by David Wigg et all... It uses the a similar scheme to the one used in the java grammar. The parser makes calls at specific places in the grammar, in order to have the information processed along with the parsing. The C++ grammar defines abstract methods which are implemented in some specialized parser class. For java reveng, the Modeller class gets called by the parser.

It is interesting to see that neither uses the AST functionalities of ANTLR. I wonder why? Maybe its because these grammars were implemented in a pre-AST time...

After looking into the grammar I now understand that I don't need to remove the pre-processor directives in quadratic.i. So, I'm going to use the original version that comes with the "official" C++ grammar.

I should consider ways to have the official C++ grammar reused instead of having a specific version that will be very difficult to integrate improvements when they are introduced in the David Wigg's grammar. A possible way, if they are interested would be to have some special tags that would be pre-processed previous to the grammar being handed over to the ANTLR for code generation. Maybe even ANTLR makes this task easy! It would be nice to have a unique grammar that would be used with C++, java and python programs! I must consider this when I send the grammar to the ANTLR list.

It is nice to see that the ANTLR project also makes a big effort to be multi-language. The examples provided in the distribution show that the type of multi-language support buit-in in one grammar is possible. In the future I must check how this is being done and try to have the C++ grammar this way!

Fixing the C++ grammar

I think I know why the quadratic.i parsing fails! The version of ANTLR being used in ArgoUML is 2.7.2, while the version that David Wigg was using when he commited the last version of the grammar was 2.7.3. Current version is 2.7.5. So, the way to go would be to at least try the ported grammar with 2.7.3 and check if that is the problem...

Some very interesting news! There exists a grammar for C pre-processor for java programs in ANTLR 2.7.5 distribution. This fits perfectly my needs! :-))

2005-03-16

The module model is now updated to show the use of the ANTLR C++ grammar and commited. I'll proceed to the next step.

2005-03-14

I've been bitten by the infamous zargo corruption bug while editing the C++ module model. Fortunately, I committed the previous version of the model in CVS, and this way I may revert to that version. The ArgoUML version I was using was 0.17.2, which is not advisable for production, as you may see in this report of mine...

Since I'm a developer for ArgoUML, I thought I could look into the log and try to figure out what was the relevant part to report the problem back to ArgoUML. Unfortunately, the log isn't configured to save the date as part of the traces... This I think qualifies as a bug and therefore is a possible fix for me to contribute.

So, I have these two identified problems in ArgoUML, which I must obviously help in being solved. I'll create issues and try to fix them.

log4j configurations should have time with traces – This is very simple, I just need to add "%d" to the pattern in the log4j configuration files, which are in /argouml/src_new/org/argouml/resource. For configurations that are for ConsoleAppender, the date isn't relevant, since the user will see the output in the console and don't need to distinguish between several working sessions in a log file. The main changes are in default.lcf and full.lcf.
ArgoUML must support by default UML foundation types

2005-03-12

The plan must be updated to be more flexible. I already know that I have a parser that is capable of parsing simple files. This is a very important first step and I don't want to loose momentum by attempting to have a perfect parser that correctly parses more complex files, like quadratic.i. So, instead of spending all effort in Fixing the C++ grammar, I'll move forward into using the information parsed for some useful thing. To enable this I'm going to make some analysis and design on how can I do this. This is still part of the Fix the C++ grammar step of the plan, although the name won't indicate this. I would call it now as a different step called analysis of how to use the parsed information.

For this I may check again what the java reveng does and maybe model it a bit in the C++ model... After that I'll make a new test case that explores the information contained in a parsed file. When this is done I may make the model of the C++ grammar and parser.

3rd plan for C++ reveng drop 1

Learn how to make the ANTLR parser for debugging and build one. Estimated Effort (EE) = 4 Mh; Short Name (SN) – ANTLR parser 4 debugging

2005-02-25 DONE – Although not actually a fully debug enabled parser, but, using the trace capabilities of the ANTLR generator. Note that this makes the parsing much slower and is only useable with small files! Actual Effort (AE) = 2:36
Debug the C++ grammar and make it pass the tests. EE = 20 Mh; SN – Fix the C++ grammar

2005-03-07 PARTIAL – It parses cleanly a simple class and a code snippet with which I was attempting to reproduce the current error in parsing of quadratic.i. AE = 2:51
Commit the result of this work and send it to Yolanda. Update the issue. EE 3 Mh; SN – Commit, Yolanda and issue

2005-03-09 DONE – I commited the work in progress and updated the issue. Due to the release of a stable version of ArgoUML the work was commited in branch cpp_reveng_work_while_0_18_release. I only sent to Yolanda an e-mail of thanks. I'll send her the version that will be sent to the ANTLR list. AE = 1:36
2nd re-planning of C++ reveng drop 1 EE 2 Mh; SN – 2nd re-planning of C++ reveng drop 1

2005-03-12 DONE – Re-planned, updated the ProcessDashboard phases and documented it all here ;-). AE = 1:39
Update the model to reflect the new package and the grammar use. EE = 2 Mh; SN – Module model update for the C++ grammar

2005-03-16 DONE – Updated and commited. AE = 2:14
Make tests that show how the parsed information may be used for reveng. If some issue exist, analyse how it is done in java reveng and fix the grammar as needed. This includes creating, or improving the current, test cases, which prove how the parsed information may be used for reveng. EE 5 Mh; SN – Prove that parsed information is useful for reveng
Model the implementation of org.argouml.application.api.PluggableImport interface in the C++ reveng module. Generate the realization of the designed classes. If there are issues in the generation, report them in issuezilla. EE 5 Mh; SN – Model and generate the realization of the PluggableImport interface
Close the circle, by making the module support reveng of preprocessed C++ files. EE 15 Mh; SN – Module support of reveng of pre-processed C++
Send a working vanilla version of the grammar to the ANTLR list and announce its use within the ArgoUML project. Provide feedback as appropriate. Automate the adaption of the files in the module build script. EE 5 Mh; SN – Send grammar 2 ANTLR list
Enjoy and celebrate the achievement! Go back to planning next drops. EE 4 Mh; SN – Plan next drops

Why do I spend so much time planning? Why do I measure with such care the time I spend in my hobby? Why do I document the whole stuff so meticulously?

First C++ parser commit and type bug

2005-03-11T00:06:00.000Z

2005-03-08

With the upcoming 0.18 release of ArgoUML, I looked into the issues reported and fixed by Daniele Tamino, in order to verify the fixes. It is all working fine and therefore many of the issues are now verified.

I think that I will check tomorrow a way to commit my current work for reveng in a branch... DONE Sent also an e-mail of thanks to Yolanda.

2005-03-04

The quadratic.i test file can't be taken as made available from the original ANTLR C++ grammar (the one for C++ output). It contains pre-processor lines, which in the TestCppGrammar test case aren't removed before handing it to the lexer. It isn't a problem. I removed these lines with a simple python script and I'm now debugging the grammar with this modified file. It contains some problems, which I think I will handle by debugging the grammar in additional test cases with just the needed code snippets to make it fail.

2005-02-25

The parser must really be built for debug to enable debugging! This parser isn't just my class, it is the antlr.Parser class! So, I'm going to use just the ANTLR generation options for tracing: -traceParser and -traceLexer. It is working, but, I'm going to start with the SimpleClass.cpp test first because the quadratic.i example from the ANTLR C++ grammar is way too complicated to start with.

The grammar works! :-)) It parsed SimpleClass.cpp as soon as I fixed it (removed the boolean)! I must test with quadratic.i, since previously the Ant target was failing because I wasn't copying the files to the build dir 8-!

New Bug: C++ generator is generating code with java types.

I've noticed a new bug in the C++ generator. ArgoUML enables selection of some built-in types according to the java language. One of these is the boolean, which is generated as boolean instead of bool. I bet this is happening for other types as well...

What should be happening is that ArgoUML enables selection of the standard UML types:

Boolean it does enable the java.lang.Boolean, but, this still is java specific.
Integer same as for Boolean, i.e., java.lang.Integer
... all the types are java!!! No UML types?!

I must create an issue for this... Actually two, one for the global ArgoUML to enable UML types by default and another for the C++ module to give warnings when java specific types are used and to translate these types to C++ types. It should also enable the use of specific C++ types, adding them, just as java does. This might be done with a XMI file made available to users for importing or by some option, which make available the use of either UML types, java types, C++ types or some other...

Another possible addition is to have a critic that warns users about the possibility of using java types in non-java specific models. Maybe having a model nature as a tag would be a nice thing that would disable such critic to be turned on. This model nature could later be extended so that only generic rules and specific language rules to be turned on. This might be applied also to packages etc.