[Discussion] Shifting our OFBiz culture to enable innovation

[taher]

Hello Everyone,

As you already know, we have been doing major work in terms of improving
and refactoring the framework. We are buzzing and making changes everywhere
and people are getting excited about helping out. This is fantastic! and I
hope we can continue in this new direction.

However, before we started the refactoring work, I kept wondering why did
we get here in the first place? We do we have lots of bad and messy code in
the code base? Why are we at point where we are shifting all energies to
cleaning up?

So as I started working with people on the refactoring project and the
answers to the above questions started to slowly appear. I list below my
perception of the problems and recommendations for avoiding repeating these
problems of bad code.

Problem: We are very conservative
----------------------------------------------

How many times did you hear this: "Don't remove that, somebody might need
it" or "Oh no, you just made a regression in trunk" or "No keep it, _one_
person X objected".

You know ... making software is difficult. It involves taking many
decisions, some of these decisions might not appeal to every person but
they are necessary for the health of the project.

So here is where I observed conservative behavior:

- We are too sensitive to objections that even _one_ person might stop an
initiative. In a way we might be a little too nice.
- We treat trunk like it is almost a stable branch, and for any serious
change we immediately prefer to create branches.
- We _rarely_ remove anything, and when we suggest removing things big
resistance happens. We suffer from "code hoarding"
- We are shy about changing other people's code. Shy not because we don't
know what to do, but we are concerned about making those who wrote the
software displeased.
- We treat code written by others like it is holy and difficult and we
cannot repeat, when in fact many times we can make it actually _better_!

The above observations in my opinion are the main reasons why we have bad
code. We just pile up and we are so afraid of change. We don't change
anything and the code as a result suffers and deteriorates. We just pile
things on top of other things and do not revisit the design and try to make
it better and cleaner. Sometimes revisiting the design involves _DELETING_
which is a strange word in our community :)

Recommendation: Shifting our mindset
---------------------------------------------------

At a high level, we can say our problem is fear! How do we reduce and
control fear? How do we gain confidence about making change without too
much pain? Luckily many smart people already thought about these things and
came up with wonderful solutions. I list hear recommendations which are
inspired by these thinkers:

- First we must be aware that we are conservative and accept it. We should
be conscious of how apprehensive we are about change
- We should have a very strong test coverage of our code and we should
exercise Test Driver Development as a core philosophy in our programming
methodology. Having very well tested code gives you confidence. Confidence
gives you courage to change.
- We should accept trunk as an _unstable software_. It is a place where all
the brain storming and thinking and innovation is happening.
- We should be open in expressing our opinions. Being correct is better
than being nice. Mind you I'm not encouraging conflict! I am instead
encouraging good technical discussions that lead to useful outcomes. It is
only when people challenge your technical opinion that you really expand
your horizons and learn something
- For me personally, I think most importantly, we should accept _REMOVING_
and _DELETING_ things. This is a natural phenomenon in all software
systems. Sometimes we create something and realize later that it was a bad
idea. Just Delete it!! Don't keep it hanging forever.

In conclusion
-----------------

So OFBiz has a wonderful community and great people. However we are overly
conservative, and we need to be a little more brave and willing to embrace
change. Yes this will lead to some friction and at times feeling lost, but
the long-term benefits far far outweigh the losses in my opinion.

What do you think? I would love to hear everyone's opinion on this, and
thank you again for being such supportive and wonderful people.

Cheers :)

Taher Alkhateeb

[Pierre Smits]

Hi Taher,

Nice posting. Something to ponder about.

Best regards,

Pierre Smits

ORRTIZ.COM <http://www.orrtiz.com>
OFBiz based solutions & services

OFBiz Extensions Marketplace
http://oem.ofbizci.net/oci-2/

On Sat, Jul 16, 2016 at 3:38 PM, Taher Alkhateeb <[hidden email]
> wrote:

> Hello Everyone,
>
> As you already know, we have been doing major work in terms of improving
> and refactoring the framework. We are buzzing and making changes everywhere
> and people are getting excited about helping out. This is fantastic! and I
> hope we can continue in this new direction.
>
> However, before we started the refactoring work, I kept wondering why did
> we get here in the first place? We do we have lots of bad and messy code in
> the code base? Why are we at point where we are shifting all energies to
> cleaning up?
>
> So as I started working with people on the refactoring project and the
> answers to the above questions started to slowly appear. I list below my
> perception of the problems and recommendations for avoiding repeating these
> problems of bad code.
>
> Problem: We are very conservative
> ----------------------------------------------
>
> How many times did you hear this: "Don't remove that, somebody might need
> it" or "Oh no, you just made a regression in trunk" or "No keep it, _one_
> person X objected".
>
> You know ... making software is difficult. It involves taking many
> decisions, some of these decisions might not appeal to every person but
> they are necessary for the health of the project.
>
> So here is where I observed conservative behavior:
>
> - We are too sensitive to objections that even _one_ person might stop an
> initiative. In a way we might be a little too nice.
> - We treat trunk like it is almost a stable branch, and for any serious
> change we immediately prefer to create branches.
> - We _rarely_ remove anything, and when we suggest removing things big
> resistance happens. We suffer from "code hoarding"
> - We are shy about changing other people's code. Shy not because we don't
> know what to do, but we are concerned about making those who wrote the
> software displeased.
> - We treat code written by others like it is holy and difficult and we
> cannot repeat, when in fact many times we can make it actually _better_!
>
> The above observations in my opinion are the main reasons why we have bad
> code. We just pile up and we are so afraid of change. We don't change
> anything and the code as a result suffers and deteriorates. We just pile
> things on top of other things and do not revisit the design and try to make
> it better and cleaner. Sometimes revisiting the design involves _DELETING_
> which is a strange word in our community :)
>
> Recommendation: Shifting our mindset
> ---------------------------------------------------
>
> At a high level, we can say our problem is fear! How do we reduce and
> control fear? How do we gain confidence about making change without too
> much pain? Luckily many smart people already thought about these things and
> came up with wonderful solutions. I list hear recommendations which are
> inspired by these thinkers:
>
> - First we must be aware that we are conservative and accept it. We should
> be conscious of how apprehensive we are about change
> - We should have a very strong test coverage of our code and we should
> exercise Test Driver Development as a core philosophy in our programming
> methodology. Having very well tested code gives you confidence. Confidence
> gives you courage to change.
> - We should accept trunk as an _unstable software_. It is a place where all
> the brain storming and thinking and innovation is happening.
> - We should be open in expressing our opinions. Being correct is better
> than being nice. Mind you I'm not encouraging conflict! I am instead
> encouraging good technical discussions that lead to useful outcomes. It is
> only when people challenge your technical opinion that you really expand
> your horizons and learn something
> - For me personally, I think most importantly, we should accept _REMOVING_
> and _DELETING_ things. This is a natural phenomenon in all software
> systems. Sometimes we create something and realize later that it was a bad
> idea. Just Delete it!! Don't keep it hanging forever.
>
> In conclusion
> -----------------
>
> So OFBiz has a wonderful community and great people. However we are overly
> conservative, and we need to be a little more brave and willing to embrace
> change. Yes this will lead to some friction and at times feeling lost, but
> the long-term benefits far far outweigh the losses in my opinion.
>
> What do you think? I would love to hear everyone's opinion on this, and
> thank you again for being such supportive and wonderful people.
>
> Cheers :)
>
> Taher Alkhateeb
>

[Jacques Le Roux]

Yes I agree,

I'd just add that one of the reasons which leaded to this situation is for a long time (until 2010 I'd say) we were advocating to use the trunk for
new custom developments. So it was something we were sensitive about.

Jacques


Le 16/07/2016 à 15:44, Pierre Smits a écrit :

> Hi Taher,
>
> Nice posting. Something to ponder about.
>
> Best regards,
>
> Pierre Smits
>
> ORRTIZ.COM <http://www.orrtiz.com>
> OFBiz based solutions & services
>
> OFBiz Extensions Marketplace
> http://oem.ofbizci.net/oci-2/
>
> On Sat, Jul 16, 2016 at 3:38 PM, Taher Alkhateeb <[hidden email]
>> wrote:
>> Hello Everyone,
>>
>> As you already know, we have been doing major work in terms of improving
>> and refactoring the framework. We are buzzing and making changes everywhere
>> and people are getting excited about helping out. This is fantastic! and I
>> hope we can continue in this new direction.
>>
>> However, before we started the refactoring work, I kept wondering why did
>> we get here in the first place? We do we have lots of bad and messy code in
>> the code base? Why are we at point where we are shifting all energies to
>> cleaning up?
>>
>> So as I started working with people on the refactoring project and the
>> answers to the above questions started to slowly appear. I list below my
>> perception of the problems and recommendations for avoiding repeating these
>> problems of bad code.
>>
>> Problem: We are very conservative
>> ----------------------------------------------
>>
>> How many times did you hear this: "Don't remove that, somebody might need
>> it" or "Oh no, you just made a regression in trunk" or "No keep it, _one_
>> person X objected".
>>
>> You know ... making software is difficult. It involves taking many
>> decisions, some of these decisions might not appeal to every person but
>> they are necessary for the health of the project.
>>
>> So here is where I observed conservative behavior:
>>
>> - We are too sensitive to objections that even _one_ person might stop an
>> initiative. In a way we might be a little too nice.
>> - We treat trunk like it is almost a stable branch, and for any serious
>> change we immediately prefer to create branches.
>> - We _rarely_ remove anything, and when we suggest removing things big
>> resistance happens. We suffer from "code hoarding"
>> - We are shy about changing other people's code. Shy not because we don't
>> know what to do, but we are concerned about making those who wrote the
>> software displeased.
>> - We treat code written by others like it is holy and difficult and we
>> cannot repeat, when in fact many times we can make it actually _better_!
>>
>> The above observations in my opinion are the main reasons why we have bad
>> code. We just pile up and we are so afraid of change. We don't change
>> anything and the code as a result suffers and deteriorates. We just pile
>> things on top of other things and do not revisit the design and try to make
>> it better and cleaner. Sometimes revisiting the design involves _DELETING_
>> which is a strange word in our community :)
>>
>> Recommendation: Shifting our mindset
>> ---------------------------------------------------
>>
>> At a high level, we can say our problem is fear! How do we reduce and
>> control fear? How do we gain confidence about making change without too
>> much pain? Luckily many smart people already thought about these things and
>> came up with wonderful solutions. I list hear recommendations which are
>> inspired by these thinkers:
>>
>> - First we must be aware that we are conservative and accept it. We should
>> be conscious of how apprehensive we are about change
>> - We should have a very strong test coverage of our code and we should
>> exercise Test Driver Development as a core philosophy in our programming
>> methodology. Having very well tested code gives you confidence. Confidence
>> gives you courage to change.
>> - We should accept trunk as an _unstable software_. It is a place where all
>> the brain storming and thinking and innovation is happening.
>> - We should be open in expressing our opinions. Being correct is better
>> than being nice. Mind you I'm not encouraging conflict! I am instead
>> encouraging good technical discussions that lead to useful outcomes. It is
>> only when people challenge your technical opinion that you really expand
>> your horizons and learn something
>> - For me personally, I think most importantly, we should accept _REMOVING_
>> and _DELETING_ things. This is a natural phenomenon in all software
>> systems. Sometimes we create something and realize later that it was a bad
>> idea. Just Delete it!! Don't keep it hanging forever.
>>
>> In conclusion
>> -----------------
>>
>> So OFBiz has a wonderful community and great people. However we are overly
>> conservative, and we need to be a little more brave and willing to embrace
>> change. Yes this will lead to some friction and at times feeling lost, but
>> the long-term benefits far far outweigh the losses in my opinion.
>>
>> What do you think? I would love to hear everyone's opinion on this, and
>> thank you again for being such supportive and wonderful people.
>>
>> Cheers :)
>>
>> Taher Alkhateeb
>>

[Jacques Le Roux]

Le 16/07/2016 à 17:54, Jacques Le Roux a écrit :
> Yes I agree,
>
> I'd just add that one of the reasons which leaded to this situation is for a long time (until 2010 I'd say) we were advocating to use the trunk for
> new custom developments. So it was something we were sensitive about.

And this state of mind (maybe unconsciously) continued

Jacques

>
> Jacques
>
>
> Le 16/07/2016 à 15:44, Pierre Smits a écrit :
>> Hi Taher,
>>
>> Nice posting. Something to ponder about.
>>
>> Best regards,
>>
>> Pierre Smits
>>
>> ORRTIZ.COM <http://www.orrtiz.com>
>> OFBiz based solutions & services
>>
>> OFBiz Extensions Marketplace
>> http://oem.ofbizci.net/oci-2/
>>
>> On Sat, Jul 16, 2016 at 3:38 PM, Taher Alkhateeb <[hidden email]
>>> wrote:
>>> Hello Everyone,
>>>
>>> As you already know, we have been doing major work in terms of improving
>>> and refactoring the framework. We are buzzing and making changes everywhere
>>> and people are getting excited about helping out. This is fantastic! and I
>>> hope we can continue in this new direction.
>>>
>>> However, before we started the refactoring work, I kept wondering why did
>>> we get here in the first place? We do we have lots of bad and messy code in
>>> the code base? Why are we at point where we are shifting all energies to
>>> cleaning up?
>>>
>>> So as I started working with people on the refactoring project and the
>>> answers to the above questions started to slowly appear. I list below my
>>> perception of the problems and recommendations for avoiding repeating these
>>> problems of bad code.
>>>
>>> Problem: We are very conservative
>>> ----------------------------------------------
>>>
>>> How many times did you hear this: "Don't remove that, somebody might need
>>> it" or "Oh no, you just made a regression in trunk" or "No keep it, _one_
>>> person X objected".
>>>
>>> You know ... making software is difficult. It involves taking many
>>> decisions, some of these decisions might not appeal to every person but
>>> they are necessary for the health of the project.
>>>
>>> So here is where I observed conservative behavior:
>>>
>>> - We are too sensitive to objections that even _one_ person might stop an
>>> initiative. In a way we might be a little too nice.
>>> - We treat trunk like it is almost a stable branch, and for any serious
>>> change we immediately prefer to create branches.
>>> - We _rarely_ remove anything, and when we suggest removing things big
>>> resistance happens. We suffer from "code hoarding"
>>> - We are shy about changing other people's code. Shy not because we don't
>>> know what to do, but we are concerned about making those who wrote the
>>> software displeased.
>>> - We treat code written by others like it is holy and difficult and we
>>> cannot repeat, when in fact many times we can make it actually _better_!
>>>
>>> The above observations in my opinion are the main reasons why we have bad
>>> code. We just pile up and we are so afraid of change. We don't change
>>> anything and the code as a result suffers and deteriorates. We just pile
>>> things on top of other things and do not revisit the design and try to make
>>> it better and cleaner. Sometimes revisiting the design involves _DELETING_
>>> which is a strange word in our community :)
>>>
>>> Recommendation: Shifting our mindset
>>> ---------------------------------------------------
>>>
>>> At a high level, we can say our problem is fear! How do we reduce and
>>> control fear? How do we gain confidence about making change without too
>>> much pain? Luckily many smart people already thought about these things and
>>> came up with wonderful solutions. I list hear recommendations which are
>>> inspired by these thinkers:
>>>
>>> - First we must be aware that we are conservative and accept it. We should
>>> be conscious of how apprehensive we are about change
>>> - We should have a very strong test coverage of our code and we should
>>> exercise Test Driver Development as a core philosophy in our programming
>>> methodology. Having very well tested code gives you confidence. Confidence
>>> gives you courage to change.
>>> - We should accept trunk as an _unstable software_. It is a place where all
>>> the brain storming and thinking and innovation is happening.
>>> - We should be open in expressing our opinions. Being correct is better
>>> than being nice. Mind you I'm not encouraging conflict! I am instead
>>> encouraging good technical discussions that lead to useful outcomes. It is
>>> only when people challenge your technical opinion that you really expand
>>> your horizons and learn something
>>> - For me personally, I think most importantly, we should accept _REMOVING_
>>> and _DELETING_ things. This is a natural phenomenon in all software
>>> systems. Sometimes we create something and realize later that it was a bad
>>> idea. Just Delete it!! Don't keep it hanging forever.
>>>
>>> In conclusion
>>> -----------------
>>>
>>> So OFBiz has a wonderful community and great people. However we are overly
>>> conservative, and we need to be a little more brave and willing to embrace
>>> change. Yes this will lead to some friction and at times feeling lost, but
>>> the long-term benefits far far outweigh the losses in my opinion.
>>>
>>> What do you think? I would love to hear everyone's opinion on this, and
>>> thank you again for being such supportive and wonderful people.
>>>
>>> Cheers :)
>>>
>>> Taher Alkhateeb
>>>
>
>

[Pierre Smits]

Hi Taher, all,

I love to see innovation (both process and code wise) happening within the
project as much as the next participant. But any particular innovation can
have a serious impact and can raise concerns from any contributor. These
impacts and concerns need to be discussed and addressed first, before code
changes get implemented. Especially when the innovation is controversial. I
see such as an opportunity for all.

Now though I love to see innovation happening, I cannot voice to much that
I find it deplorable that a faction of the community (the so called OFBiz
Team) plots and schemes in some kind of back room channel to get
controversial code changes in the repo, not engage with the entire
community to discuss the controversies or not start a vote before
implementation, have some of their faction starting to implementing this
kind of code in the repo and then sell it to the entire community as
something that has some kind of consensus.

And if PMC members or even ASF Members are participating in this back room
plotting and scheming without upholding the Apache Principles (not
discussing first in the mailing list of the project) from begin to end,
their actions are even more shameful and embarrassing to the project.

It seems to me that the Gradle implementation and removal of the Ant build
solution has been shoved down the throat of the community in this way. We
have had discussions in the past (IIRW at least in 2014), and we all
learned from those discussions that we couldn't reach consensus back then.
I guess that this the members faction didn't want to engage in another
discussion (out of fear or arrogance) with the entire community and wanted
to have their way.

I will not hesitate (and I have) to voice my concerns and complaints (in
private channels and publicly) about such actions to any party I know.

Pierre Smits

ORRTIZ.COM <http://www.orrtiz.com>
OFBiz based solutions & services

OFBiz Extensions Marketplace
http://oem.ofbizci.net/oci-2/

On Sat, Jul 16, 2016 at 3:38 PM, Taher Alkhateeb <[hidden email]
> wrote:

> Hello Everyone,
>
> As you already know, we have been doing major work in terms of improving
> and refactoring the framework. We are buzzing and making changes everywhere
> and people are getting excited about helping out. This is fantastic! and I
> hope we can continue in this new direction.
>
> However, before we started the refactoring work, I kept wondering why did
> we get here in the first place? We do we have lots of bad and messy code in
> the code base? Why are we at point where we are shifting all energies to
> cleaning up?
>
> So as I started working with people on the refactoring project and the
> answers to the above questions started to slowly appear. I list below my
> perception of the problems and recommendations for avoiding repeating these
> problems of bad code.
>
> Problem: We are very conservative
> ----------------------------------------------
>
> How many times did you hear this: "Don't remove that, somebody might need
> it" or "Oh no, you just made a regression in trunk" or "No keep it, _one_
> person X objected".
>
> You know ... making software is difficult. It involves taking many
> decisions, some of these decisions might not appeal to every person but
> they are necessary for the health of the project.
>
> So here is where I observed conservative behavior:
>
> - We are too sensitive to objections that even _one_ person might stop an
> initiative. In a way we might be a little too nice.
> - We treat trunk like it is almost a stable branch, and for any serious
> change we immediately prefer to create branches.
> - We _rarely_ remove anything, and when we suggest removing things big
> resistance happens. We suffer from "code hoarding"
> - We are shy about changing other people's code. Shy not because we don't
> know what to do, but we are concerned about making those who wrote the
> software displeased.
> - We treat code written by others like it is holy and difficult and we
> cannot repeat, when in fact many times we can make it actually _better_!
>
> The above observations in my opinion are the main reasons why we have bad
> code. We just pile up and we are so afraid of change. We don't change
> anything and the code as a result suffers and deteriorates. We just pile
> things on top of other things and do not revisit the design and try to make
> it better and cleaner. Sometimes revisiting the design involves _DELETING_
> which is a strange word in our community :)
>
> Recommendation: Shifting our mindset
> ---------------------------------------------------
>
> At a high level, we can say our problem is fear! How do we reduce and
> control fear? How do we gain confidence about making change without too
> much pain? Luckily many smart people already thought about these things and
> came up with wonderful solutions. I list hear recommendations which are
> inspired by these thinkers:
>
> - First we must be aware that we are conservative and accept it. We should
> be conscious of how apprehensive we are about change
> - We should have a very strong test coverage of our code and we should
> exercise Test Driver Development as a core philosophy in our programming
> methodology. Having very well tested code gives you confidence. Confidence
> gives you courage to change.
> - We should accept trunk as an _unstable software_. It is a place where all
> the brain storming and thinking and innovation is happening.
> - We should be open in expressing our opinions. Being correct is better
> than being nice. Mind you I'm not encouraging conflict! I am instead
> encouraging good technical discussions that lead to useful outcomes. It is
> only when people challenge your technical opinion that you really expand
> your horizons and learn something
> - For me personally, I think most importantly, we should accept _REMOVING_
> and _DELETING_ things. This is a natural phenomenon in all software
> systems. Sometimes we create something and realize later that it was a bad
> idea. Just Delete it!! Don't keep it hanging forever.
>
> In conclusion
> -----------------
>
> So OFBiz has a wonderful community and great people. However we are overly
> conservative, and we need to be a little more brave and willing to embrace
> change. Yes this will lead to some friction and at times feeling lost, but
> the long-term benefits far far outweigh the losses in my opinion.
>
> What do you think? I would love to hear everyone's opinion on this, and
> thank you again for being such supportive and wonderful people.
>
> Cheers :)
>
> Taher Alkhateeb
>