• Herding Software Developers

    Managing software developers can be a difficult task, especially when working with an agile team. Changing requirements and priorities combined with a learning and growing team can make even the most experienced managers sweat.

    Similar complex interactions have been studied in a number of fields. Game Theory, Cybernetics, and Chaos Theory all provide inspiration to managers looking to ease communication and improve the performance of a team. These theories along with many others fall into the category of Complex Systems. But as developers we need to be careful when utilizing concepts from other domains or managing developers may become an exercise in herding cats.

  • 50 Articles on Code, Architecture, Agile, and Large Codebases

    33: Happy 50th Birthday

    Today Architexa’s “Working With Large Codebases” blog has posted it’s 50th post. While not a huge number, we are excited to see the response to so many of our articles for helping developers work with Eclipse, with agile teams, use design patterns, and document and communicate ideas  with developer tools and diagrams.

    Architexa has been working on the performance of our diagramming tools, and conducting user studies to find more about what it takes for a developer to understand code. We have also been improving our Open Source documentation site codemaps.org.

    With all the articles out there helping developers understand code, we were wondering what type of information you would like to see more of?

    Creative Commons License photo credit: Imagery by Pete

    We are looking forward to providing much more interesting content in the coming months. Please let us know what you would like to see. Send us your favorite articles from our site or across the web.

  • 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.
  • Making Cool Ideas Happen: Studying Our Users and Software Immigrants

    One of the nice things about being Software Developers, is that it’s really nice to spend our time working on cool ideas:  building out systems that help in situations where no solution currently exists. The problem is that often these cool ideas fail. Yes, using an Agile approach helps significantly, especially when customers/users request features. But often customers don’t realize what problems they need solved or what developers are capable of. Skilled engineers have the opportunity to really push the envelope with new and innovative ideas. The challenge then becomes making sure that these new ideas actually meet a need.

  • New Years Resolutions of a Software Developer

    Happy new year all! With the new year comes a chance to re-invent yourself, and as a software developer I find that it is a great opportunity to reflect on how I can improve my skills in the upcoming months. I have thought about this quite a bit over the last few days and have come up with a list of new years resolutions I intend to follow that will help me, and hopefully others, start the new year off on the right foot.

    Practice and experiment with new languages and frameworks for at least a day a month.

    Keeping up with the latest advancements in the software world can be challenging, especially when working at a fast paced start up. Nevertheless, taking time to investigate new and interesting languages and frameworks benefits not only your career, but may also provide streamlined solutions to problems at work. Having an array of languages and frameworks in your developer’s toolkit allows you to find the best solution to a wide range of problems. Career 2.0: Take Control of Your Life seems like it might be a good place to start investigating this resolution.