Cultural learnings of testing for make benefit glorious nation of startup
•Download as PPTX, PDF•
1 like•450 views
The document discusses the importance and benefits of software testing. It notes that adding features, fixing bugs, and refactoring code requires testing the entire application due to the risk of introducing new bugs. Two types of testing are discussed: QA testing, where code is passed to QA after development, and developer testing, where testing is integrated into the development process through techniques like test-driven development. Developer testing provides benefits like confidence in changes, agility through faster release cycles, and ability to evolve requirements through collaboration. The document urges both managers and developers to prioritize testing.
Recommended
More Related Content
What's hot
What's hot (17)
Similar to Cultural learnings of testing for make benefit glorious nation of startup
Similar to Cultural learnings of testing for make benefit glorious nation of startup (20)
Recently uploaded
Recently uploaded (20)
Cultural learnings of testing for make benefit glorious nation of startup
- 1. @giltayar Cultural Learnings of Testing for Make Benefit Glorious Nation of Startup November 2015
- 2. @giltayar There are 10 kinds of people Those that understand binary And those that don’t
- 3. @giltayar There are 10 kinds of people Those that understand binary And those that don’t
- 4. @giltayar There are 2 kinds of developers Those that are confident because they test everything And those that aren’t
- 5. @giltayar There are 2 kinds of product managers Those that understand why developers test And those that don’t
- 6. @giltayar There are 2 kinds of CEOs Those that understand that testing is a priority And those that don’t
- 7. @giltayar What is Software Testing? Software testing is an investigation conducted to provide stakeholders with information about the quality of the product or service under test.[1] Software testing can also provide an objective, independent view of the software to allow the business to appreciate and understand the risks of software implementation. Test techniques include the process of executing a program or application with the intent of finding software bugs (errors or other defects) -- Wikipedia
- 8. @giltayar What is Software Testing? Testing is the art of ensuring that changes in the code will not cause new bugs to appear
- 9. @giltayar
- 10. @giltayar What is Software Testing? Testing is the art of ensuring that changes in the code will not cause new bugs to appear Testing is confidence
- 11. @giltayar Why Do We Need Confidence?
- 12. @giltayar Because Developers are Shit
- 13. @giltayar “All software is a harmony of bugs” - Eli Singer
- 16. @giltayar “Coding is writing text files in foreign languages containing instructions suitable for an absolute idiot to follow” -- Stephen Nichols
- 17. @giltayar Coding Adding Features Fixing Bugs Refactoring code to make it simpler
- 19. @giltayar Adding Features: Perfect World
- 20. @giltayar Adding Features: It’s Usually More Like This
- 22. @giltayar Code Reads From File Code Contacts
- 23. @giltayar Feature: Enable Sorting By Name Code Contacts
- 24. @giltayar Feature: Adding Comments to Each Contact
- 25. @giltayar Feature: Adding Comments to Each Contact Code Contacts
- 26. @giltayar So… Adding a feature means testing the whole app
- 27. @giltayar Let me repeat that
- 28. @giltayar Adding a feature means testing the whole app
- 29. @giltayar Remember? Adding Features Fixing Bugs Refactoring code to make it simpler
- 31. @giltayar Fixing Bugs: Perfect World
- 32. @giltayar Fixing Bugs: It’s Usually More Like This
- 33. @giltayar Example: Comments Database Structure Gil Tayar Eli Singer Sergey Bolshchikov Gil Tayar He’s really great Gil Tayar This is boring Sergey Bolshchikov Best mentor ever! Sergey Bolshchikov Congratulations!
- 34. @giltayar Fix Gil Tayar 1 Eli Singer 2 Sergey Bolshchi kov 3 1 He’s really great 1 This is boring 3 Best mentor ever! 3 Congratulations!
- 35. @giltayar So… Fixing a bug ⇒ testing the whole app
- 36. @giltayar Let me repeat that
- 37. @giltayar Fixing a bug ⇒ testing the whole app
- 38. @giltayar Remember? Adding Features Fixing Bugs Refactoring code to make it simpler
- 40. @giltayar What is refactoring? Code refactoring is the process of restructuring existing computer code – changing the factoring – without changing its external behavior. Refactoring improves nonfunctional attributes of the software. - Wikipedia
- 41. @giltayar What is Refactoring? It’s making complex code simple
- 42. @giltayar One Task One Concept One Responsibility One String No Intertwining Simple Code Means
- 43. @giltayar Adding a Steve Jobs Quote to your talk makes the talk stylish!
- 44. @giltayar Why is Simple So Important? Simple Means Understandable We can only hope to make reliable those things we can understand We can only consider a few things at a time Intertwined things must be considered together Complexity undermines understanding - Rich Hickey
- 45. @giltayar Why Is Simple So Important? Simple Make Changing Things Easier We can only hope to make local changes to things that are not entwined Changes in intertwined things are global Simple things are not intertwined Complexity undermines local changes - Gil Tayar
- 46. @giltayar So Just Build It Simple! That means thinking a lot And understanding the domain before we code Understanding comes while coding, sometimes after months And change begets complexity…
- 48. @giltayar We need to constantly refactor
- 49. @giltayar Refactoring ⇒ testing the whole app Refacrtoring is a Global Process
- 50. @giltayar Remember? Adding Features Fixing Bugs Refactoring code to make it simpler ⇒ testing the whole app
- 51. @giltayar So What do We Do?
- 53. @giltayar There are 2 kinds of Testing QA Testing Developer Testing
- 55. @giltayar Or… “throwing things over the wall”
- 58. @giltayar And he tests it….
- 60. @giltayar And then he throws it over the wall to...
- 61. @giltayar QA… QA = Quality Assurance
- 64. @giltayar Remember? Adding Features Fixing Bugs Refactoring code to make it simpler ⇒ testing the whole app QA-ing
- 66. @giltayar And What Happens When QA Get Bored? They make mistakes They miss bugs Quality slips
- 67. @giltayar So What’s the Solution Get rid of QA Replace it with...
- 69. @giltayar The Best Developers are Lazy Given a repetitive task They automate it
- 70. @giltayar Testing Becomes Part of the Development Process
- 72. @giltayar And she writes the tests for the code (sometimes even before writing the code…)
- 73. @giltayar And, while coding, she runs the tests
- 75. @giltayar Remember? Adding Features Fixing Bugs Refactoring code to make it simpler
- 76. @giltayar Just run the tests again...
- 77. @giltayar I thought it was 80-20 So I checked… code: 2922 lines tests: 35623 lines Wow. 90-10 How Much Test Code vs App Code?
- 78. @giltayar What Does it Give Us? Confidence Confidence Confidence
- 79. @giltayar TDD - Test Driven Design Tests are not just for confidence Tests lead the design
- 80. @giltayar Remember? Adding Features Fixing Bugs Refactoring code to make it simpler Just run the tests again
- 82. @giltayar What Is Agile? Agile software development is a group of software development methods in which requirements and solutions evolve through collaboration between self-organizing,[1] cross-functional teams. It promotes adaptive planning, evolutionary development, early delivery, continuous improvement, and encourages rapid and flexible response to change. - Wikipedia
- 83. @giltayar What is Agile? Agile is the ability to add a feature, or fix a bug, and immediately send it to customers, so that they can feedback back and change things quickly.
- 84. @giltayar Remember? Adding Features Fixing Bugs Refactoring code to make it simpler Just run the tests again
- 85. @giltayar The Agile Cycle Add Feature Fix Bug Send to Customer Get Feedback Act on it
- 87. @giltayar So Why Doesn’t Everybody Do Testing?
- 88. @giltayar Why? Testing is hard, and developers are lazy Managers need to deliver, and testing takes time
- 89. @giltayar Testing is hard, and developers are lazy
- 90. @giltayar Fear is the Mind Killer -- Frank Herbert, Dune
- 91. @giltayar Managers need to deliver, and testing takes time
- 92. @giltayar So what to do?
- 93. @giltayar Test! Test! Test! There are now incredible tools and methodologies to help you do that! Unit testing, system testing, TDD, Continuous integration tools, github, travis. All of them on the cloud, mostly cheap, or even free! Learn! Use! Build a process! Where you cannot release a feature or a bug fix without there being tests for it. Feel ashamed if it happens, and fix it immediately. And, yes, hire QA after a while, but let her try and break the system manually, like a human, and not like a robot - she will find the tests that you have forgotten to
- 94. @giltayar To the Manager If you don’t … your release cycle will be months and you will not be agile and your business will suffer
- 95. @giltayar Test! And You Will Never Be Afraid Again To the Developer:
- 96. @giltayar
Editor's Notes
- And let me explain...
- My co-founder, the great Eli Singer, who is a profoundly cynical person, used to say that all software is a “harmony of bugs”. I completely agree. So it’s not that there are no bugs, it’s just that the bugs work so well with one another, that the software as a whole works Of course, I’m exaggerating. I think… So what can you do?
- First, understand how the developer works:
- It is what we do to make an application, whether a web app, mobile app, or desktop app
- In a perfect world, adding a feature would affect just the new feature, but not the rest of the system So, after writing the code, I can manually test the feature and see that it works, and I’m done
- But it isn’t a perfect world Let’s give an example: Web app that enables adding a list and showing by addition date How would I implement it?
- This is how - the simplest thing that could possibly work - use a file
- Let’s say I want to add a feature: sort by name Ouch. I need a db, so I need to rewrite a lot of the code in the app I need to test the whole app again.
- To each name in the list I need to add comments.
- Ahh, but now deleting a name means adding code to delete their comments. Hmm….
- In a perfect world, adding some code locally would just fix the bug. So, after writing the code, I can manually test the fix and see that it works, and I’m done
- But it isn’t a perfect world Fixing a bug may introduce problems elsewhere
- Let’s say whenever I rename my name, I lose all the comments, because the name is the key to the comments.
- To fix that, I need to change all the code that reads and displays names and comments
- I need to test the whole app again.
- Doesn’t that give you shivery goosebumps? The word Quality hums like a finely tuned Porsche, doesn’t it?
- And what does quality assurance do? Why, they assure Quality! And once the Quality is assured…. out goes the product to our users. There was this idea once that developers must NEVER QA their own stuff, because they would be blind to their mistakes, but I’ll get to that. So who tested? Who assured Quality? Why, QA engineers!
- But remember, any addition, fixing bugs, or refactoring will cause unknown bugs in unknown places, so a reliable QA engineer needs to test everything on every release
- This is called a “regression test”. This is very very very boring.
- So what does a developer do today, when she does developer testing?
- There is even a methodology where she writes the tests before writing the code (it’s called Test-First)
- She runs all the tests Mostly, the new tests will fail, because code is never written correctly.
- So she fixes the bugs, and runs again, until the new tests succeed Sometimes, the old tests fail. And that is a “regression bug”. But it is found by the tests!
- And when she needs to do the above things...
- She just does them and runs the tests again...
- Is it worth it?
- It gives us something more
- Let’s go back to how wonderful it is for the developer
- But it gives us one more benefit.
- Well, good for you! You don’t need no stinking tests. And in the beginning, this is true The product is small, and testing it manually is very fast. So you’re king of your hill! Master of your domain. And you tell yourself - when the product gets complex, that’s when we introduce tests. And the product gets more complex, but there is no clear cut time when you say you can have tests. So your manual testing gets more and more complicated and takes more of your tie. So your manager decides to hire QA. And now you do less manual testing! You’re king of the hill again! But every bug fix you do, every additional feature, makes your code base more and complicated. And when you want to write the code the “right” way, you don’t because you prefer making local changes that have as little effect as possible. And you really want to make the code simpler, to refactor, but you can’t - you’re afraid. Fear is now guiding you. You are in hell, and no chance in the world that you would get out.
- Well, good for you! You don’t need no stinking tests. And in the beginning, this is true The product is small, and testing it manually is very fast. So you’re king of your hill! Master of your domain. And the product gets more complex, and you notice that your developer isn’t very productive. So you go to him, and ask him. And he says two things: He’s spending more and more time testing, because he has to test all the time everything He’s afraid to do big changes to simplify the code, because he could break something and not notice it during testing Oh, well, you say, it’s easy to fix. And you hire QA. And for a while it helps, but then things are slow again. It now takes weeks to test. And you ask the developer, and he tells you - “yes, the code is now so complex that adding anything takes a lot of time, and needs full QA”. You ask him why he can’t simplify, and he explains that he is afraid. And those week tests turn into months, and you’re now deep in hell