Category: Software Architect

97 Things Every Software Architect Should Know – 26/97

You might adopt the approach that a framework that is well designed, or an architecture that is carefully considered, and cleverly implemented will lend itself to re-use within your organization. The truth is that even the most beautiful, elegant and re-usable architecture, framework or system will only be re-used by people who:
a) know it is there
b) know how to use it
c) are convinced that it is better than doing it themselves

a) Know its there

Within your organization, developers or designers need to know a design, framework, library, or fragments of code exists and where they can find all the critical information about these elements (e.g. documentation, versions, and compatibility) in order to reuse them. It is a simple, logical truth that people won’t look for things that they don’t believe to exist. You are more likely to succeed with reusable elements if the information about them is ?”pushed”.

There are any number of methods for pushing information about reusable elements in an organization. These range from wiki pages with an RSS feed providing update information, useful in very large teams, to e-mail announcing version updates in the source repository. In a tiny team, the designer or lead developer can inform his colleagues in personal conversations or shouting it across the office. Ultimately, whatever your process for communicating about reusable elements… make sure you have one, don‘t leave it up to chance.

b) Know how to use it

Understanding how to reuse an element depends on skills and training. Of course there are those people who (to use Donald Knuth‘s terminology) “resonate” with coding and design. We have all worked with them, the gifted developers and architects whose speed and depth of understanding is impressive, even scary. But these people are rare. The rest of your team might be made up of good, solid, intelligent developers and designers. They need to be taught.

Developers and designers might not know of the particular design pattern used in a design, or fully understand the inheritance model that the framework designer intended them to use. They need to be given easy access to that information in the form of up-to-date documentation, or even better, training. A little training goes a long way to ensuring that everyone is on the same page when it comes to reuse.

c) Are convinced that its better than doing it themselves

People, and particularly developers, tend to prefer to solve problems themselves rather than ask for help. Asking how something works is a sign of weakness, or even an indication of ignorance. This has a lot to do with the maturity and personality type of your individual team-members, “Better than doing it themselves” means different things to different people. The “young guns” on your team will always want to write things themselves because it appeases their ego, whereas your more experienced people are more likely to accept that someone else has given thought to the problem domain and has something to offer in terms of a solution.

If your team doesn‘t know where to find reusable artifacts or how to reuse them they will default to the natural, human position: they will build it themselves. And you will pay for it.

97 Things Every Software Architect Should Know – 25/97

Scope refers to a project’s size. How much time, effort, and resources? What functionality at what level of quality? How difficult to deliver? How much risk? What constraints exist? The answers define a project’s scope. Software architects love the challenge of big, complicated projects. The potential rewards can even tempt people to artificially expand a project‘s scope to increase its apparent importance. Expanding scope is the enemy of success because the probability of failure grows faster than expected. Doubling a project‘s scope often increases its probability of failure by an order of magnitude.

Why does it work this way? Consider some examples:

• Intuition tells us to double our time or resources to do twice as much work. History[1] says impacts are not as linear as intuition suggests. For example, a four person team will expend more than twice the communication effort as a team of two.
• Estimation is far from an exact science. Who hasn‘t seen features that were much harder to implement than expected?

Of course, some projects aren‘t worth doing without some built-in size and complexity. While a text editor without the ability to enter text might be easy to build, it wouldn‘t be a text editor. So, what strategies can help to reduce or manage scope in real-world projects?

• Understand the real needs – The capabilities a project must deliver are a set of requirements. Requirements define functionality or qualities of functionality. Question any requirements not explained in terms of measurable value to the customer. If it has no effect on the company‘s bottom line, why is it a requirement?
• Divide and conquer – Look for opportunities to divide up the work into smaller independent chunks. It is easier to manage several small independent projects than one large project with interdependent parts.
• Prioritize – The world of business changes rapidly. Large projects‘ requirements change many times before they‘re completed. Important requirements usually remain important as the business changes while others change or even evaporate. Prioritization lets you deliver the most important requirements first.
• Deliver results as soon as possible – Few people know what they want before they have it. A famous cartoon shows the evolution of a project to build a child‘s swing based on what the customer said and what various roles in the project understood. The complicated result only faintly resembles a swing. The last panel, titled ?What would have worked?, shows a simple swing using an old tire. When the customer has something to try, the solution may be simpler than expected. Building the most important things first gets you the most important feedback early, when you need it most.

Agile advocates[2] exhort us to build “The simplest thing that could possibly work”. Complex architectures fail far more often than simpler architectures. Reducing project scope often results in a simpler architecture. Scope reduction is one of the most effective strategies an architect can apply to improve the odds of success.