Navigating social media I bumped into the Capgemini Word Quality Report 2014-15. After sharing my personal data with Capgemini, I downloaded it and started reading. First of all, it is a very well written document, second the findings are interesting, I will talk about some of its puzzling conclusions some other time.
What I am going to comment on here is one small part in the chapter “Agile Testing: Growing in Acceptance, Still to Fully Mature” and in particular to the finding that the biggest challenge in agile testing according to the report is:
“Lack of a good testing approach that fits with the agile development method”
According to the report 61% of the 1432 respondents (among 1543 CIOs and IT testing leaders) claim this is an issue for their organization and among the issues this is the most widespread.
Can you see the real problem?
The problem is that 61% of the interviewed don’t know what agile testing is about, and that’s the real issue.
Agile testing is an inseparable part of agile software development how can it not fit with itself?
Do you want to know when it will not fit? It will not fit when you try to shoehorn traditional centralized independent testing approaches into an agile development team. Yes in that case it won’t fit at all, in fact, forget it, if you do that you will fail.
Do you really want to be agile? Really? Then forget about Test departments and change the culture in your organization. Software quality is everybody’s responsibility in an agile organization, embrace the change and YOU WILL FIT.
I’ve been asked the question “what are the best metrics to improve software quality?” (or similar) a million times, this blog post is a selfish time saver, you are probably reading this because you asked me a similar question and I sent you here.
Firstly, i am not a fan of metrics and I consider a good 99% of the recommended software quality metrics pure rubbish. Having said that there are a few metrics that have helped teams I worked with and these are the ones I will share.
Secondly, metrics should be used to drive change. I believe it is fundamental that the metric tracked is clearly associated to the reason why the metric is tracked so that people don’t focus on the number but on the benefit that observing the number will drive.
Good metric#1: In order to be able to re-factor without worrying about breaking what we have already built we decided to raise the unit test coverage to >95% and measure it. Builds would fail if the metric was not respected.
Good metric#2: In order to reduce code complexity, improve readability and make changes easier, we set a limit and measured the maximum size of each method (15 lines) and the cyclomatic complexity (don’t remember the number but I think it was <10). Builds would fail if the metric was not respected.
Good metric#3: In order to continuously deliver low complexity easily testable units of work and help with predictability we started measuring the full cycle time of user stories from inception to production with the goal of keeping it between 3 and 5 days. When we had user stories that took more than 5 days we retrospected and examined the reasons.
In the 3 cases above, the focus is on the goal, the number is what we think will drive the change and can always be changed.
If people don’t understand why they write unit tests, they will achieve unit test coverage without guaranteeing the ability to refactor, for example by writing fake tests that don’t have assertions. We should never decouple the metric from the reason we are measuring something.
These are the good metrics, for me. If you want to see some of the bad ones, have a look at this article I wrote some time ago on confrontational metrics and delivery teams that don’t give a damn about their customers.
When I speak to people about how it is possible to continuously deliver customer value with near zero issues, I usually get laughed at.
After I tell them that there is nothing to laugh at, people start challenging me on how I integrate with other systems, how I manage defects, how I deal with changing requirements, how I manage regression issues, and how I cope with context switching and other similar issues.
Luckily enough I have empirical data and my answers are based on experience and not some book or model I read about somewhere, so after a while I manage to get people moving from laughing at me to at least starting to be curious.
It has to be said, people become curious but deep inside they still don’t believe me and still think I am a big fool.
How could I blame them? I would have done the same a few years back. I know that people need to have to prove it for themselves to be able to believe it, I have no problem with that.
While I manage to explain my way of dealing with defects, changing requirements, regression, and context switching, until now I haven’t been able to answer the biggest question of them all, the one that every conversation ends up with eventually: how do you deal with extremely complex systems that need to scale up?
I have been thinking about this for a while now and the more I think about it the more I become convinced that Complexity is the Excuse.
Complexity exists when we are not able to prioritise the value to deliver (we don’t know what we really want). Complexity exist when we are not able to understand and describe the system we are building. And finally, Complexity is a nice excuse for not doing our job properly as software engineers and having something to blame.
The net is not complex to the spider
Reduce Complexity and stop taking excuses: 1) You want to deliver customer value, OK. You don’t need to deliver everything on day 1. Sit down with your business partners and identify the highest value added feature and focus on that one. If asked for bells and whistles, say, “we will do it later and only if we really need to”, chances are when you are finished doing the first feature you will have learned that you need something different anyway. 2) When deciding how to implement such feature, look for the simplest and cheapest solution, do NOT future proof. By future proofing you will be adding complexity and guess what? YAGNI. Measure the success of your feature and feel free to change direction, failure is learning. 3) Once you have identified the value to be delivered, make sure you break down its own complexity. If a user story or unit of work or whatever you call it has more than one happy path, then it is too complex, break it down into 2 or more units of work. 4) If you start working on something and you discover it is more complex than you had thought, then stop and break it down to less complex units, if you keep on going saying nothing, you will hide complexity and sooner or later you are bound to mess it up.
Scaling up is the wrong answer to the false complexity question.
Chances are you don’t need to scale up at all: Read 1 and 2 again and again, you will find out that you don’t need as many resources as you thought you would. Scaling up, most of the times, is the easiest, most expensive and laziest approach to fight complexity.
For doing 1) and 2) in a structured manner I strongly recommend an approach called Impact Mapping devised by Gojko Adzic, it works. For doing 3) click here For doing 4) use your head
TL;DR: stop blaming complexity when you don’t understand what you are building
When I joined PaddyPower in October 2012 I was asked to improve quality without affecting throughput. I studied the teams for a couple of months and I came up with this model based on Gojko Adzic’s Specification By Example and a white paper on ATDD from Elisabeth Hendrickson.
One year after, the bugs are a distant memory and cycle time has been almost halved, so I thought sharing the approach might be useful to somebody out there.
Here we go!
Acceptance Test Driven Development
Acceptance Test Driven Development is about people, communication, collaborationand deliveringbusiness value.
ATDD is a software development methodology based on enhanced communication among its actors.
ATDD uses high communications processes and tools to help developers write tests in a business language understandable by all actors. Such tests help developers focus on what to code. The tests can be automated and represent the blueprint of the application being developed. The tests live with the code never getting out of date. Any deviation between tests and application is communicated to the team in the form of a failing test. ATDD sits very well with many agile software development approaches including Scrum and Kanban and with XP engineering practices.
The Actors
ATDD Actors
Activities Artifacts and Goal
Acceptance Test Driven Development can be described using 4 activities (Discuss, Distill, Develop, Demo) 4 artifacts (User Story, Examples, Tests, Working Software) and 1 goal (Business Value). Each activity takes as input an existing artifact and produces as output an evolved version of such artifact until the goal is reached as explained in the Business Value Evolution train picture below:
Business value Evolution Train
The starting artifact is a User story, during the Discuss activity such artifact is transformed in Examples, in the Distill activity we transform the Examples into Tests, Tests are transformed in to Working Software during the Develop activity and Working software demonstrates Business Value at the Demo activity.
For this process to be successful it is fundamental that none of the activities is performed in isolation (by a single actor) . As many actors as possible should participate to any of the activities, specific actors’ requirement for specific activities are described later in this document.
One Source Of Truth
The first 3 artifacts describe requirements, the fourth is the representation in software of such requirements and the last is the final business goal. The Tests will represent the one point of truth about what it is turned into software and business value. Once the Demo is completed the User story and the Examples can be disposed and the only source of truth will be in the Tests. This is due to the fact that in the transformation the team will have learned a lot more about the deliverable than what it is described in the user story or the Examples. The tests will be updated during all activities to quickly adapt to changes and new discoveries, it is not necessary to retrofit such changes into User Stories or Examples. Tests stay forever and describe the application.
It is imperative that the Tests are at all time visible to all the actors. This means for example that having them buried into source control is not an option because business people don’t use source control.
Actors on the Train
The picture below expands on the Business Value Evolution Train by showing which Actors participate in which activities.
How it Works
Discuss
Required Artifact: User Story – We need a business requirement to start from. This doesn’t necessarily need to be in the format of a user story, and it can be expressed in any format. What is needed is a business value to be delivered.
Required Actors: At least 3 members of the Development team should participate, ideally a mix of testers developers and business analysts. Either one between Product Owner or Business Analyst need to participate to this activity.
Format: Meeting with access to a whiteboard
How it works: The Business Analyst has previously developed the user story through his conversations with the Product Owner, he will be able to explain to the other actors the user story’s business value. He will also be able to explain the conditions of satisfaction. Shared understanding of goals will guarantee the real goal is attained and not a consequence of somebody’s assumption
The conditions of satisfactions will be translated into examples, for example if the user story is about giving free delivery for customers that buy 5 books or more the initial examples might be:
5 books free delivery
4 books paid delivery
Questions will be asked and other examples might come out, for example
5 books outside Ireland paid delivery (if the product owner decides to give free delivery only for home users)
4 books and 2 CDs paid delivery
5 books and 1 washing machine free book delivery and paid w/m delivery
and so on…
By the end of the meeting the examples very likely will describe more scenarios than we thought when reading the user story for the first time and by trying to create concrete examples, few questions over the applicability of rules will be raised. If all questions have not been answered and the help of the Product Owner is required, the Business Analyst will get the answers from the Product Owner and have a quick catch up with the other actors to define the last examples. Having the product owner at the Discuss activity can make it more effective as most of the questions will be answered during the activity.
If the questions have unlocked some large uncovered areas and cannot be addressed by the Product Owner, more analysis will be required before we can proceed with the next activity.
Outcome1: Examples – Notice as the examples cover all the aspects of the user story plus those aspects that were not covered in the user story. If we add a 2 liner with the business value to the examples we have an improved version of the user story. The original user story is now out of date and can be expended.
Outcome2: The team have a common understanding of the business value of the user story
Outcome3: The discuss activity might highlight that the user story is too big to be delivered, in this case the activity will produce a list of user stories and the examples for the first one that is taken into development.
Distill
Required Artifact: Examples
Required Actors: Two members of the development team need to participate. At least one Developer needs to participate, ideally the developer that will be designing the code for this item. The second member should possibly be a tester or a Business Analyst, if they are not available, a second developer would do.
Format: Pair programming
How it works: Now that we have the examples written down, we can transform them into tests in a format that works with our test automation framework. There are a variety of test automation frameworks that support defining the tests in advance of the implementation including Jbehave and Cucumber. Tests will be written using the Given When Then format. Tests will cover all the examples that were identified as result of the Discuss activity. Extra tests could be added based on the improved understanding of the business goal.
Outcome1: Tests – The Tests cover all the aspects of the examples plus those aspects that were not covered in examples that were uncovered while writing the tests. The tests will also contain the 2 liner with the business value contained in the examples. Again we have an improved version of the examples.
Outcome2: The tests will be written in English so that every actor is able to understand and give feedback. The examples are now out of date and can be expended. The Tests represent the blueprint (documentation) for what we will eventually deliver. The tests will be highly visible and easily accessible at any time.
Develop
Required Artifact: Tests
Required Actors: Two Developers need to participate.
Format: Pair programming or Single developer writing code + Code Review
How it works: When implementing the code, the developers are following a test-first approach, they execute the tests and watch them fail. They will write the minimum amount of code required to get the acceptance tests Green. Once the acceptance tests are green he will manually verify that everything hangs together and will call another Developer or a Tester to perform Exploratory Testing. Once exploratory testing is completed and any defects fixed the user story is done and working software is ready to be delivered. While coding the developer might identify scenarios that were not identified earlier and add tests for them. Such tests need to be added to the previous set and shared with the rest of the actors. If the new scenarios identified represent a large amount of work a decision might be made that pushes the new uncovered scenarios to a subsequent user story or we could decide to deliver them.
Outcome: Working software + more comprehensive tests
Demo
Required Artifact: Working Software
Required Actors: The Product Owner and 2 members of the development team. Possibly the developer that wrote the software and the other actor that performed the exploratory testing.
Format: Meeting with large monitor
How it works: Before organising a Demo the development team needs to be sure the user story adheres to the definition of done. One very good practice is to create a demo script in which the demo facilitator writes down the steps to follow in order to demonstrate the user story business value to the product owner.
The demo should be an occasion for the development team to be proud of what was delivered.
The product owner will be able to use the Tests to validate all the required functionality has been delivered. At the end of a successful Demo, the product owner will accept the original User Story through the business value demonstrated by running the tests.
Outcome1: Business value
Benefits:
1) Shared understanding
2) Front load issue resolution => reducing defects detected at exploratory testing
3) Tests, for their nature, are specific and unambiguous. Using tests as requirements, developers will create their code based on specific and unambiguous requirements.
4) Developers can avail of the specificity of the requirements and avoid over-engineering
5) The tests are not written in a technical language and can be reviewed/discussed/improved by anybody with some business domain knowledge. Everybody can participate in designing the application by collaborating in defining the tests.
6) The tests are the one source of truth for the application’s behaviours. The acceptance tests live with the code and are executed in CI, they will always be up to date unless the application diverges. The tests are the application documentation. With new functionality come new tests or old tests get adapted to fit the new behaviours.
7) Increased communication builds trust and alliances between the actors
8) Increases transparency; the tests content and results are shared, easily accessible and have high visibility among all actors.
Pleasant Side Effects:
1) Acceptance tests are automated and as such they grow into a comprehensive regression suite
2) Can help Impact analysis. If we want to assess the impact of a change on our application we can simulate that change and verify what pre-existing behaviours it affects by reading the acceptance test results.
3) In the not so uncommon scenario of a re-write, if the original application was written using ATDD it is now possible to recreate the old functionality that needs to be transferred by reusing the Acceptance Tests
Acceptance Tests add no value and can be counter productive when…
1) When we write Acceptance Tests for anything but new deliverables
2) When we write Acceptance Tests to create a regression suite of an existing application
3) When we confuse Acceptance Tests with the tool for writing Acceptance Tests
4) When we write Acceptance Tests that do not give fast feedback
5) When we write Acceptance Tests that are brittle and difficult to maintain
6) When we write Acceptance Tests that contain variables and parameters
7) When we write Acceptance Tests that contain unnecessary detail
8) When we write Acceptance Tests that do not focus on what the change is but on how to exercise such change
9) When we write Acceptance Tests that test the application using the UI when the change is not in the UI
10) When we write Acceptance Tests in isolation and we hide them in source control
11) When we write Acceptance Tests as workflows/scripts
I have been working with agile teams for a few years now and I have used a flavour or another of BDD almost since the very start of my journey. Like everybody I used it badly at the start, misunderstood it and made a mess of it for a good while. Unlike others I have no problems admitting it. Mistake after mistake, fuck up after fuck up I learned a lot of things and today I believe I have developed a decent approach that I will try to improve. Through these years of many failures and small successes one thing clearly emerged for me and it is I believe the true value of BDD.
To me BDD is about communication, collaboration and delivering business value.
The most important part of it? The discussions you have with your team just before you write the tests.
The inherited automation, the derived documentation, the shared knowledge, the reduction in gold plating are side effects and it’s nice to have them, but the real value is in the conversations. The conversations where the team explores new grounds, the conversation where if you want to add value, it doesn’t matter how senior or technical or business savvy you are, what it counts is how much you care about your customer.
I thought that once I got away from the horrors of waterfall software development it would disappear forever. But no, the menacing SIGNOFF has made it into agile software development teams. I was at Agile Testing Days in Berlin last week and I had an incredible time talking and listening to passionate people. On the other hand, I was surprised to hear how many people still talk in term of SIGNOFFS.
Overheard in Berlin:
“The user stories need to be signed off before you can start working on them”
“…then after our signoff we can deliver the software…”
And so on
This is my definition of a signoff:
“A point in time where my responsibility ends, so for errors up to then you can blame me, after that it’s your fault and I don’t give a rats arse.”
That’s what it is, it is a Cover Your Ass activity. There is no other reason why you would want to signoff on something unless you are trying to cover your own ass and blame somebody else. The fans of the Cover Your Ass manifesto are also the ones that would sing off on anything.
What’s the value of a signoff to our customers?
Signoff by High Five at the Dublin Java User Group
0 – Zero – Nil
What’s the value to the development team?
Less than zero because signoffs cause finger pointing and blame games
So, why the hell do we do signoffs?
I don’t know.
One thing I know is that the agile manifesto (among other things) says:
Customer collaboration over Contract Negotiation
That in my head translates into
Shared activities over Signoffs
In my team we have started a new trend, it’s called “Signoff by High Five”, it works like this: You get 3 people (possibly the 3 amigos) and you get them working on a task, for example writing a user story. They work together and when
Our senior dev signing off on testing
they are finished they go: are we happy? Yes! “High Five!”
At this point you don’t need to have a document with a checklist and a signature of somebody to blame, you simply need 3 people agreeing and one simple “High Five”.
We also do this when we do exploratory testing together, at a certain point we look at each other and we know there is nothing more that we can do to add value then it’s “High Five!”
Sometimes we do that at the end of a demo, the high five there means the story is accepted.
So what happens if there is a problem and a bug appears on software we had wrongly high fived? Not much, we just worry about repairing the issue as soon as possible and delivering the missing value to our customer, no need for arguing over who fucked it up and how we can punish him. What we do is deliver value, that’s what we care about.
When I know that I don’t know something, it’s a really easy situation, I can study and research to remove the ignorance factor and eventually I will know that thing I didn’t know. This is called first order ignorance, I know what I don’t know.
Homer doesn’t know what he doesn’t know
The second order of ignorance is a bit more tricky, in fact it can be described with “I don’t know what I don’t know”. For example you are estimating a piece of work and what can happen is that your estimates cannot cater for what you don’t know that you don’t know. Being a bit moire specific, say you are estimating writing a new feature that allows your customers to buy tickets for the cinema. You probably know that you need customers, you need a movie, you need a movie theater and a date. What you might not know is that for instance some of the movie theaters are roofless and attendance might depend on whether the sky is full of stars or there is a full blown storm over the screen. Not knowing this you won’t initially estimate the work required for reimbursing the customers that stayed at home during the storm. You will more than likely find out about this either while you are working on the software thanks to an occasional “WTF? moment” or if you are unlucky when you get people knocking at your door because they want their money back. There are quite a lot of things that we can do to try to limit the negative impact of second order ignorance, like doing risk assessment, or breaking down the complexity in many small stories. This won’t guarantee you remove it but will help in many cases. One thing that we always need to keep in mind is that “we don’t know what we don’t know” so deep inside we know that estimates are only there as a placeholder for people that are obsessed with dates, but deep inside we know that they have no real value.
This guys was very confident, an example of third level ignorant
Then there is a third order of ignorance, and I would describe it as “I don’t know that I don’t know what I don’t know”, basically “false confidence”. This can be extremely dangerous because third level ignorant people make a lot of confident statements because they have no clue that there might be something they don’t know, but when it hits, like Homer once said “Forget it Marge, It’s Chinatown!”
…doing a workshop on ATDD to new hires that are enthusiastic and participate actively making the experience fulfilling.
Myself and my colleague Mary Walshe gave our now traditional ATDD workshop to PaddyPower’s latest new hires and the atmosphere was great, everybody wanted to participate and learn, it just felt great.
Even more satisfying is seeing their answers to the “what did you learn today?” question on post its. They really got it!
People moan, it’s a natural thing. It is a way of reacting to difficult situations where we are not able to change outcomes. By moaning, we feel some relief in sharing our discomfort with our friends, family and colleagues.
I confess; I have a problem with moaners because I don’t believe there is anything positive about it and it doesn’t really cut it for me. If I am not happy about something and moan about it, I normally become angrier rather than feeling any better. If I am really unhappy about something I would rather rant for 5 minutes, than moan all my life.
People see you like this
I am sorry to say it, but testers are in my experience the worst category of moaners in IT, maybe at pair with tech support people, but I’ll focus on testers here because I am one.
Testers moan about developers that don’t understand the customers, moan about business analysts that can’t write requirements, moan about managers that don’t give them enough resources, moan because they talk and people don’t listen, moan because sometimes they are paid less than developers, moan because the environment is not working, moan because they find bugs, moan because they don’t find bugs, moan because the application is delivered late to them, moan because the quality of the application is not to their standard and find just about another thousand reasons to moan about.
While I can understand moaning coming from a junior or mid-level tester that has say 1 to 8 years’ experience, I cannot understand, accept or condone a tester calling himself a “senior practitioner” that moans about any of the above.
Senior practitioners are like moaning rock stars, they have all they need but keep on moaning
One simple reason: a real test practitioner is able to face up to every single one of the moaning causing issues and is well able to change them.
Dear senior test practitioner, It is not acceptable that if management doesn’t give you enough resources, you are not able to influence them into understanding that they are making a mistake and need to release more resources, it is not acceptable that the developers don’t understand the needs of the customers and you are not able to come up with a solution that can minimize or even completely resolve the issue.
It’s NOT acceptable.
If you want to call yourself a senior practitioner, then act like one; influence and change the environment you are not happy with. What’s the point in moaning? You will bring down the rest of the team with your negative whiney attitude, won’t resolve anything and will piss off everybody else outside your team that is so unlucky to have to listen to you.
Senior Moaner – “Yes but management don’t understand!”
This is the ultimate answer of every senior moaner. The reality is different though, in fact 60% of the moaners didn’t even talk to managers to suggest a solution, 15% of them have tried and failed because they weren’t able to make their point and influence management, 20% have tried but management were right all along and they keep on moaning hiding the truth, finally 5% of them have tried repeatedly and appropriately to influence managers, but management are actually stupid and don’t understand.
Moaners Distribution among Senior Test Practitioners
Now look at that chart, where are you? If you are in the 5% that already did everything they could, but hit a rubber wall, then I suggest you change job before your moaning alienates you from the rest of your team mates, your wife and friends, in the other 95%, simply stop moaning, do something meaningful with your job, be brave and BE THE CHANGE you moan about!
1st reason: The hardest conversation you will ever have is with somebody that blindly believes a practice applies to every context and it is always valid, no matter what. There are 2 ways out of the conversation, agree with your interlocutor or kill him. I don’t like either option (even though I am often tempted by the second) so I end up trying my utmost to use reasoning and examples, but I miserably fail in 99.99% of the cases, eventually become exhausted and retreat in a personal comatose space where I refuse to discuss the issue any longer. #WinByExhaustion
2nd reason: Think religion. If you are roman catholic like me, then the Bible is your best practice manual. The Bible thinks for you, you simply follow and if you doubt something then you are an infidel that should be excommunicated (who cares?) or worse silenced and sometimes burnt at the stake, don’t you love it? Some names come to mind including Galileo Galilei that was intelligent enough to refuse his own belief, but if you want a more detailed list have a peek here: http://en.wikipedia.org/wiki/List_of_people_burned_as_heretics.
Is this what you do to different thinkers?
The thing is, you cannot innovate if you believe in best practices, because according to the best practice you don’t need to innovate. Did the roman catholic church evolve? Did they innovate? Fuck no! They are stuck to the day that poor Jesus Christ (God bless his soul) died on the cross and his followers started writing about him. #NoInnovation
They have them, they are very well hidden and they are too nice to use them against us: TRUTH
3rd reason: Best Practices are your #1 personal growth enemy. I see extremely intelligent people that have best practices so ingrained in their DNA that refuse to accept every valid reason, no matter what the evidence is. These people are the ones that will lag behind, because for example 20 years ago they might have said “what’s the fuss with this Internet thingy, business is run in factories and shops, you won’t make money with it, unless you are a porn site provider”. Today I hear financial experts saying “Forget about Bitcoin, money is money and people want it in their wallets and regulated banks”.
#GreatThinkingBro
4th reason: Best practices are the antithesis to kaizen, do I have to say more? #YoureStuck
Become Better, be the change
5th reason: Best practices deny men the greatest pleasure of them all, discovery. The day that you switch your brain from following the best practice is the day you might discover something awesome about yourself. The day you start listening to the person you are talking to without having the mental block of the best practice that doesn’t allow you to agree with him. That day you will grow. The day you will say “eureka!”. The day you will discover you are FUNDAMENTALLY WRONG. I love those moments, they make my brain go at 200 miles an hour and in a day I grow more than in 10 years. #NoEureka!
Everything’s squared away
To finish I wanted to thank a few people that helped me reach the “eureka!” moments, you are the reason why I have evolved and I am a better person today than I was before.
In no particular order:
Monica Campardo, Emmet Townsend, Diego Armando Maradona, Roberto Lo Giacco, Gojko Adzic (twice!), Don Gabriele, Aunty “Zia” Enrica, Lisa Crispin and Janet Gregory (books), Mary Coyle, Giacomo Leopardi (poems), My high school Maths teacher (I don’t remember his name but was known among students as “il Roscio” => “The ginger”), Eric Ries (books), Barry O’Reilly and the other guys in ThoughtWorks, Jayne McCormack, My Brother Duccio, Evariste Galois (books), Gianluca Perazzoli, Gerard M. Weinberg (books), My lovely sister in law Luana, My Nana (highest amount of times), Martin Fowler (blog), Gandhi (life and quotes), Auntie Ada, Massimo Troisi (movies), Roy Phillips, Roberto Benigni (movies), Dan North, The “Dude” in the Big Lebowsky
I thank you all with all my heart for proving me FUNDAMENTALLY WRONG that day, and inspiring me to become a better person. I might have forgotten one or two, sorry folks.
Do you want to be in the list? Prove me FUNDAMENTALLY WRONG and give me a “eureka!” moment, I will love you forever!
The “Dude” proved me wrong when I thought I had to be a serious and stiff arsehole to be liked by people
mysoftwarequality 
