Wednesday, August 9, 2023

Cargo-cult testing


  עברית

Cargo cults were a set of practices and beliefs that sprang in Melanesia post WWII, where the native population saw the westerners arrive, set up some rudimentary airfield, landing stripes, control tower, etc. and started getting supplies by planes. When the war was over, the natives tried to achieve the same results by maintaining their own airfields, trying to lure the gods to send them food and weapons as well. They were missing only one part: The people sending supplies from the other side of the airplane flight. Since it was coined, this term was used to indicate situations where someone is mimicking the form but missing out the essence.

And how does this relate to software testing? Well, every now and then there's a public talk on "how to get hired". Naturally, talks like this focus on people with less experience and so, eventually, someone will spurt "go and test a public website or product". Sounds legit, right? it's just like coding - you can demonstrate your skill by creating a useless pet project and present it to whomever it is you might want to hire you. 

Just like the cargo cults, however, there's only one part that's missing - The actual, professional testing. Ask any experienced tester and they'll be able to tell you that the important things are not test cases ran, bug reports written or the excessive documents produced. The real value is in the conversations you have, in bringing a different perspective to reviews, in translating between different functions, highlighting the risks and improving design by presenting just the right question at the right time. When you work (effectively) as a tester on a product you gain a profound understanding of its inner workings, of its tech stack, architecture and technical debt. You gain some insight on the business side: what's important, what's less urgent, what sort of problems we don't care enough to bother fixing and what properties of the product are the ones that help sell it. You then use this understanding in the conversations and test design.

Those parts are completely missing from the so0called "experience" you'll get if you follow such advice. If you are investing your time on that, or even on the paid version in crowdsourced testing, you might be gaining or demonstrating some technical capabilities, but you are not dealing with nor growing the core skills required in a testing position. You are not negotiating schedule difficulties, you are not involved in prioritization debates and you are smashing your keyboard without the slightest idea of the priorities of the company whose product you are testing or the entire iceberg beneath the nice looking website you chose as your target.

 

Or, if we sum it all in a click-baity fashion: Good software testers shouldn't waste their time testing.

על בדיקות ועל כתות מטען


 English

כתות מטען הן תופעה שצצה במלנזיה בעקבות מלחמת העולם השנייה. התושבים הילידים ראו את האדם המערבי מגיע, בונה שדות תעופה, משרדים, מגדלי פיקוח ומסלולי נחיתה  ובעקבות זאת מצליח לגרום לאלים (או לרוחות האבות) לשלוח לו אוכל, נשק ומשאבים נוספים. כשהחיילים עזבו, הילידים ניסו לחקות את מה שראו כדי לגרום לחלק מכל השפע הזה להגיע גם אליהם. היה חסר להם רק חלק קטן אחד - האנשים בצד השני של הטיסה שבנו את המטוס ומילאו אותו בכל הציוד הנדרש. מאז שהביטוי הזה נטבע הוא משמש כדי לתאר מקרים בהם מישהו מחקה את הצורה אבל מחמיץ לחלוטין את המהות של מעשה מסויים. 

ואיך כל זה קשור לבדיקות תוכנה? ובכן, מדי פעם אפשר למצוא באינטרנט (ובמקומות אחרים) הרצאות עם הנושא החשוב "איך למצוא עבודה". באופן די טבעי, חלק נכבד מההרצאות האלה יעסוק במי שאין לו ניסיון. יש כל מיני דברים שאנשים חסרי ניסיון יכולים לעשות, אבל מתישהו מישהו יפלוט אמירה בסגנון של "בחר לך איזה אתר אינטרנט ולך לבדוק אותו, כתוב תוכנית בדיקות ומצא באגים". ככה, לפחות על פי הרציונל, יהיה לנו מעין "תיק עבודות" שנוכל להראות. 
עצה טובה, לא? הרי זה בדיוק מה שמתכנתים עושים. הם לוקחים בעיית צעצוע שלא חשובה לאף אחד וכותבים קוד בסיסי שמטפל בה. ככה הם מראים כמה הם יודעים למי שאולי ירצה לראיין אותם. 

כמו במקרה של כתות מטען, חסר פה רק חלק קטן אחד - בדיקות תוכנה מקצועיות. כל בודק תוכנה מנוסה ידע לספר שאת רוב הערך משיגים עוד לפני שכתבנו או הרצנו בדיקה אחת. שזה לא חשוב כמה יפה כתובה תוכנית הבדיקות או כמה מפורט הבאג שפתחנו. מה שחשוב זה השיחות שיש לנו מסביב כשאנחנו מתכוננים. זו השאלה שנשאלה בדיוק ברגע הנכון כדי לשנות לחלוטין את איך שמפתחים פיצ'ר וחסכה לכולם מלא שעות של תסכול, זו הפרספקטיבה השונה שמביאים לסקירת הדרישות או העיצוב, אלה שיחות המסדרון בהן חושבים יחד עם המפתחים על דרך טובה לפתור איזו בעיה. זה כשאנחנו מתפקדים כמתרגמים או כשאנחנו מסתכלים על "מה יכול להשתבש" במקום על "איך לגרום לזה לעבוד". הם ידעו לספר שכשעובדים כבודקי תוכנה ועושים את העבודה היטב אנחנו לומדים המון על המערכת הנבדקת ועל איך היא בנוייה. על הארכיטקטורה שלה ועל המוזרויות של הספריות הספציפיות בהן היא משתמשת, על האילוצים הטכניים ועל הדברים שנשברים באופן תדיר יותר. אנחנו גם לומדים קצת על הצד העסקי - על אילו תלונות מגיעות מהלקוחות שלנו, על מה חשוב לנו מספיק כדי לעצור גרסה או אילו תכונות עוזרות לנו למכור את המוצר על פני המתחרים. מה דחוף וממה לא אכפת לנו בכלל ולא נתקן גם אם הוא שבור. אנחנו מנצלים את כל הידע הזה בתכנון הבדיקות ובשיחות שלנו עם אנשים. 

החלקים האלה נעדרים לחלוטין מ"תיק העבודות" שנוכל לבנות אם נעקוב אחרי העצה המטופשת הזו. אם אנחנו משקיעים זמן בדברים האלה, או אפילו מצטרפים לפלטפורמת בדיקות המון ומקבלים דמי כיס על בניית תיק העבודות. בהחלט יכול להיות שנוכל לשפר ולהדגים כמה כישורים טכניים, ואפילו כאלה שנמצאים במודעות הדרושים, אבל צריך לזכור שזה לא נוגע בכישורים הספציפיים של בדיקות תוכנה. במצבים האלה אנחנו לא נגיע לדיונים על סדרי עדיפויות או על מה אפשר לא לבדוק, לא נצטרך להתווכח על תכנון תאריכים ולא נדע אם המשוב שלנו הועיל למישהו. פשוט חבטנו קצת על המקלדת בלי שיש לנו מושג ירוק מה חשוב לחברה. הסתכלנו על קצה הקרחון שחשוף באתר האינטרנט בלי שיש לנו גישה לכל הקרחון העצום שמתחת לפני השטח של האתר החמוד שבחרתם לעצמכם כקורבן. 

 או, אם לסכם את כל הפוסט במשפט קצר ורק קצת מוקצן - בודקי תוכנה טובים לא מבזבזים את הזמן שלהם על בדיקות. 

Friday, July 28, 2023

פשוט אמרו לא


 ENGLISH

לפני חמש שנים כששמעתי על הסילבוס החדש של ISTQB CTFL הקדשתי לו את הזמן, קראתי וכתבתי עליו ביקורת. במאי השנה, אותו ארגון ממש הוציא את גרסה 4.0 של הסילבוס הנ"ל, ואחרי ששמעתי עליו מאחד האנשים שהשתתפו בשלב ההערות והעריכה החלטתי להקדיש את אותו המאמץ כדי לראות אם המסמך החדש שעבר כל כך הרבה שיפורים אכן טוב יותר. אחרי הכל, מסיבות שאינן לחלוטין ברורות לי, יש כמה אנשי מקצוע טובים מאוד שמשייכים את עצמם לארגון הזה, ואולי הם הצליחו להוציא משהו סביר תחת ידיהם. 

כבר בהתחלה, אפשר לשים לב לשיפור אחד ניכר - המסמך החדש קצר יותר. במקום 76 עמודי תוכן ממשי (לא כולל מראי מקום, זכויות יוצרים ושאר מילוי תוכן שאין טעם לקרוא) יש הפעם רק 50 כאלה, מה שיכול להסביר איך הצלחתי לסיים את קריאת החומר בתוך שעה ו55 דקות בהשוואה לשלוש ומשהו שעות שזה לקח לי בפעם הקודמת. הפעם, כיוון שחלק מהקריאה התבצע ברכבת, לא מדדתי את הזמן באמצעות פומודורי, אלא בעזרת כלי בשם super productivity שאפשר לי למדוד זמן שהקדשתי למשימה הזו. באופן משעשע, סיימתי את הקריאה עם מספר דומה של הערות שוליים שכתבתי לעצמי (59 הפעם, כלומר שתיים יותר) וכמו בפעם הקודמת - רוב ההערות היו שליליות. המסקנה הבסיסית שלי אחרי קריאת הטקסט - זו עדיין פיסת תוכן מאוד לא טובה ואני בטוח שכל אחד מהכותבים (וקל וחומר כולם יחד) יכולים להוציא תחת ידיהם משהו טוב יותר. 

כמו בפעם הקודמת, הבעיה המהותית היא במודל העסקי ובהנחות שהוא כופה על המסמך. כדי ללמד נושא שלם בפחות מ19 שעות (שעתיים ועשרה יותר מאשר בסילבוס הקודם!) צריך לסמוך על המון ידע מוקדם, או לעשות עבודה גרועה במיוחד. חלק מהנושאים שמוזכרים בסילבוס בקצרה הם מורכבים ורב מימדיים, מה שאומר שצריך זמן כדי להפנים אותם ולהפוך אותם לכלי יעיל. לצמצם את הכל לכדי משהו שאפשר לשאול עליו 40 שאלות אמריקאיות בלי להניח ידע מוקדם של הנבחנים? שום סיכוי בעולם. 

אילו היו מכוונים לאנשים עם ניסיון (כמו, למשל, שעושים ISC2 עם הסמכת  CISSP) הייתה יכולה לאפשר למסמך הזה להיות ממוקד יותר ולפתוח נושאים לדיון גם במסגרת הזמן המוגבל שמקצים בו. כפי שהמצב כיום, הסילבוס מנסה להיות גם מבוא לעבודה בחברת תוכנה וגם לתאר את הליך הבדיקות הכבד והמתיש ביותר שניתן לדמיין (הם נעזרים לשם כך ב IEEE 29119, שעל המחלוקת סביבו אפשר לקרוא בויקיפדיה). מה לגבי להזכיר שזה בסדר להתאים את התהליך ושלא חייבים להשתמש בכל הארסנל הכבד הזה כדי להרוג זבוב? להסביר מתי נכון להימנע מחלקים מסויימים ומה הערך שהם מוסיפים במקרים אחרים? בשביל מה? למה לא להעמיד פנים שהדבר המיותר הזה הוא הסטנדרט שראוי להתיישר סביבו? הרבה יותר מצחיק ככה. 

המסמך הזה הוא שינוי דרמטי למדי ביחס לגרסה הקודמת (כמו שאפשר להבין מקיצור היריעה) ויש בגרסה הזו כל מיני דברים חדשים. קודם כל, יש שיפור ניכר בבאזזוורד בינגו - מונחים כמו דבאופס, CI\CD או הזחה שמאלה נזרקים לחלל המסמך כאילו אין מחר. באופן טבעי, אלו מילים חלולות. 

אבל, גרוע אפילו מזה הוא היחס שמקבלים כמה מונחים שנעדרו מהסילבוס ונפוצים בקרב בודקי תוכנה. ספציפית, ההתייחסויות לפירמידת הבדיקות ולמרובע הבדיקות האג'יליות. שני המונחים נמצאים, מסיבה עלומה כלשהי, תחת הקטגוריה "תכנון בדיקות". למה? ישנם, הורציו, בשמיים ובארץ, דברים שנפלאו מדעת חכמיך.
כנראה שתיאור הפירמידה הוא התיאור הכי גרוע שנתקלתי בו עד היום. מעבר לכך שלא טורחים להסביר איך המודל הזה שימושי אלא פשוט מתארים אותו באופן גרוע. ואז, מגיע הדבר הזה:

Tests in the bottom layer are small, isolated, fast, and check a small piece of functionality, so usually a lot of them are needed to achieve a reasonable coverage. The top layer represents complex, high-level, end-to-end tests. These high-level tests are generally slower than the tests from the lower layers, and they typically check a large piece of functionality, so usually just a few of them are needed to achieve a reasonable coverage.

בעוד שהתיאורים פה הם טכנית נכונים, האם הבחנתם בכך שהטקסט בעצם שולח את הקורא להשוות בין הרמות השונות ולטעון שאפשר להשיג את אותה רמת כיסוי (של מה?) בעזרת הרבה בדיקות קטנות או מעט גדולות? האם הבחנתם בכך שזה נעשה במקום לציין איך שהשכבות השונות אמורות לפעול בסינרגיה?

הטיפול שמקבלים הרביעונים האג'יליים אפילו גרוע יותר, אם דבר כזה אפשרי. במקום להשתמש במודל כפי שהוא מיועד להיות - מודל תיאורי שנועד לעזור לנו לאתר נקודות עיוורון ביחס שלנו לבדיקות, הופכים את המודל הזה לסט הנחיות לביצוע. למשל:

Quadrant Q1 (technology facing, support the team). This quadrant contains component and
component integration tests. These tests should be automated and included in the CI process

באופן לא מפתיע בכלל, הטיפול של הסילבוס בבדיקות חוקרות ממשיך לסבול מחוסר הבנה קיצוני של המושג. הראיה הברורה ביותר? בדיקות חקר מתוייגות כ"טכניקת בדיקות", אחת מכמה טכניקות "מבוססות ניסיון". בדיקות חוקרות אינן לא זה ולא זה. בראש ובראשונה, זו אינה טכניקה, אלא גישה מקיפה לבדיקות תוכנה - כזו שאפשר להפעיל בעזרתה כל טכניקת בדיקות שתרצו (ספציפית, באך ובולטון גורסים שכל הבדיקות הן בדיקות חוקרות), ובנוסף, בדיקות חוקרות אינן "מבוססות ניסיון" יותר מאשר הגישה לפיה מנסים לכתוב את כל הבדיקות מראש. ההבדל המרכזי הוא בכך שאנחנו מכירים בעובדה שבודקי תוכנה מנוסים ישיגו תוצאות טובות יותר ולא מנסים להעמיד פנים שמעקב אחרי האלגוריתמים שהזכרנו יוביל לתוצאות זהות גם אצל עובדים לא מיומנים. בסופו של יום, כל הטכניקות הפורמליות שמוזכרות בסילבוס נמצאות בתוך סט הכלים של הבודק גם במהלך חקירה, ועליהן מוסיפים כמה יוריסטיקות שזמינות רק במהלך ביצוע הבדיקות. 


אז לסיכום,
להסמכת CTFL עדיין יש קורלציה שלילית ליכולתו של אדם לתפקד היטב כבודק תוכנה מקצועי. הסילבוס עדיין מקדם  מגוון תפיסות שגויות לגבי בדיקות תוכנה - בין אם הטענה על כך שנדרשת "עצמאות" של גוף הבדיקות ("accelerate" כבר השליכו את הטענה הזו מהחלון לגבי רוב המקרים), שמציאת באגים היא אחת המטרות של בדיקות תוכנה או שהדרך הנכונה להתקדם היא בעזרת תהליך ארוך וכבד. הסילבוס עדיין מתמקד בתיאור של איך דברים נראים באופן שטחי וכמעט ולא מתייחס לשאלה "כיצד נכון לעשות" ואין בו אפילו זכר לשאלה הכי חשובה "למה עושים" (למעשה, הנקודה היחידה בה שואלים למה היא "למה חייבים לבדוק תוכנה", וזה דווקא המקום בו צריך לשאול - מתי צריך לבדוק ומתי לא). הסילבוס עדיין לא עוזר לבודקי תוכנה לתקשר עם אנשים מחוץ למקצוע, ולמעשה מקשה על התקשורת בכך שהוא משתמש בחלק מהמונחים בצורה שונה מזו שמקובלת בתעשייה. הוא עדיין מתמקד יותר מדי בתוצרים ומסמכים מיותרים ולא מספיק בתועלת שאמורים להשיג בזמן הכתיבה שלהם, והוא עדיין מכוון כדי לאפשר לאנשים לא מיומנים עם אפס הבנה של התחום לנפנף בחתיכת נייר חסרת משמעות ולהציג אותה בפני מעסיקים עתידיים.

או, ממש בקצרה - זו עדיין תרמית.

still not polished.

 

5 years ago, I welcomed the new release of ISTQB CTFL new syllabus with an honest (if a bit hostile) reading. This may, ISTQB have released version 4.0 of the CTFL syllabus, and after hearing about it from a colleague, I thought to myself that it would only be fair to give it the same respect. After all, for reasons unbeknownst to me, there are some very good professionals who identify with this organization, so maybe they have managed to get something decent from under their hands. 

There is one significant improvement in this version only 50 pages of non-skippable content (such as refrences, appendices, copyright and the like) compared to 76 in the previous one, which can explain how I managed to go over it in 1 hour and 55 minutes (this time, as I was reading in the train, I did not use pomodoro, but rather a time tracking software name "super productivity"). Amusingly, I ended up with a similar number of comments (59, compared with the 57 from last time), and my conclusions are still the same - it is a terrible piece of content, and I'm sure that each and every one of the people who were involved with it (let alone all of them together) could produce something better from under their hands. 

as before, the underlying problems are the business model and the assumptions it forces on the document: Teaching something in less than 19 hours (which is still 2 hours and 10 minutes more than 2018), must either rely on previous knowledge or experience or be extremely shallow and inefficient. Some of the topics mentioned in the syllabus are multi-faceted and complex, grokking them takes time and practice. Narrowing it to a 40 multiple-choice questions for people without any prior knowledge? that's simply impossible to do. 

Aiming to people with some experience (and adding this as requirement to the certification, in a similar manner to what ISC2 does with its CISSP certification) would enable much more focus to this document. As it is, though, the syllabus still tries to be an introduction to working in tech and a description of the heaviest test procedure fathomable (Heck, they even mention the notorious IEEE 29119). Mentioning that it's ok to tailor it to your needs? nah, why not pretend it's the golden standard? much more fun this way. 

As this document is a major revamp of the previous, there are some new things in this version. The buzzword bingo is even more noticeable. With terms such as shift-left, devops, CI/CD sprinkled just about everywhere. Naturally, it's devoid of meaning. 

Even worse is the homage to some other terms that are by now well established in the testing profession. Those would be the test-pyramid and the agile testing quadrants. both terms are oddly placed under the section of test planning. Why? There are more things in heaven and earth, Horatio. 


Their description of the pyramid is probably the worst botch I've seen in trying to describe or use it. Its existence is mentioned, but we skip completely questions like "how to use it". Then comes this: 

Tests in the bottom layer are small, isolated, fast, and check a small piece of functionality, so usually a lot of them are needed to achieve a reasonable coverage. The top layer represents complex, high-level, end-to-end tests. These high-level tests are generally slower than the tests from the lower layers, and they typically check a large piece of functionality, so usually just a few of them are needed to achieve a reasonable coverage.

 while most of it is technically correct, have you noticed how they shift the whole issue to a comparison of "how many are needed to get full coverage" (one might also ask, coverage of what?) instead of mentioning that those are completing each other, or that this is an observation on what a healthy set of tests usually looks like, it's now hinting that you can get the same done with a few large tests as you can with a lot of smaller ones.

Treating the agile testing quadrants is even worse: instead of treating it as an observational, descriptive model that can expose some gaps in the way we think about tests or in what we actually implement, in the hands of the ISTQB authors, it has become a prescriptive model.
for instance:

Quadrant Q1 (technology facing, support the team). This quadrant contains component and
component integration tests. These tests should be automated and included in the CI process

Naturally, the ISTQB treatment of exploratory testing still represents an utter lack of understanding of it. It's still treated like an after-thought, not really planned testing, and it being placed under "experience based techniques" is probably the best sign of this misunderstanding - it's not a technique, it's a complete approach to testing, and it is not any more "experience based" than the approach where we try to write our test plans ahead of time. The main difference is that the exploratory testing approach admits that experienced people perform better. During exploration we employ all of the formal looking techniques that can be performed ahead of time, as well as other heuristics that are more readily available during test execution.

so, summing it up: 

CTFL certification still has negative correlation to one's ability to function in a professional testing situation. The syllabus still promotes a lot of misconceptions about testing - that it should have some "level of independence" ("accelerate" has thrown this claim out of the window for most cases) , that finding bugs is a goal and that a slow and heavy process is the best way to go forward. It still focused on telling the "what" and very rarely the "how", the most important "why" is not present at all (The only place is when the question "why is testing necessary", and there the question should be "When is it needed, and when not "). It still does not help testers communicate with non-testers, and I would say that it even hinders such efforts by choosing to use terminology in a way different than what is common in the industry. It still focuses too much on the useless artefacts produced and not on the value we should aim to get when creating them and it still aimed to enable untrained, unskilled people hold a piece of worthless paper and present it to future employers. 

Or, briefly - it's still a scam.

 

Thursday, July 27, 2023

This too is a way to learn a lesson.


 עברית

Recently we've engaged with a consulting company to help us build a product in our core business. 

A terrible idea, right?

In our defense, there were some compelling(?) arguments to act this way. We knew the risks of employing a company under contract to build something we care about, and were willing to pay the price.

So, things have started moving. As the main reason we didn't do the work was that we were too busy with other stuff happening, the consulting company has started working pretty much unsupervised for a few months. When we finally joined the effort we could see a lot of design work that has been done, with some proof of concept code for various parts - it was not a lot, but it was as much as could be expected given the requirements we gave them and our availability until then. At least, this is what I thought until I examined their "tests". Starting with a review of the code, I found a couple of robot-framework scripts that are executing a browser against the UI defined in Figma, and only running in theory. But, we are starting to work on a new project and some work has been done by the contractor, so we should at least give it the benefit of the doubt, right?

So, we had a talk and I started asking the basic questions - Where in the SDLC are those tests expected to run? against which of the multiple repositories? how should the product be deployed? how often? who are the intended authors of future tests? who are the intended consumers of the results?
Based on the work I've seen, I didn't really expect them to have answers, but I could use this to start an internal discussion about how do we want to approach testing in the new product. While it was rather easy to name the gates that a piece of code should pass on its way to production, we found that some things needed to be defined better, and that we needed to choose a lot of new technologies, or at least review the existing ones to see if they fit. 

We talked about what is a "component test", should we run full system tests on pull requests to some services, how to incorporate contract tests to our process, and so on. 

As we are trying to answer those questions we find that the decisions we make are influencing the rest of the product - from our branching strategy to the way we architecture our product and deployment. There are some difficult questions that we need to answer in a short time, but it's quite interesting so far.

Key takeaways?

First, never fight a land war in Asia. 

First, when you plan your testing strategy, take time to figure out your context - who should be doing what, what results are important, and what limitations will hinder your progress.

Second, Especially if you are a service provider, be very explicit about how you expect your work to integrate with other parts of the development process. Have a discussion about what you will need, what you will provide, and how will this impact the work of others. If you can't have a discussion, share your thoughts with the other people involved. 

Third, your choices will change the way the entire team works, it will have an impact on both the processes you employ and the architecture of your product. In this sense, it's no different than choosing a tool, a programming language or the roles of people in the team. And just as is the case in those other examples, it is a two way street and choices make there will impact how you do testing.

גם זו דרך ללמוד לקח


 ENGLISH

לפני זמן מה סגרנו חוזה בעבודה מול חברה חיצונית כדי שתוכל לפתח את אחד המוצרים שנמצאים בליבה העסקית שלנו. 

רעיון ממש רע, נכון?

להגנתנו, היו כמה טיעונים טובים(?) למדי לעשות את זה. ידענו מה הם הסיכונים שבהעסקה של חברה חיצונית והיינו מוכנים לשלם את המחיר. 

בקיצור, הדברים התחילו להתגלגל, וכיוון שהסיבה המרכזית בגללה פנינו לחברה חיצונית הייתה שהיינו עסוקים עד מעל הראש בפרוייקטים אחרים, החברה התחילה לעבוד עם מעט מאוד הכוונה או מעורבות שלנו למשך כמה חודשים. כשסוף כל סוף התחלנו להצטרף למאמץ יכולנו לראות לא מעט עבודת תכנון שנעשתה, יחד עם הוכחת היתכנות לגבי כמה מהחלקים. זה לא המון, אבל בהתחשב באיכות הדרישות ורמת הקשב שהקדשנו להם, זה לגמרי מסוג הדברים שאפשר היה לצפות להם. לפחות, ככה הנחתי עד שהגעתי לבחון את החלק לו הם קראו "בדיקות". הסתכלתי קצת על הקוד שלהם וראיתי כמה סקריפטים שכתובים בעזרת robot-framework ומיועדים להריץ כמה תרחישים בעזרת הדפדפן, והחלק הכי טוב? זה נכתב אל מול ההגדרות שהיו בfigma כי כמובן שאין שום דבר פועל שאפשר לרוץ מולו. האם זה יכול לרוץ? תיאורטית. מול מה? לך תדע. מצד שני, אנחנו רק נכנסים לפרוייקט והחברה החיצונית כבר עובדת כמה חודשים אז בטח יש להם כל מיני מחשבות ותובנות לגבי איך הכל מתחבר, לא? 

קבענו שיחה, והתחלתי לשאול שאלות - איך זה אמור להתחבר לתהליך הפיתוח? איפה ומתי הסקריפטים האלה צריכים לרוץ? מי אמור לתחזק אותם? מי אמור לקרוא את הדו"חות שיצאו כתוצאה מזה? למה בחרנו את רובוט כתשתית להרצת הבדיקות?
אחרי שראיתי את הקוד, זה לא שבאמת ציפיתי לקבל תשובות אינטיליגנטיות, אבל זו הייתה הדרך שלי לשקף להם שהם בזבזו את הזמן לעצמם ולנו, ובנוסף יכולתי להשתמש ב"הכנות לשיחה" כדי להתחיל את הדיונים האלה אצלנו. בעוד שזה היה די פשוט להגדיר את השלבים השונים שקוד צריך לעבור כדי להגיע לתוך המוצר, אבל מה בדיוק כולל כל שלב, אילו טכנולוגיות מתאימות לו ודברים כאלה - זה כבר יותר קשה. דיברנו על איך כל אחד רואה את התחום המעורפל של "בדיקות רכיב" (component tests, שבניגוד למה שמי שקרא את המילון של ISTQB עשוי לחשוב, זה דבר שונה לגמרי מבדיקות יחידה), ואיך אנחנו רוצים להריץ בדיקות חוזה ובדיקות אינטגרציה ומתי ואיפה נרצה להריץ בדיקות מערכת מלאות.

אחד הדברים שבלטו מאוד בדיונים האלה היה עד כמה צריך לקחת בחשבון את הארכיטקטורה שאנחנו רוצים לעבוד בה, ועד כמה הבחירות שאנחנו עושים משפיעות על תהליך הפיתוח ועל העבודה של כל הצוותים המעורבים. נתקלנו גם בכמה מגבלות שנובעות מהארכיטקטורה שאנחנו רוצים שתהיה למוצר, וגילינו שיש דברים שנצטרך לשפר כדי להגיע לתהליך הבדיקות שאנחנו רוצים. 

בקיצור, בזכות העבודה המחופפת של החברה החיצונית, קיבלנו הזדמנות לתכנן את תהליך הפיתוח שלנו באופן מודע ולא פשוט להתגלגל מדבר לדבר. שיעור מרתק. 

 

אז, מה אפשר ללמוד מכאן?

קודם כל, לא להשתתף במלחמה יבשתית באסיה

קודם כל, כשמתכננים את הבדיקות למוצר, קחו בחשבון את ההקשר - מי אחראי על מה, אילו תוצאות חשובות ולמי ומה המגבלות שיפריעו לנו בהמשך?

שנית, במיוחד אם אתם מספקים שירותים לחברה אחרת, היו ברורים מאוד לגבי איך אתם רואים את התהליך. נהלו דיונים על הדברים שתזדקקו להם ועל אלו שתספקו כמו גם על ההשפעה שתהיה לכם על עבודתם של אחרים. אם אין לכם מול מי לנהל דיון כזה, הניחו הנחות ושתפו אותן. העבודה שלכם תימדד, בין היתר, על בסיס ההנחות האלה. 

לבסוף, הבחירות שלכם ישפיעו על כל הצוות. הן ישפיעו על התהליכים ועל ארכיטקטורת המוצר. במובן הזה בחירת תהליך בדיקות אינה שונה מבחירת טכנולוגיה לעבוד איתה, או הגדרת התפקידים השונים בצוות. ובדיוק כמו במקרה של הדוגמאות האלה - זו דרך דו סטרית. כל הדברים עליהם תהליך הבדיקות משפיע, ישפיעו עליו בחזרה.

Sunday, March 12, 2023

Quality is a four letter word


עברית

A question that started in the ABTesting slack group and has found its way to LinkedIn was wondering about whether an unethical product, even if exquisitely built, can be referred to as "high-quality". 

This question resonated with a biff I have with the term "quality" for quite a while now. Specifically, with how it is commonly used. Since many of us have the word "quality" in our role description, many of us and of our colleagues in other software specialization are using it to indicate the sum of all desired things we might want in a piece of software. As we do that, we are shooting ourselves in our metaphoric leg. How bad is it? well, as I was writing this post, I stumbled upon this episode of the testing peers where we can hear four professionals who care about their craft, spend half an hour talking nonsense. By the end of the episode titled "what is testing" they do recognize the fact that they have not actually defined it.It is of no surprise, this term is difficult to define and is pretty vague, and as I've written in the past, it does not conform with the idea of quality in other fields. When my manger says "we have a quality problem in our product" he means one thing that is probably not the same as the product manager saying "We need to have this shipped with perfect quality", and is surely different from the now-so-common definition of "value to some person who matters" or the approaches adopted by ISO - "fitness for use" or "customer satisfaction". What we are getting when we use such an ambiguous term is a feeling of consensus that will blow up in our faces once the actual differences will start to show.

Moreover, "improving quality" is not actionable. If you actually have such a problem, you have a lot of work to do just to clarify what you actually need, and you will need to override people instinctive understanding of this term. Some people would go as far as claiming that "quality" is just about technical mastery and skillful coding. Others will stress the visibility of the product  and others yet will look at the extent in which it gets the job done. All of those are important, but we need to align in order to move forward

Another notion I've stumbled upon sometime during my career is that "quality" is just another word fro "property", which leads me to suggest talking about the specific qualities we are actually seeking in our software. It could end up being a long list, but it will enable us to align more easily, and to break the dichotomous view of "high\low overall quality" - Software (and life in general) is all about choosing the right tradeoffs, and I might go for something that looks nicer even if it is not as fast, or choose the product that preserves my privacy better over the one with more features and better integrations - we need to use a language that helps us notice these possible tradeoffs instead of concealing them under the very broad term "quality".

If "Quality" is a profane word that should not be used, what should we talk about instead? My preferred way is to break it down to different qualities, and preferably, to avoid confusion: Desired properties. What sort of desired properties are there of a software? I'll list a few here, and there are probably more that would be relevant in the various contexts one might find themselves in: 

  • Correctness: This is the extent to which the software is doing what it is supposed to do. A tax calculator makes no tax mistakes given the proper input, a game is responding to the user commands in the expected way, etc.
  • Robustness: The product can withstand messy (and even malicious) input, recover from mistakes and does so for a prolonged time. 
  • Scalability: The product can support the expected growth in a viable way.
  • Performance: Personally I lump here both the quickness of response and the resources consumed by the system, those can be separated if we are in a place to make internal trade-off (for instance, throw more hardware to get faster results without a redesign). 
  • Privacy: How well is the product protecting human data that it handles (or generates). 
  • Ease-of-use: How well can people achieve their goals with the product.
  • Attractiveness: How appealing is a product to the target audience, that would conform to what James Bach has named "charisma"
  • Explainability: The extent to which the behavior of the software is predictable or easy to explain.
  • visibility: can we figure out what happens in production? can we use that data to improve the product? 
  • Safety: will the product kill someone? Harm them in any way? will releasing a new version put us in risk we can't tolerate?

This is a partial list that can be extended with a lot of other properties (an example can be found in the paper by Rikard Edgren, Henrik Emilsson and Martin Jansson extending James Bach's  quality criteria), but one obvious thing is not on my list: Testability. Why is that? because in itself, it provides very little value. I think of testability as a secondary desired property that helps achieving the others or verify their state.Other properties in this category could be maintainability or extendability  I also don't consider process properties in this list, even though they are often more desirable than almost every bullet in my list. Things like efficiency or pace of deployment: I had to draw the line somewhere and so I chose to stick with properties that are attached to the product and not to the teams building and maintaining it.

So, next time someone asks you how to improve the quality of your product, take the time to understand what do they really mean. Are they bothered by functional problems? do we have a security problem? There's no need to go out right and tell them "don't use this meaningless, confusing word", but try to drill down using guiding questions such as "what is the most significant current concrete pain that we feel now?" or "do we want to invest now our efforts in increasing our ability to spot problems in production before our customers, or do we have more pressing matters?" get to somewhere concrete and work from there. Ask such questions again after there has been some improvements in the top priority desired properties.


איכות זו מילה גסה


English

שאלה שהתחילה בערוץ הסלאק של הפודקאסט ABTesting התגלגלה לפוסט בלינקדאין. בקיצור נמרץ, השאלה היא "האם תוכנה לא מוסרית יכולה להיחשב כבעלת 'איכות גבוהה'?". 

השאלה הזו מתכתבת עם נושא שמציק לי כבר כמה שנים טובות: בעולם התוכנה משתמשים במילה "איכות" בצורה חסרת אחריות. אולי זה כי לחלקנו יש תפקיד שהמילה "איכות" מופיעה בהגדרה שלו, או כי כולם סביבנו מדברים ככה, אבל המשמעות של המילה "איכות" באופן בו משתמשים בה היא פחות או יותר "כל מה שטוב ושום דבר ממה שרע". השימוש הזה עושה בעיקר נזקים, ובמקרים מסויימים אפילו אפשר לומר שאנחנו יורים לעצמנו ברגל. כמה המצב חמור? בעודי כותב את השורות האלה נתקלתי בפרק של Testing peers שמנסה להגדיר את המונח הזה. זו דוגמה מושלמת לאיך שארבעה אנשי מקצוע שמשקיעים לא מעט זמן בלשפר את ההבנה המקצועית שלהם פשוט מדברים שטויות. אחרי חצי שעה של קשקשת, הם עוצרים כדי להכיר בעובדה ש"בעצם, לא ממש הגדרנו מה זה איכות". תכל'ס? זה לא מפתיע  - די קשה להגדיר "איכות תוכנה". זה מושג עם הגדרה מעורפלת  שפשוט לא מתיישרת עם הגדרות מתחומים אחרים. התוצאה? כשמנהל אחד אומר "יש לנו בעיית איכות" הוא לא מדבר על אותו דבר כמו מנהל המוצר שרוצה להוציא "מוצר באיכות מעולה" ושתי ההגדרות האלה בטח לא מתיישבות עם ההגדרה הנפוצה "ערך עבור מישהו שאכפ לנו ממנו" (Value to someone who matters)  כמו שאמר ג'יימס באך בעקבות ג'רי ויינברג, או ההגדרות שאפשר למצוא בתקן ISO "התאמה לשימוש" או "השבעת רצון הלקוחות". אם ננסה לעבוד כשיש לנו תחושה כוזבת של הסכמה, זה רק יגרום לחיכוכים אחר כך,

כל כאב הראש הזה אומר ש"שיפור האיכות במוצר" זו הכרזה ריקה מתוכן, כזו שאי אפשר לפעול לפיה. אם אכן יש רצון לשפר את "איכות" המוצר, יש בפנינו עבודה לא בהכרח קלה של הגדרת התחומים בהם נרצה להשתפר. תוך כדי התהליך הזה נגלה שחלק מהאנשים מבינים את המושג "איכות" כהפגנת מיומנות - שימוש בטכנולוגיות העדכניות באופן אלגנטי ויעיל, אחרים יסתכלו על תוצאות עסקיות, או על חווית המשתמש או על מרווח בין תקלות. כל הדברים האלה חשובים, אבל כדי לזוז קדימה, אנחנו צריכים לדבר על אותו דבר. 

אבחנה מילונית נחמדה בה נתקלתי מתישהו לאורך חיי היא שמשמעות אחת למילה "איכות" היא פשוט שם אחר ל"תכונה", זה אמנם טבעי יותר באנגלית, אבל גם בעברית האמירה "יש לו מגוון איכויות" מובנת בלי להיות העתקה בוטה מדי מאנגלית. דווקא הריבוי הזה נראה לי כמו נקודת מוצא נוחה מהתסבוכת הזו. אם במקום לדבר על "איכות" נוכל לדבר על "תכונות", או אפיל על "תכונות רצויות", נוכל לשבור את הדיכוטומיה סביב "איכות גבוהה\ירודה" ולהתחיל להתמקד במה שחשוב לנו - בלבחור את האיזון שמתאים לנו.

ואם "איכות" היא כזו מילה מגונה, במה יהיה לנו נכון יותר להשתמש? כמו שרמזתי בפסקה הקודמת, אני מעדיף לדבר על מכלול התכונות הרצויות ואלו שאינן. ככה אפשר למנוע בלבול ובאשכרה להתקדם לקראת המטרה אליה אנחנו חותרים. כמובן, זה לא כזה פשוט - רשימת התכונות הזו אינה סגורה, אבל הנה כמה תכונות שנראות לי רלוונטיות במגוון מוצרים, וכל אחד יוכל להוסיף מתוך ההקשר שלו. 

  • נכונות: עד כמה התוכנה עושה את מה שהיא אמורה לעשות. מחשבון מס לא מגיע לסכומים לא נכונים, משחק מגיב לפקודות מהשלט בצורה הצפויה ודברים כאלה. 
  • עמידות: עד כמה התוכנה יכולה לתפקד לאורך זמן בעולם האמיתי, גם לנוכח משתמשים שמנסים להתקיף אותה
  • סילומיות: תכל'ס, חיפשתי באינטרנט את המילה הזו, אנשים נורמלים יקראו לזה סקיילבליות או משהו כזה. עד כמה התוכנה שלנו מסוגלת לגדול כדי להכיל את סדרי הגודל הצפויים בעתיד הקרוב והבינוני. 
  • ביצועים:אישית אני דוחס לכאן גם את התשובה לשאלה "כמה מהר" וגם את המשאבים שהמערכת צורכת. אם זה רלוונטי, אפשר להפריד את שני אלה כדי שנוכל לשלם באחד כדי לקבל את השני. 
  • פרטיות: עד כמה התוכנה מגנה על מידע אנושי שהיא נחשפת אליו. 
  • נוחות וקלות שימוש: כמה טוב אנשים יכולים להשיג את המטרות שלהם בעזרת המוצר שלנו. 
  • אטרקטיביות: כמה המוצר מוצא חן בעיני המשתמשים. ג'יימס באך משתמש במושג "כריזמה" כדי לתאר את זה.
  • נהירות:עד כמה קל לנו להסביר מה התוכנה שלנו עושה ועד כמה קל לנו לצפות את ההתנהגות שלה במצבים שונים. 
  • נראות: עד כמה אנחנו יכולים לדעת מה קורה עם המוצר שלנו בעודו רץ? האם יש לנו מידע מהשטח שאנחנו יכולים להשתמש בו כדי לשפר את המוצר? כדי לאתר בעיות?

אפשר להרחיב או לשנות את הרשימה הזו, ויש כבר מי שעשו דברים כאלה (למשל, אדגרן, אמילסון ויאנסון הרחיבו כאן את העבודה של ג'יימס באך), אבל אני רוצה להפנות לרגע את תשומת הלב לתכונה אחת שאני לא כולל בתוך התכונות שאנשים רוצים: בדיקתיות. הסיבה לכך היא שיש מעט מאוד ערך בבדיקתיות בפני עצמה. הדרך בה אני חושב על בדיקתיות היא כעל יעד עזר: זה כנראה יהיה משהו שנרצה כדי להשיג מטרה אחרת, או שזו תהיה תוצאת לוואי של תכונה קיימת (למשל, אם שיפרנו את נהירות התוכנה, ממילא שיפרנו את היכולת שלנו לבדוק אותה, ויהיה לנו קשה מאוד לשמור על רמת נכונות טובה אם המוצר שלנו יהיה קשה מאוד לבדיקה). יש תכונות נוספות שאפשר להכניס לתוך הקטגוריה הזו - כמו תחזוקתיות או יכולת הרחבה, אבל זה לגמרי עניין של מי שמרכיב את הרשימה. 
חוץ מזה, יש סוג אחר של פריטים שלא כללתי ברשימה - תכונות תהליך. דברים כמו עקביות, או צפיות (כמה אנחנו יודעים לומר מה ייקח לנו כמה זמן). זה לא שהם לא חשובים, אלא שהייתי צריך למתוח את הקו איפשהו, ולכן בחרתי להתמקד בתכונות של הקוד עצמו ולא של תהליך הפיתוח. זה גם מתיישר עם התפיסה של "מוצר איכותי" - זה לא משנה מה התהליך שהוביל ליצירת מוצר כלשהו. אם הוא טוב, אז הוא טוב. 

לכן, בפעם הבאה בה מישהו שואל "איך אפשר לשפר את איכות המוצר", עצרו לרגע כדי לחשוב למה בדיוק הוא מתכוון. האם יש לנו תקלות פונקציונליות? האם יש לנו בעיות אבטחה? האם לקוחות מתלוננים בהמוצר שלנו זוחל? כמובן, אין צורך (או טעם) לריב על טרמינולוגיה ולהתחיל להסביר "אל תשתמש במילה 'איכות', היא חסרת משמעות ומבלבלת", אבל מאוד כדאי לצלול טיפה יותר לעומק ולשאול שאלות מנחות כמו "מה התסמין הכי בולט של בעיות שיש לנו כרגע?" או "האם כדאי לנו להשקיע מאמץ בניסיון למצוא טעויות לפני הלקוחות או שיש דברים בוערים יותר לעשות?" אחרי שיש לנו כמה תשובות כאלה, אפשר להתחיל לעבוד. על הדרך, בזמן רגוע יותר, אפשר להתחיל לדבר על התכונות שמרכיבות "איכות" מבחינתנו.