Posts Tagged ‘design’

  

Analyzing System Dependencies

Analyzing dependencies might seem like a simple concept, but recently I have come to appreciate even more the multiple layers to this topic. To start, why as I.T. professionals should we care about dependencies between and within systems? The core reason is that understanding dependencies allows us to determine the impacts of change. This aids […]

Visualizing Java Package Dependencies

I have recently been examining the overall package structure of a Java enterprise application. I discovered an easy way to visualize the dependencies between packages using two open source tools JDepend and Graphviz and a little glue code. JDepend analyzes compiled Java bytecode and determines dependencies and metrics between Java packages. These analysis results can […]

Streaming Data to Reduce Memory Usage

I recently performed a series of optimizations to reduce an application’s memory usage. After completing several of these I noticed that there was a common theme to many of my optimizations that I could explicitly apply to help identify further opportunities for improvement. As a reoccuring solution, this qualifies as a design pattern which I […]

Defect Prevention Practices

I have written numerous times about defect elimination practices such as code reviews, unit testing, and static code analysis tools. From the perspective of lean thinking, however, eliminating defects, no matter how soon after they are introduced, results in waste due to rework to fix the defects. The ideal as far as lean is concerned […]

Exploring Mental Processes behind Developing Software

How do you go about designing and coding software? More specifically, what is your mental process for accomplishing this? Becoming more aware of the approach you use allows you to deliberately control and improve it. Mental thought processes are, however, very intangible and difficult to put into words. In the software development literature much has […]

Avoiding Caching To Improve Hibernate Performance

I was recently doing some performance tuning and made the surprising discovery that doing less caching in Hibernate actually improved performance in a particular scenario. When I discovered the problem this seemed very counter-intuitive. In fact, my original design maximized the use of caching in order to improve performance, but the opposite happened in practice. […]

Exposing Mutable Objects as Public Properties

I recently had an interesting design discussion with a coworker in which we discussed the pros and cons of exposing mutable objects as public properties of a class. This article provides my thoughts on the subject. An immutable class (or object) is one whose state cannot be changed once the instance is constructed. Mutable objects […]

The Source Code is the Design

I first came across the thought-provoking article What Is Software Design? by Jack Reeves as an appendix titled “The Source Code Is the Design” in the book Agile Software Development: Principles, Patterns, and Practices The article was written in 1992 so ignore the references to C++ (I mentally translated them to Java) and instead focus […]

Inspiring Great Design

I recently acquired a design tool – a set of IDEO method cards, where each card presents a design approach or a method of gaining inspiration. IDEO’s design philosophy is to keep people at the center of the design process, and the four categories they divide the cards into reflect this: Ask people to help. […]

Organizing Information: Using Tags versus Categories

I recently upgraded WordPress – the software that runs this site – to version 2.3. New in this latest version is support for tags. Each post can be associated with any number of keywords or key phrases called tags, and navigation elements can be added to display the set of tags. Probably the most commonly […]

Designing for Deployability

In my previous article Architecting for Deployability, I wrote about the importance of deployability – how reliably and easily software can be deployed from development into the production environment. To accomplish this, one approach I recommended was to encapsulate differences between environments to isolate them from the majority of the application, and thus simplify deployment. […]

Error Handling and Reliability

I have been thinking a lot lately about how to create reliable systems. I previously examined the link between complexity and reliability. Recently, however, I have come to appreciate the impact of error handling on reliability. For the purposes of this discussion, I consider two aspects of reliability: correctness – does the application produce the […]

The Reuse Trap in Software Design

I stared at my code on the screen, but inspiration wouldn’t come. I was trying to design a new feature which shared some commonalities with the existing code base. In particular, there were a couple classes that I knew I could reuse. I just wasn’t sure how they would have to be modified because I […]

Fail Fast or Degrade Gracefully?

There are two approaches to handling internal application errors. In the fail fast approach you immediately terminate the operation (or even the application) once an error is detected. In the degrade gracefully approach you try to continue with as much of the operation as you can. For quite a while I have been a firm […]

How to Write Good Unit Tests

My previous post on How to Create Maintainable Software talked about the importance of automated testing. Working with automated test suites over the years, I’ve found that creating good tests is a skill that needs to be developed. I’ve seen many cases of unit tests that I’d consider poor or bad due to a number […]

How to Create Maintainable Software

My previous article talked about the importance of maintainable software. In this article I provide some recommendations on how to create software that is maintainable – easy to change with minimal risk and impact. What are the specific challenges facing developers maintaining software? They probably did not originally develop the software, and may not even […]