• Breaking Out of Your Shell as a Coder

    tortoise in shellWorking on a software project after it has shipped for 1 or 2 years can be fun. But sometimes you feel like you need to do something a little different – to get different ideas, different perspectives, and different types of challenges. I feel like I am in the midst of such a journey, one that has begun to have some results that were unexpected when I started. The big lesson has really been that I need to *talk* to more people about coding.

  • Diagramming Tools – A (Biased) Survey

    Diagramming tools can help you to quickly understand a new project, debug code, visualize and enforce usage patterns, and quickly generate high quality documentation.  All good.  However, not all tools are created equal and there are lots of legacy tools (UML has been around for a while).  I wanted to take a look at what is out there to get a sense for how these tools are evolving.

    Below is a slice if you will through what are some next generation offerings in software development, tools that are trying to do something different, and some well established old-guard tools that everyone has heard of and compares all comers too.

    Code Canvas Example

    Debugger Canvas  Debugger Canvas by Microsoft (see video) is based on Code Canvas which was developed at Microsoft Research in  collaboration with the Code Bubbles folks from Brown.  Debugger Canvas is available to premium Microsoft Visual Studio license holders.  I love how you can view a GUI widget, its documentation, and implementation side by side in one clean view.  The development metaphor is very different from a traditional IDE.


  • I’ve Just Inherited an Application – Now What?

    Lucene Overview Diagram

    What if I had a diagram like this?

    I have previously written about how lack of decent software documentation can cause problems in doing what we developers love to do, deliver functioning software. Documentation, code comments and good variable naming are all key to understanding code.  This applies to both code that we write and applications that we use through their API’s.  We could just as easily be looking at C/C++/C#, Python, PHP or any language but for now let’s stay with Java (read more about advantages of Java over other languages at .

    I want to illustrate how useful diagrams are in understanding an existing complex Java code base. Understanding code quickly is particularly important when inheriting a new project or trying to figure out how to use a third party package or open source project. As we all know we are typically faced with tight deadlines, limited resources, and herculean objectives. Sound familiar?

  • The Decline Of Spring?

    I was recently talking to someone I respect very highly about the Spring Framework. I told him that that I would only very reluctantly consider it for a project.

    Now, I have used Spring in the past, and am really a big fan of what they have done. But, these days, I keep thinking of ‘bloated’ in association with them, and wonder if their best days are perhaps behind them.

  • Eclipse Tabbed Editor Extended.. Embedding a GEF Editor

    Finding the right format for users to edit and view your Eclipse plugin’s data can be tricky. Eclipse provides many different types of editors for modification of its resources. Some examples of these are the Java, Text, JSP, XML, Ant editor etc. It also provides tabbed editors like the Plug In Manifest Editor which can have multiple sub editors as tabs in one editor. A simple example template to extend the tabbed editor when creating a new plug-in, is provided in Eclipse by default. For our project we needed to add a compare editor and a GEF editor as sub editors. This post should help you become more familiar with creating custom tabbed editors in Eclipse.


  • Uh oh, not another Large Code Base!

    I came across two blog posts which agree that large code bases are a hassle to programmers. The first post, “Code’s worst enemy” written by Steve Yegge, basically loathes large code bases and Jeff Atwok shares the same opinion in “Size is the enemy” . The problem with large code bases is that their physical size is indication for the large amount of effort, cost and time to be invested for that project, as stated in Steve McConnell books.
  • A simple intro to creating a MVC framework: Using GEF

    When creating a rich graphical editor the Model View Controller (MVC) design pattern makes life a lot easier. But it is often difficult to decide which libraries/frameworks to use. On the Eclipse platform GEF (Graphical Editing Framework) is a great solution but it can be challenging to figure out how to integrate with the parts you need. Since GEF is built on top of the Draw2d/SWT graphical libraries and is able to provide a powerful and consistent UI. However there are many considerations and pitfalls to take into account when getting started with GEF.

    Some of my first large scale Java coding involved using and modifying GEF code. Luckily the GEF team provides many helpful examples showcasing the different features GEF offers. I will attempt to provide a concise introduction to the points that I found best helped me understand GEF.

  • Understanding What Others Are Upto!

    One of the challenges when working in teams is in keeping up with your fellow developers. Spending a lot of time reading others' code not only means less time getting your own work done but also the gradual deterioration of the code architecture. This is a problem that we have heard over and over again from developers and managers alike. We have just released additional code and architectural review tools that will help developers easily understand new features that are being built. We are pleased to announce that we will be demoing this functionality at EclipseCon 2011 as part of the Hot New Products Showcase. With this release we not only have a full fledged code review client and server, but also are making it really easy for developers to document the main parts of what is being worked on. Our new features will help developers create and maintain more comprehensive architectural documentation, solving a number of common development issues. It's important to make sure the quality of your project's code and documentation don't degrade over time. Reviewing the architecture as well as the code itself will ensure a better documented codebase, resulting in easier to understand code and decreased development overhead. On the other hand, we all know that poorly documented code can increase overhead. Developers are often biased to think that their own code is well documented. Another set of eyes checking the documentation as well as the code can make sure confusing code is documented before it is committed. Code duplication is one of the main sources of bugs and headaches for developers. Code review can help minimize duplication in new code but finding redundancies in legacy code may be difficult without quality architectural documentation. Projects with limited or outdated architectural documentation are more susceptible to code erosion since developers may not be clear on what boundaries they are constrained by. Easy access to viewing and creating documentation helps developers be more aware of the effects their code has on other components.
  • From Java to Spring and Beyond – Making Diagrams (and UML) work for developers

    One of the strengths of working with Java is the large number of frameworks that are available. These frameworks are great for taking care of the basic tasks involved in building Java based apps. But they often bring about challenges in understanding - whether it is xml files or annotation based configurations, developers needing to work with these frameworks have to see how different parts of the code are connected. With this in mind we have extended Architexa to not just show code relationships but have also built special support for popular frameworks like Spring and Struts. We are happy to announce that we will be demoing this functionality at EclipseCon 2011 as part of the Hot New Products Showcase. We are pushing the edge here - so we are making this capability available as an 'early access' version. You can find it by default in all versions of the Architexa Suite. We would really like to hear what you think about it, and invite you to extend your trial of the product as we refine the implementation based on your feedback In this release we are including early access to a number of frameworks. With Spring we have added support for Dependency Injection and Web Flow. We have also added support for Struts (1 and 2) and Tiles. Spring Bean classes can be shown in both class and sequence diagrams along with any Property fields they contain. This allows for easy exploration of the hierarchy of beans along with a clearer view of dependency injection. Struts support enables you to explore the actions defined in xml configurations files; specifically, the dependencies to other actions, jsp pages, and classes all within an easy to understand class diagram. Tiles support allows you to easily see where different JSPs plug into various web components and how they relate to other java elements in a class diagram.
  • A Detailed Study on Understanding Code

    Let’s face it; code can be hard to understand. We have all encountered a piece of code that took longer than expected to figure out or was easy to misunderstand. It could be a new library, a coworker’s code, or your own code from 6 month’s ago.

    In a previous post we discuss the importance of taking time to study users in order to get feedback on innovative ideas. We did that to determine how developers understand code and why it can be a challenge.


    We asked Open Source developers a number of questions. Two that stood out were their thoughts on the difficulty of understanding their code and what they generally wanted more of in such projects.


    The first question we asked Open source developers was if they thought that the code they were working on was challenging to understand. Those using the libraries (API Clients) had a different take than those building the library (Core developers).
  • Features of GEF and why they’re useful

    GEF provides a great framework for building MVC based plugins on the Eclipse platform. It contains a great deal of the core functionality (described in more detail here)  necessary for building these types of apps. In addition, GEF also provides features that greatly simplify the task of creating a robust interactive editor. I'll try to show how these different features can benefit any Eclipse developer working with GEF.
  • Eclipse Cheat Sheets: A Hands on Tutorial

    Based on the great response we have had to our previous cheat sheets articles, (why they rock and tips and tricks), I have decided to post a more in depth tutorial. One of the many benefits of Cheat sheets is that they provide an immediate improvement to your product’s usability and are simple to implement. This article will allow you to quickly create multiple cheat sheets.

    To help get you started we have created a cheat sheet on cheat sheets: This cheat sheet can be opened from within eclipse and will guide you through the simple steps for setting up a cheat sheet for your own project.

  • Custom Lucene Scoring

    When you have a lot of data, finding what you are looking for can be a challenge. Fortunately, Google and other search engines help us make sense of the vast amount of data on the web. But what about your own data? Lucene is a great tool for indexing and searching large amounts of information quickly. Fundamentally it uses a great deal of intelligence to determine which Documents are most important to you based on your query. On the surface Lucene is easy to set up and provides many useful benefits, and taking a peek under the hood can give us insight into the core of Lucene’s powerful features.

    I have covered the basics of indexing and searching in Lucene. For those of you interested in the internal workings of Lucene there is no better place to start than its scoring system. Lucene’s brain is its Scoring system. This critical calculation is what determines which results are returned from your searches. Depending on the type of data you are indexing and the purpose of your application you may want to implement a custom method of scoring your data. For instance, when searching data about used cars you may want to put more weight on make and model than, say, color.

  • Eclipse Cheat Sheets: Tips and Tricks

    We talked about in a previous post why Cheat Sheets Rock. Our users have found them useful in the Architexa plugin and we are in the process of adding a great deal more cheat sheets to it. We have also had requests from our readers for more details on creating and utilizing cheat sheets effectively. Some of the most important tips that we found helpful while adding cheat sheets to our product are below to help you get started.

  • Getting Started with Lucene: Searching your Index

    As humans, we are constantly being bombarded with data throughout our lives. Thanks to the superb filtering and attention abilities of our brains we are able to make sense of all this information. Java programs and web apps need to rely on Lucene for this ability. Using Lucene, apps can now collect information at will, add it to an index, and retrieve whatever information is currently needed quickly and efficiently.

    In my last post we learned the basics of creating and modifying a Lucene Index. Now I’ll give you some tips on how to query your index and avoid some of the pitfalls and stumbling blocks I’ve come across.

  • Eclipse Cheat Sheets Rock

    The hardest part in creating a user interface or complex feature is explaining to the user how it should be used. No matter how useful a feature is, if users can not figure out how to use it, it won’t provide them any benefit.

    Tutorials and wizards can both help in getting users easily using features for the first time. Tutorials can be good at describing the steps necessary to perform a task where users may want to modify the steps in order to accommodate their specific needs. But tutorials do not typically live within your plugin/product and force users to switch between a tutorial on a website and your product. Wizards are great for taking a user through an ordered series of configuration actions but they also have their weaknesses. Wizards live entirely in a dialog box, which not only has to be designed by the development team, but also does not provide nearly enough flexibility. This is where a little known feature of Eclipse comes to the rescue.

  • Getting started with Lucene: Creating an Index

    One of my favorite parts of working at Architexa is that I get the chance to learn and experiment with new and interesting libraries, projects, and tools. One such project is Lucene. It provides a great infrastructure for indexing and searching any sort of text. This can be used for all sorts of applications and has saved us a great deal of time when keeping track of data in our projects.

  • REST Architecture – Simplified

    Recently, while working on some collaboration functionality for our suite I got a chance to work on a REST (Representational State Transfer) based web server. There are many great resources about REST out there but most of them are quite technical and it took a me a while to get it. So, in this post I am trying to explain in some simple terms what I have understood about REST.

  • Navigate through Large Projects with Ease using Eclipse

    When working with large code bases, finding your way around can sometime get quite challenging. In such cases, Eclipse makes a developer’s life a lot easier with its shortcuts and quick navigation features. Below is a compilation of a few shortcuts that I have found really useful.

    Quick Navigation in the Workspace

    While working with a large projects one of the challenges we face is to quickly find resources in the workspace. A very useful resource is or shortcut to find any kind of Java resource is Ctrl+Shift+T. It opens a dialog box to search for the needed resource and wildcards can be used in cases where you are not sure about the name of the class. Similarly Ctrl+Shift+R can be used to find any type of resource (even non Java) present in the workspace like jsp’s, xml’s etc.

  • 7 steps to working effectively on large projects with Eclipse

    Large projects often come with an independent (usually ant based) build system – so that the project can be built effectively in different situations. For programmers working on these projects, this often means setting up the IDE to work with these build systems. While working with development teams, I have seen way too many examples of the IDE not setup to take advantage of some of their features. Especially these days, IDE’s absolutely rock, so if you are not taking advantage of them then you are likely putting yourself at a disadvantage.

    Below are a set of steps that you can follow to configure Eclipse to effectively work on your project:

  • Highlights from TheServerSide Java Symposium

    I couldn’t make it to The Server Side Symposium this week, so I spent my spare time following the latest happenings on twitter, various blogs, and checking out the uploaded slides. While these are no replacements to talking to the other attendees in person, it is great to see the online world make things easier when we can’t show up in person.

    The symposium agenda had four tracks over a period of three days with a number of the slides now available online. Below are some of the highlights from the symposium:

    Twitter Updates

    Updates from the conference where posted with the #tssjs hashtag and they can be used to get a listing of the play-by-play points as people tweeted them. I pulled out a list of all the tweets and converted them into a tag cloud. Clicking on any of the commonly used words below will show the tweets that those words were posted under.

    Tweets from TheServerSide Java Symposium (based on #tssjs on twitter and generated using