The nice people over at Architexa have decided to offer free (gratis) licenses to individuals and small teams for their code analysis tools, and asked me to take a look at it and provide some feedback. As stated in my previous post, no problem – but expect honesty.

First things first – Architexa is an Eclipse plugin, which meant I had to put aside my beloved IntelliJ for a few hours while I tried it out. It’s been years since I last used Eclipse – it was 2008, to be precise, and I used it for 3 days in a new job before losing patience with it. I am not an Eclipse fan (as you may have guessed at this point), but that’s irrelevant. At the very least, a tool that makes life easier for Eclipse users must be welcomed. End of Eclipse bashing.

I’m not going to describe what the tools can do, simply because there are videos on youtube that will do that for me. Watch this, and then keep reading. It’ll save me from repeating a feature list, and save you from having to read it.

Got that? Excellent – let’s move on to the question of whether or not I think it’s any good.

As an independent software developer, an open-source developer and a user of open-source software, I spend a reasonable amount of time looking at unfamiliar codebases. As a result, I approached Architexa as a potential way of giving me a fast overview of the codebase. What I actually found surprised me quite a lot.

Architexa provides three diagram types. By covering each in turn, I will eventually get to the point.

Class diagrams

The class diagrams…well, I personally have never heard of anyone getting excited about class diagrams. In fact, I think they’re generally harder to read than the simple class structure shown by a good IDE. Here are screenshots of the structural view in IntelliJ and Eclipse, and the class diagram from Architexa.

To me, this structure is very clear, with intuitive icons – but, in the spirit of full disclosure, I’ve been an IntelliJ user for a decade.

Hmm – those icons are pretty hard to discern clearly, although I imagine that an experienced Eclipse user is fine with this. Additionally, I have no intuitive idea of what {…} represents without clicking it – it’s the static class initializer.

The weakest of the three, for a couple of reasons. The static initializer isn’t shown, and there is no mention of the generic parameters. It’s 2012, and I want to see generics, damnit!

So, I would say the class diagram feature of Architexa, for a personal understanding of a single class, adds nothing to the existing features of the IDE. Happily for Architexa, they’ve understood that classes interact, extend and inherit and these can be added to the diagram too.

Slightly less happily, there doesn’t appear to be a way of automatically optimising the diagram layout, so when things start to get messy you have to manually move things around. An auto-layout feature, such as the one yFiles has, would be a big improvement here.

Layer diagrams

On the first viewing, I thought layer diagrams were just package diagrams – but then I thought, why call them layer diagrams in that case? The answer is that they are not just package diagrams – they are composable diagrams that combine views from the package level down to the inner class level. You can also add actors, database connections and comments to the diagram to create a richer overview of the code.

The palette is fairly restricted – actor, database, comment, class, package and connection are the only options – but for generating diagrams for documentation, they work well. If I could suggest one thing, it would be either a) expand the palette or b) allow users to upload their own icons to use in diagrams.

For me, this is the single most useful feature of Architexa for semi-technical documentation, because you can choose your own layer of abstraction.

Finally, we come to…

Sequence diagrams

Now we’re getting to the core of the deal. If one of the goals of Architexa is to encourage understanding of code, the sequence diagrams are firmly in the image/1000 word category.

A sequence diagram allows you to show the internal workings of a method, plus as many of the subcalls as you wish. I found it particularly useful when mapping out lifecycles in third-party frameworks, because it saves one hell of a lot of clicking and navigation and instead gives you a complete overview in one place. This, for me, is the killer feature.


Architexa has some very nice features for aiding (and shortening) your documentation tasks. It’s not perfect – aside from the issues I mentioned above, I would like to see at least state diagrams as an option. But, it does what it does well and now you can get a free license, it’s at least worth checking out.

Will I continue using it myself? Probably not – but this is due to the pain factor of having to use Eclipse. If it were available as a plugin for IntelliJ, then it would become part of my toolbox. I don’t know what the roadmap for the project is, but, y’know…just hinting 🙂

1 thought on “Tool review: Architexa

Leave a Reply

Your email address will not be published. Required fields are marked *