Antifragile Software Design

The International Association of Software Architects (IASA) in Israel organized a special event about Adaptive Software Systems. I was glad to be invited to give a talk about “Antifragile Software Design”.

Title: Antifragile Software Design

Abstract: The concept of Antifragility was introduced by Nassim Taleb to describe systems that benefit from impacts and volatility.

In this talk we will discuss how this concept may be applied in the field of Software Design with the goal of developing Change-Resilient Systems.

In particular we will address two patterns which frequently appear in Antifragile systems:

1) The Barbell Strategy and the importance of the separation between high-level abstract elements and concrete implementation details.

2) The Componentization Strategy and its applications in SOA, Microservices and Software Product Lines.

Bio: Hayim Makabee was born in Rio de Janeiro. He immigrated to Israel in 1992 and completed his M.Sc. studies on Computer Sciences at the Technion. Since then he worked for several hi-tech companies, including also some start-ups. Currently he is a Predictive Analytics Expert at Pontis. He is also a co-founder of the International Association of Software Architects (IASA) in Israel. Hayim is the author of a book about Object-Oriented Programming and has published papers in the fields of Software Engineering, Distributed Systems and Genetic Algorithms.

These are the original slides of Hayim’s presentation:

Here is the video of the talk (in Hebrew):

Please see here my previous posts on Antifragility and Software Design.

Feel free to share your comments below.

Posted in Software Architecture, IASA Israel, Software Evolution, Adaptable Design, Antifragility | Tagged , , , , | Leave a comment

Manifesto for Adaptable Software Development

We believe that the activities in the left are required to face the challenges of modern software development.

Experimentation instead of Specification
Evolution instead of Implementation
Adaptation instead of Modification
Extension instead of Growth

Perhaps the activities in the right were once good enough, but they are not adequate to the new reality of building complex software systems.

Experimentation instead of Specification

Traditional software development focuses on the detailed specification of system requirements, functional and non-functional. Modern software development should allow the discovery of requirements through experimentation. For example, a Lean approach allows us to build a Minimum Viable Product (MVP) while delaying decisions until the Last Responsible Moment. Sound engineering practices are necessary to build flexible software platforms to support cost-effective experimentation.

Evolution instead of Implementation

Traditional software development focuses on the prioritized implementation of features according to the specified requirements. Modern software development should allow the constant evolution of the system’s functionality to meet the dynamically varying customer needs. For example, Domain Modeling allows us to capture the essential aspects of an application while enabling future specializations. Domain knowledge is necessary to define the central entities and relationships that will remain stable during the system’s evolution.

Adaptation instead of Modification

In traditional software development, code must be modified in order to meet changing requirements. Modern software development should allow the existing code base to be easily adapted to satisfy any change in requirements. For example, Frameworks allow us to have several alternative components that may be chosen according to current needs. The design of a good Framework should be such to eliminate completely the dependency on concrete components.

Extension instead of Growth

In traditional software development, the system must grow in order to accommodate additional requirements. Modern software development should allow the easy extension of the system’s functionality through modular features. For example, Plug-ins allow us to add new features to an existing application without increasing its size and complexity. The design of a good Plug-in should be such that does not expose details about the system being extended nor the Plug-in extending it.

Do you agree? Please share your comments below.

Posted in Adaptable Design, Agile, Lean Development, Software Architecture, Software Evolution | Tagged , , , , | 3 Comments

To document or not to document? An exploratory study on developers’ motivation to document code

caise_2015Last week at Stockholm, Sweden, at the Conference on Advanced Information Systems Engineering (CAISE’15), my colleague Yulia Shmerlin presented our paper at the Workshop on Cognitive Aspects of Information Systems Engineering (COGNISE). This is joint work with Prof. Irit Hadar and Prof. Doron Kliger from the University of Haifa, and is a sequel to our previous paper on Documentation Debt that was published last year.

Title: To document or not to document? An exploratory study on developers’ motivation to document code

Abstract: Technical debt represents the situation in a project where developers accept compromises in one dimension of a system in order to meet urgent demands in other dimensions. These compromises incur a “debt”, on which “interest” has to be paid to maintain the long-term health of the project. One of the elements of technical debt is documentation debt due to under-documentation of the evolving system. In this exploratory study, our goal is to examine the different aspects of developers’ motivation to document code. Specifically, we aim to identify the motivating and hindering aspects of documentation as perceived by the developers. The motivating aspects of code documenting we find include improving code comprehensibility, order, and quality. The hindering aspects include developers’ perception of documenting as a tedious, difficult, and time consuming task that interrupts the coding process. These findings may serve as a basis for developing guidelines toward improving documentation practices and encouraging developers to document their code thus reducing documentation debt.

You can freely download the paper.

Below are the slides of our presentation at the workshop:

Please share your comments below.

Posted in Psychology of Programming, Research, Technical Debt | Tagged , , | Leave a comment

The SOLID Principles Illustrated by Design Patterns

The Clean Code Alliance in Israel organized a special event about the SOLID Principles of Object-Oriented Design. I was glad to be invited to give a talk about “The SOLID Principles Illustrated by Design Patterns”. My friend Eyal Golan also gave a very nice talk about the Single Responsibility Principle.

Title: The SOLID Principles Illustrated by Design Patterns

Abstract: The goal of the SOLID design principles is to improve the Separation of Concerns, through weaker Coupling and stronger Cohesion. The main consequence should be software systems that are easier to maintain and to extend. However the definition of the SOLID principles is quite abstract, and some developers find it difficult to apply them in practice. In my talk I will show how well-known Design Patterns illustrate the application of the SOLID principles, and also show examples of how to follow these principles to Refactor and improve existing designs.

Bio:  Hayim Makabee was born in Rio de Janeiro. He immigrated to Israel in 1992 and completed his M.Sc. studies on Computer Sciences at the Technion. Since then he worked for several hi-tech companies, including also some start-ups. Currently he is a Predictive Analytics Expert at Pontis. He is also a co-founder of the International Association of Software Architects (IASA) in Israel. Hayim is the author of a book about Object-Oriented Programming and has published papers in the fields of Software Engineering, Distributed Systems and Genetic Algorithms.

These are the original slides of Hayim’s presentation:

Here is the video of the talk (in Hebrew):

I would like to thank Boris Modylevsky and Itzik Saban for the organization of this event.

Feel free to share your comments below. Thanks!

Posted in Design Patterns, OOD, Software Architecture | Tagged , , | 5 Comments

Rotem Hermon on Change Driven Design

At the last meeting of the TLV Software Architecture Meetup, Rotem Hermon, VP Architecture at Gigya, gave a very interesting talk about “Change Driven Design”.

Title: Coding Changes

Abstract: Every developer knows that the only constant thing is change, and every developer has the scars to prove it. When we come to designing and writing software, we should make handling change one of our main concerns. We all pretty much do it, even if we don’t usually call it that. In this talk we’ll discuss the four principles of Change Driven Design. We’ll also explore some software architecture methodologies that position handling change as a core concept and design principle.

Change Driven Design

In particular I like very much Rotem’s definition of the four principles of Change Driven Design:

  1. Areas of change should be contained.
  2. Things that are more likely to change should be easier to change.
  3. Things that are less likely to change should not depend on things that are likely to change.
  4. Change should entail extending the system rather than refactoring.

I believe my proposal of Adaptable Design Up Front (ADUF) is a good example of the application of these principles to high-level design.

These are the original slides of Rotem’s presentation:

Here is the video of the talk (in Hebrew):

Please share your comments below.

Posted in Adaptable Design, Software Architecture, Software Evolution | Tagged , , | 3 Comments

Do SOLID design principles make code slow?

SOLIDThis week one of the readers of my blog asked me this question:
“Do SOLID design principles make code slow?”

I think this is a very interesting question, which I have already encountered several times during my 20 years as a professional software developer.

This question became even more common with the popularization of Agile methods, that in general focus on simplicity following principles such as KISS and YAGNI. While I agree that we should try to keep things simple, I think that over-simplification is extremely dangerous.

The SOLID principles of object-oriented design are:
Single Responsibility principle
Open/Closed principle
Liskov Substitution principle
Interface Segregation principle
Dependency Inversion principle

The goal of these design principles is to improve the Separation of Concerns, through weaker Coupling and stronger Cohesion. The main consequence should be software systems that are easier to maintain and to extend. Thus the application of these principles may be seen as an investment in the quality of the software design that has future benefits for the system’s evolution.

However, some potentially undesirable consequences are:
– The proliferation of relatively small concrete classes.
– The proliferation of abstract classes and interfaces.
– A high number of levels of indirection.
– Too many abstraction layers.
– Increase in the depth of the inheritance tree.
Yo-yo problem.

Thus the indiscriminate application of SOLID principles may in practice increase too much the complexity of software systems, with negative consequences for maintainability and extensibility. This is the reason we need experienced software developers in a team, who have the wisdom to foresee the consequences of their design decisions.

Back to the original question: “Do the SOLID principles make code slow?” As we have seen, this is one possibility, because of the potential increase in the levels of indirection and in the number of abstraction layers. In other words, we may be forced to make more method calls and aggregate the data we need from several small objects.

My advice is to choose a design that is clean, focusing on the separation of concerns, but still as simple as possible. If there are performance concerns, this should be measured using runtime tools such as a profiler. Only if a clear bottleneck is detected should the initial design be modified to make the code faster. In any case, the definition of “slow” and “fast” depends on specific system requirements.

To end with a quote by Donald Knuth: “Programmers waste enormous amounts of time thinking about, or worrying about, the speed of non-critical parts of their programs, and these attempts at efficiency actually have a strong negative impact when debugging and maintenance are considered. We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%.”

Do you agree? Please share your experience in the comments below.

Posted in Agile, Design Patterns, OOD, Programming, Software Architecture | Tagged , , , , | 10 Comments

Finding your purpose in life

How to find your purpose in life? The Venn diagram below has appeared several times on the social networks I use. In my opinion it is very interesting and makes me think, so I would like to share it with you and make some personal comments.

purpose

You Love It vs. You Are Great At It

Probably there are many things that we love but that we are not great at. But the opposite is not true: I don’t believe we may be great at something we don’t love. I think that nothing is more effective than enthusiasm. Thus in the Venn diagram above, all the things we are great at should fall in the intersection with the things we love. I talk more about that in my post about the 10,000 hours rule.

You Are Great At It vs. You Are Paid For It

On the short term we may be paid to do something even if we are not great at it. But on the long term we will only be able to hold a good job if we are great at it. So on the long term there is always an intersection between being great at and being paid for something. Moreover, being great at something is not simply a status we reach and then enjoy. Being really great requires continuous improvement.

You Are Paid For It vs. The World Needs It

I believe that if we are being paid for something it is because the world needs it. Thus all the things we are being paid for fall in the intersection with the things the world needs. Of course there are lots of people working as volunteers on things that the worlds needs. But I also believe that if there is something that the world needs, there will always be someone willing to pay for it.

Conclusion

  1. All the things we are great at fall in the intersection with the things we love.
  2. All the things we are paid for fall in the intersection with the things we are great at.
  3. All the things we are paid for fall in the intersection with the things the world needs.

Thus to find your purpose in life, you just need to find something you love and that the world needs, and then make sure you are great at it. That simple. :)

Posted in Efficacy | Tagged | 1 Comment