Showing posts with label maintenance. Show all posts
Showing posts with label maintenance. Show all posts

18 March 2015

IT-Systeme systematisch verbessern...

Software neu erstellen - das lernen wir alle in Ausbildung und Studium.

Die Evolution, Weiterentwicklung oder Verbesserung von Softwaresystemen systematisch zu betreiben, müssen wir uns mühevoll in "Training on the Job" selbst beibringen - bisher zumindest...

Neuer Lehrplan zum Thema


Seit kurzem hat der iSAQB e.V. einen entsprechenden Lehrplan namens IMPRVOVE aufgenommen (Disclaimer: Ich habe den entworfen und eingereicht).

Dessen Name ist Programm: Sie können ab sofort lernen, wie Verbesserung, Evolution oder Weiterentwicklung systematisch funktioniert, mit balancierten betriebswirtschaftlichen, fachlichen und technischen Zielen.

IMPROVE hilft Ihnen, kurzfristige Budgetvorgaben und langfristige Architektur- und Produktqualität in Einklang zu bringen. Sie vermeiden Verletzungen der konzeptionellen Integrität und kurzfristige Behelfslösungen. Es zeigt systematische Auswege aus inkonsistenter Implementierung und riskanter Technologiediversifizierung.


Was Sie zum systematischen Verbessern brauchen

aim42 verrät Ihnen schon ziemlich viel, aber ganz praktisch sollten Sie folgende Fähigkeiten mitbringen, wenn Sie Systeme verbessern möchten:

  • Systematische Problemanalyse betreiben, sowohl auf Makro- (z.B. bei Querschnittsthemen, externen Schnittstellen, Entwicklungsprozessen) wie auch auf Mikroebene (z.B. im Code)
  • systematisch Verbesserungsvorschläge für die gefundenen Probleme entwerfen.
  • sowohl Probleme wie auch Lösungsoptionen aus betriebswirtschaftlicher Sicht bewerten (d.h. in Geldeinheiten!). Dieser Punkt fällt Softwareentwicklern erfahrungsgemäß besonders schwer.
  • Langfristiges Vorgehen bei Verbesserung planen, ihre "Evolutionsstrategie" festlegen.
  • Kurzfristige Verbesserungen planen und durchführen, beispielsweise Refactorings, Einführung interner Schnittstellen, Verbesserung von Modularisierung, Kohäsion und/oder Kopplung.
  • Sich durch betriebswirtschaftlich fundierte Argumentation gegen kurzfristige Widerstände durchsetzen.


In diesem Sinne - viel Spaß beim Verbessern Ihrer Systeme.

16 February 2014

Software Quality is More Than Just Code Quality

I'm astonished how many people in our software business try to improve systems by JUST looking at source code - and ignoring loads of other aspects. Especially vendors of code analysis tools tend to equate "software quality" with "code quality" - which ignores major parts of quality issues. Let me illustrate my point with some examples.

Sample 1: Gold-Plated System

The team has created features above features, all highly configurable with a good-looking user interface. There's a button here, a menu there, some choices and a lot of functions... all stuff adding no business value, not useful for the end-user. By the way - all written in clean-code. In my opinion, this team produced *waste* - and the resulting system will more expensive to maintain than it needs to be - more lines of code, more configuration, more difficult to understand.

Sample 2: Overly Complex Solution

Data from a relational database is selected, then transformed into Java objects, then into an XML representation. This XML is processed into a pdf document, which is send via smtp-mail to the user. User prints the pdf, fills out some fields, scans the pdf. The system performs OCR (optical character recognition) and transforms back to xml. The xml is converted to Java objects, which are used to update the relational database. Sounds crazy? Is crazy - but describes an existing system. All written in nice and clean code. In my opinion this sample describes a conceptual disaster, where refactoring code alone wouldn't help - re-architecting the overall process would be the right approach.

Sample 3: Horrible User Experience

A company opened their impressive and useful backend services to customers by adding a web-frontend. Both back- and frontend code was written by expert programmers, adhering to many clean-code principles. Unit and integration tests supported the system. But the user interface has a nightmare. Layout, colors and screen flow had been created by programmers, not by usability-experts. Sidenote: I'm quite sure you have experienced similar situations... programmers-as-designers seems to be a common anti-pattern in development.

Software Quality is MORE than Code Quality

The examples above hopefully illustrate the point that even with well-written code a system can *fail* for its users or developers. Quality attributes like performance, understandability, maintainability, understandability, security or compliance might be neglected despite good source code...

Analyze Problems From Bird's Eye Perspective

In exiting business systems you should approach *improvement* or system evolution from different perspectives, not only by counting code-violations or code-metrics. For example the following perspectives provided valuable input for some of my own practice experiences:
  • Qualitative Analysis (e.g. ATAM)
  • Runtime Analysis, e.g. performance and resource monitoring
  • Analysis of Development Process
  • Data Analysis - find improper structures and content
  • Issue-Tracker Analysis
  • Static Code Analysis

Clean Code is Important...

I'm convinced of the importance of understandable code. I will actively promote refactoring towards cleaner code whenever appropriate. The principles of clean code need to be taught and practiced throughout our industry. But hopefully you see my argument - there's some more to do: we need to create understandability on a higher level, need to design appropriate technical and business concepts, need to design appropriate data structures and interfaces and so on...

Methodical Improvement to the Rescue

What's needed to systematically improve software is an iterative approach to find *many* problems, not only within code. aim42 collects practices and patterns to achieve exactly that - the foundation for systematic improvement. Think about it when some manager demands compliance to some code metric or coding-convention... you might be better off by optimizing or improving something completely different.

05 February 2014

aim42 - Systematic Approach to Software Maintenance

During the OOP-Conference 2014, Stefan Tilkov and myself released aim42 - the systematic approach to software maintenance and improvement.
Aim42 logo
We named it "aim", short for "Architecture Improvement Method". aim42 is a free and open-source project, a community approach to collect practices and patterns.

Why Do We Need Software Architecture Improvement

Software maintenance is a major issue, because over time many systems degrade massively: Understandability (and with it, maintainability) goes down, and cost-of-change grow. See the diagram below:
Cost of change

aim4 Phases

It consists of three distinct phases:
  1. Analyze: search and collect problems, issues, deficiencies and technical debt within your system and your development process.
  2. Evaluate:understand root-causes of problems, determine their „value“ and cost/effort of their remedies.
  3. Improve: systematically improve code and structures, reduce technical debt, remove waste and optimize.

Community Approach

Currently we host the (AsciiDoc) source of the aim42 guidebook on Github, one of the best-known open-source communities.
https://github.com/aim42/aim42
Find some further information (oops - currently in German only) within our initial presentation (on Speakerdeck) or the upcoming YouTube channel.

Changes

* Feb. 16th: Changed URL from Bitbucket to Github