On Wisdom and Happiness

Posted on August 28, 2015 by Hayim Makabee

I spend considerable time thinking about the meaning of Wisdom and Happiness:

  • What are the characteristics of a wise person?
  • What are the characteristics of a happy person?
  • Can wisdom and happiness be measured?

Of course I also think about the relationship between the two:

  • Are wise people happier?
  • Can we increase our happiness by increasing our wisdom?

In the Venn diagram below I try to capture one possible aspect of wisdom: The relationship between the “things we want” and the “things that are good for us”. The set W is the intersection of these two kinds of things. I believe that the number of items in W may be a measure of wisdom, meaning that a wise person is able to understand what is good for him/her.

Wisdom

Consequently, happiness would be the capacity to obtain these “things that we want and that are good for us”. In the Venn diagram below, the set H is the intersection between W and the “things we have”. I believe that the number of items in H may be a measure of happiness, meaning that a happy person has many of these things that he/she wants and that are good for him/her.

Happiness

Of course I’m not talking only about material possessions. I believe that the “things you have” should consist mostly of the personal goals you achieved and the dreams you realized.

So what is the the path to happiness? First you increase the number of things in W, by understanding which things are good for you and “wanting them”. Then you increase the number of things in H, by obtaining the things that you want and that are good for you.

In other words, before realizing your dreams, make sure you are dreaming the right dreams.

What do you think? Do you agree? Please share your comments below.

Posted in Efficacy | Tagged | 2 Comments

Resource Adaptive Software Systems

Posted on August 12, 2015 by Hayim Makabee

The International Association of Software Architects (IASA) in Israel organized a special event about Adaptive Software Systems. We invited Tom Mueck to give a talk about “Resource Adaptive Software Systems”.

Title: Resource Adaptive Software Systems

Abstract: DARPA issued an announcement about building Resource Adaptive Software Systems this past April. More specifically “to build survivable, long-lived complex software systems that are robust to changes in the resources provided by their operational environment”. The motivation behind this project has to do with the short shelf life of modern day software systems:

  • Orders of magnitude less than other engineering artifacts.
  • Strongly inversely correlated with the rate and magnitude of change.
  • When changes do occur they lead to high software maintenance costs and premature obsolescence of otherwise functionally sound systems.

All of these factors greatly impact an enterprise architecture and every architect wishes there would be better technology around.

This talk will introduce a new general computing abstraction named Resource-Oriented Computing (ROC) and discuss these areas of particular interest to architects:

  • Coupled, loosely coupled and decoupled systems
  • Resource-Oriented Architectures
  • Messaging
  • Risk surface / Security

Bio: Tom Mueck is the Director of Business Development at 1060 Research – which was spun out of Hewlett Packard Labs in Bristol. Tom has an MA in Asian Studies and an MBA from the University of Chicago. Previously he was a Political Risk and Financial Analyst, and Sales Manager at Hotsip AB (spun out of Ericsson).

These are the original slides of Tom’s presentation:

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

Feel free to share your comments below.

Posted in IASA Israel, Software Architecture | Tagged , | Leave a comment

Introduction to Event Sourcing

Posted on August 11, 2015 by Hayim Makabee

The International Association of Software Architects (IASA) in Israel organized a special event about Adaptive Software Systems. We invited Vladik Khononov to give a talk about “Introduction to Event Sourcing”.

Title: Introduction to Event Sourcing

Abstract: Event sourcing is a pattern for modeling the application’s business logic. It states that all changes to application state should be defined and stored as a sequence of events. Its advantages are many:

  • Gives freedom to refactor the business logic, allowing better response to new requirements.
  • Suitable for building scalable, highly concurrent, distributed systems.
  • Stored events give the true history of a system, which is required by law in some industries.
  • The system’s state can be reversed to any point in the past for retroactive debugging.
  • The required infrastructure is simple – no monstrous databases are involved.

Vladik will also describe CQRS, an architecture that goes hand in hand with Event Sourcing.

Bio: Vladik Khononov is a software engineer with 15 years’ expertise in building web and enterprise applications for leading Israeli and global companies. Currently he serves as a solutions architect for Plexop, an Israeli-based startup company, where he specializes in Domain-Driven Design, CQRS/ES, and design of scalable, fault tolerant, distributed systems.

These are the original slides of Vladik’s presentation:

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

Feel free to share your comments below.

Posted in IASA Israel, Software Architecture | Tagged , | Leave a comment

Antifragile Software Design

Posted on August 2, 2015 by Hayim Makabee

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 Adaptable Design, Antifragility, IASA Israel, Software Architecture, Software Evolution | Tagged , , , , | Leave a comment

Manifesto for Adaptable Software Development

Posted on July 5, 2015 by Hayim Makabee

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 , , , , | 6 Comments

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

Posted on June 19, 2015 by Hayim Makabee

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

Posted on June 11, 2015 by Hayim Makabee

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

Posted on May 12, 2015 by Hayim Makabee

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?

Posted on April 22, 2015 by Hayim Makabee

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 , , , , | 12 Comments

Finding your purpose in life

Posted on March 24, 2015 by Hayim Makabee

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 | 2 Comments