Friday, February 12, 2016

First day at ETC2016

(no Hebrew, it will come later, I hope).
So, My first day at ETC2016, and what a day it has been!
I'm still recovering from the amount of new information and thoughts that were crammed into my head, not to mention all of the great people I met (and the few great people I mustered the courage to speak with).
What did I have there? Two awesome keynotes, one perspective changing workshop, one really enjoyable lean coffee, one talk that introduced me to a cool new idea, and two talks that were good, and surprisingly enough, in that conference, or at least today - "good" felt like it just doesn't stand up for the high standards set by just about everyone else.
As my thoughts are still fuzzy from all of that rush, I'll just go quickly through my experiences - I made an attempt to keep some notes in each talk, but I'm a lousy note-taker, so it is probably better if I look at them while they still mean anything and re-organize them.
After registration, with me walking around trying to find some other folks who didn't know a single soul in the conference beforehand (which didn't go that very well, but at least it was short),
Then began the first keynote by Linda Rising, the subject was "the power of an Agile mindset". She began her talk with a short disclaimer about her slides being public and free to use as anyone would like, as probably we will wish that someone we know would have been here to hear it too. And she was right - ten minutes into the talk I knew exactly who should be hearing this talk. I still hope that there will be a video published with this talk, as I think I've seen a video camera posted.
The talk was about the difference between having a "fixed" mindset and "growth" mindset - the first assumes that skills are inherent and unchangeable, the other assumes they can be nurtured and grown, and that anyone can improve by investing effort. She presented a study that found that having the "growth" mindset drives people to perform better, and achieve better results. Also, for the parents around, especially for those with girls - be careful when you give compliments. Saying "how smart &  perfect you are" is pushing your child to the fixed mindset. What she suggested was to comment about the effort invested, something along the lines of "wow, you have really put yourself to the task".
Where does Agile come along? Linda made a claim that the core values of the "growth" mindset are very similar to the Agile core values - embracing change, constantly improving, accepting failure etc.
I left this talk wondering about how can someone educate themselves to have that mindset, and whether I can do anything to help them do so, as it will definitely help them a lot.

Reading recommendation: Fearless change, mindset (and apparently, audible are giving a free audio-book version of it, if you don't have an account and join their 30 day trial)

Next, after a very short recess, I attended my first "regular" talk, where Thomas Sundberg talked about why everyone who invests in automation should strive to focus mainly on the low level checks, or, as they are more commonly known "unit tests". His argument was quite compelling, and even though I've heard it before, he made a good case for it, and showed an interesting perspective about the fairly known "test pyramid" where he attached different attributes to the layers of the pyramid - at the base you could find stuff like "precise", "fast" and "reliable", while at the top there are "business logic" alongside "long" and "fragile" (I probably missed some and mis-worded some of the terms, my apologies). Despite that, I'm not sure I really buy into that idea of focusing on the unit level. There's something at looking at the trees that makes me feel as if I'm missing out the forest. Probably it has a lot to do with the fact that my experience is in automating system level checks, and that every time I looked at a set of unit-tests written by our developers they were very naïve, and almost always were a bit to simplistic for my taste. I think I can understand the reason behind investing in low-level checks, but I don't feel it. I also feel that testing a whole system tends to force me watch out for the unknowns. a unit I can grasp and understand completely. two units integrating? I can probably manage. The whole system? Not a chance in the world. I believe that this way I'm less prone to assume I have some sort of a "perfect coverage", so when the unexpected occurs, I will be more open to noticing it.
Oh, his main case for that sort of investment was simple math - connecting all the pieces together means that you have to multiply the paths inside each component as you integrate them, if you break your tests early, you are only adding the paths, which scales much better.

After a short coffee break, I went to a workshop by Alexandra Casapu, under the subject of "Examine your test skills". We got a cool testing challenge (here's a black box. go ahead and figure out what it does", and she literally brought some black boxes to play with, which was awesome), and after 20 minutes or so of playing with it, or, as I suspect most of us ended up saying: "But we've only just started to understand what's going on" we were asked to stop and think about the different skills we have used to solve the challenge. Let me tell you one thing - it was very hard to start and break down my simple "oh, I just played with it a little bit" to actual skills I applied unconsciously (or "tacitly" as I hear occasionally from Bach, Kaner, Bolton and just about everyone around them). Next, we got to compare our lists with our team members (did I mention we were split into groups?) and then to categorize the skills, which was really important too, since it allowed us to find some other skills we used (or could have used), and to identify areas in which we invest more than others (maybe it's a sign for interest, maybe it's a hint we should change our focus).
My main takeout from this session is a decision that will be tough to maintain, and I got it in the form of a quote: "Get out of the execution mode!" (I think Alexandra was quoting someone else, but I'm not certain about it, and quite happy to attribute this to her ). Pausing from time to time gives us time to reflect on what we have done and think of ways to improve. It also gives us the language to talk about testing (I have Alexandra's word for it, since I have yet to experience it firsthand, but I totally see this happening).
Next, I was a bit late for a talk by Abby Bangser with the title - "Truth - the state of not yet proven false", which was a really nice talk about how our mind fills gaps automatically and how this filling-up is based on our expectations. There's not much to do in the way of preventing it, but if you are aware of it happening, you can definitely take some steps to minimize or overcome the ill-effects of those unconscious blind-spots. An idea I really liked as a way to fight that sort of bias was by using personas, by telling ourselves a nice story about the user who will be using the software. Some automated tools could help us vary the data we use (The example in the talk was and automated web-form filler that came up with semi-random input). Definitely some nice things to think about.

Next was lean coffee, which was a great experience. I'm used to think of myself as allergic to strict formats, and I felt that the five minutes limit sound always came just at the wrong moment, but this did enable us dropping subjects fast and get a nice coverage of our topics during the hour of the lean coffee (which felt like ten minutes). I really enjoyed hearing both the concerns and thoughts. We went over various stuff - from usability testing tactics for a software specifically targeted for doctors, to choosing a test strategy, to inspiring other testers to learn (and much more). Plus - I actually got to talk to some people and now I feel a bit more comfortable approaching them, and though names are a problem (I did manage to remember Claudia Rusu's name since she also gives a talk, and Gita Malinovska with whom I paired during the workshop as well, I think there were also two Adrians, but at this point I decided the world was trying to confuse me and focused on listening to people ideas). I ended up talking a bit with Claudia about the subject she just raised when the buzzer announced the end of the lean coffee, and without noticing I found myself late to Emma Keaveny's talk about "dark patterns". Whenever your application is deceiving the user, making it harder to choose the "right" option, or coerce the user to do something they wouldn't normally do, you are using a dark pattern. A really cool subject, and something I will have to remember looking for when testing in the future. For me, all the bits and pieces connected perfectly when I realized that this is very similar to some of the concepts of usable security. There we ask "Is the default behavior is the more secure one?". When looking for dark patterns the question is similar - is the default behavior is in the best interest of the user?" . I think it might prove a great rule of thumb to identify dark patterns.
Oh, and by the way, if you ask me - the most notorious use of a dark pattern I have ever seen is the flash player update. Why should I uncheck something to avoid downloading a second piece of software to my PC??
Reading materia: Evil by design, darkPatterns.org.

After the talk I stayed to speak a bit with Emma and two or three others (including one that worked for Adobe  - the company that was my go-to example for using a dark pattern with the antivirus bundled with each flash player update). That was really cool, and we were late to the closing keynote by Anne-Marie Charrett with the misleading title "How to conduct great experiments". The talk did mention some experiments, and it seem that they were great, but it was so much more. It was a transition of paradigm - from test management to test leadership (and the bottom line, that left my jaw right down on the floor, was that the difference is that managing is a regulatory activity that promotes stability, while leadership looks for and drives constant change and evolving), which had to pass through redefining the role of the testers in the company, focusing on what is most needed and delegating or dropping other activities that could be done by others, or that are not as important to have. It also spoke about the difference caused by the test team size, and added a creative solution of dispersing the test team\department and driving it to become a practice rather than a designated owership (practice, in this case, is like the medical practice - where one might go and consult the doctor about their health, but the ultimate responsibility to eat, sleep and exercise properly is the individual's, not the doctor's).

Then - retrospective. How do you do retrospective of a full day for ~100 people?
Here, have a look.


By then, the day has ended, and I was happy to get to my Hotel and rest a bit. This day was intense.
Only I didn't. at 9  PM we met at a nice bar\café and had some good mingling time. I ended up talking a bit with Richard Bradshow, and having another chat with Emma Keaveny, and got a chance to thank Llewellyn Falco and hear from him about some of the purposes of the lean coffee (to get people to talk with each other). There was so much more going on there, but it was a bit late for me, and everything just got mixed up in my head to a really nice feeling that I can't pull details from, but certain that it was good.

If any of the others I talked with during this day and are not mentioned hear ever read this - please don't be offended I didn't have your names here. Some of them I actually do remember, but this post is already long as it is, and cramming a whole day to a single post is almost as hard as is cramming all of those ideas into my thick skull.

So, thank you everyone for a great first day.


Monday, January 25, 2016

צה"ל צה"ל כבר באים

You're in the army now

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

--------------------------------------------------------
Now and then, when I consider trying to find myself a relocation option and wonder whether I really want to try such a thing,  one of the first arguments that I note at the "pro" side is military reserve duty. The fact that at any a summon can arrive and with a short notice pull me back to my worst period of life so far (and I really hope not to experience worse times) is burdening my life more than I would like (and more than I usually admit). 
Anyway, why do I spill my guts here? After all, this blog is about testing. the thing is, I was recently called to service. The thing I do requires me to work a bit with an ABCS (ABCS= Army Command Battle System, the link in the Hebrew version is different, since it directs to the actual system used in the IDF, but I didn't' find any description of it in English). Even though there were some inhibitors such as lack of sufficient sleep,or the fact that it was not OK for me to completely break the system (besides, it broke perfectly by itself ) as well as other tasks I had to do, giving me a software to play with is fun and will lead me to think about "how would I test it?".
Obviously, I'm not going to get into details about a military system in a public blog. Since most of the not-so-secret stuff in the IDF are classified as "you can tell it only to other Israeli citizens" and I am used to bundle up "not classified" with "not-so-secret", I won't trust my memory or instincts and will choose to err on the safe side. I do feel free, however, to link or to discuss things that already exist in the internet. Also, instead of discussing the particular features and behaviors of the system I worked on, I want to raise a question - What are the things you would test in such a system? A short reminder for those that did not read the Wikipedia page, or did not understand it, we are talking about a system used by both the troops in the field and all levels of command - wherever they may be.
The full list when coming to test such a complex system is huge, and even when trying to pinpoint "the most important stuff" there can be many answers (in fact, what is your list of "big items"?). At any rate, here are the main subjects I think are the most important to notice:

  • Simplicity - The system will be used by a lot of folks, under stressful situations, and most of them are not necessarily computer wizards, and most of them have other complicated tasks without having to deal with this new system. If they will have to invest to much time or effort in the system, their performance will decline instead of improving, which is the whole purpose of this system to begin with. It has to be simple for all levels and types of use.
  • Resilience - It's a battlefield, not a cozy test lab. The equipment will suffer from dust, rain, mud rattling around when carried, being accidentally hit by a piece of equipment carried by a soldier (Any soldier that has carried a rifle had accidentally hit something or someone with the barrel of his gun at least once. Most soldiers I know don't even notice this happening anymore unless some damage or pain is caused), and only the devil knows what else could befall the poor equipment on top of the issues I've already mentioned (one thing could be harsh weather conditions - from extreme cold to extreme heat).
  • Efficiency - The system's whole purpose is to improve the soldiers capabilities and to enable them to take better decisions faster. 
  • Filtering information - I would not normally consider this as a separate issue and would include it under efficiency or simplicity\easy of use, but after playing with the system in a rather limited stressed one fact to me - in the battlefield there are gazillion things that someone should know about. Every squad, and every enemy force generates at least one point of interest, battle plans, events, areas of responsibilities, various form of geographical analysis (for instance - what can be seen from a  certain point, or what should be the comm coverage of an antenna placed in one place) and even field intelligence items - all of these are crammed into one, not that large screen. Moreover, For any given soldier, most of the information is only a distraction. A cannon operator cares only about "where can my cannon shoot?" and "when and what to shoot?". Both battalion commander and a brigadier general cares about the location of their forces, the position of enemy forces and stuff like that, but while the former will need to know those things down to the single squad, and sometimes to the single soldier level, the latter can't afford this level of granularity and must look at the bigger picture.
    In short - in order to be usable, the system must allow filtering information, and since it is this important, it is worth being tested specifically for it. 
  • Information Security - as always, this breaks down to several properties, according to your favorite acronym (STRIDE, CIA or any other acronym you may have encountered). The properties I would invest effort in trying to ensure are: 
    •  Secrecy - Most of what is going on in this system is the jackpot of the enemy intelligence, so we better make some effort to keep them away from it. The obvious requirement is that all communication be encrypted so that no one would be able to tap into the communication channel, but the system must protect against situations such as a device falling captive, perhaps even with it's legitimate operator. Besides, it would be great if the system will not broadcast constantly, as most broadcasts can be triangulated, thus exposing the location of the forces. 
    • Availability - It's a battlefield. The enemy will be attacking everything, the communication network included. A bomb dropped on a main server better not disable your system, and a station should be able to provide some basic functionality even when it cannot contact any other component of the system (which may happen if the enemy if jamming all radio broadcasts in an area).
    • Compartmentalization - It's a bad idea to expose everything to any grunt that has connected to the system - some pieces of information should be available to certain people only. 
  • Portability - I should probably find a better term for that, as I don't mean portability in the conventional use it has in software testing context. I mean the ability to carry the system along with the fighting forces. Adding a Kg. or two of equipment to an infantry squad is bearable, If they have to carry with them something that weighs 20 Kg. (~45 pounds) that would be rather difficult and irrational, and anything more than that would simply be impossible.
    Another thing I include here, which may deserve a bullet of its own, is the infrastructure required for the system to work - a cell-phone is great, but it must rely on a strong network of antennae that should be deployed. If the system is small and compact, but requires complex infrastructure work, the forces may end up having a small and compact piece of junk. 
  • Functionality - well, we had to get to functional testing eventually, didn't we? while less important than the previous bullets (at least in my eyes), I would prefer to have my system working correctly. 
  • Load - The modern army has hundreds, if not thousands of forces in a given battlefield, probably more in an entire war. The system should be able to deal with all the different stations - whether it is designed as a server-clients system or as independent stations communicating with each other. 
  • Performance - Here I get close to the "nice to have", but this system operates in a highly dynamic world that does not wait for it. While it is not the performance requirement of an algo-trading system, and that of your day-to-day web page, an extra five minutes it takes to complete a complex request can be the difference between being able to use the system and having to ditch it. 
To wrap it all up, I didn't have fun during my reserve duty, but at least I got a chance to consider testing of a software very different from the one I'm working on in my daily job (and to be baffled by the complexity of designing such a system). 


Thursday, January 7, 2016

the imposter syndrom

תסמונת המתחזה

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

--------------------------------------------------
Ever heard of the impostor syndrome? I don't think I know anyone that does not suffer from it at least to some extent. At least, no one that I am close enough to in order to know how does he feel about himself. Sure, my observations so far seem to strengthen the idea mentioned in Wikipedia which stated that the issue is more prominent in women, but in my case it could be just that I somehow had more talks about feelings and self esteem with women.
Anyway, back to the subject. The situation where I feel this whole impostor thing most strongly is when I get a compliment. My natural inclination is to respond with something like "That? oh, this isn't such a big deal, anyone could do the same", and then try to find the closest place to hide. At least, this was my go-to response until someone I talked with mentioned to me that I do that all the time, and when someone gives me a compliment, they usually mean it and don't want it to be discarded or trivialized. they are saying "thank you", or "I appreciate what you've done" and they mean it. It took me a while, but I managed to tell myself that I'm good at what I do. I'm a fast learner, I can ask very helpful questions,I can smell  and I'm generally a very good software tester.  I started believing that I was over this whole syndrome 
So I believed. 
Apparently, after getting used to the idea that I'm a good professional, I now have to get used to the idea that people are enjoying working with me. 
Yesterday, I found myself in the center of attention of too many people, shortly after receiving a compliment about being a fun guy to work with. My first instinct? Hide. then "I didn't do anything special" came to mind as well. luckily, I didn't have the chance to speak. 
A nice guy. me. 
I will have to get used to this idea. 

Sunday, December 6, 2015

תראו כמה מסמרים!

Look at all these nails!

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

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


----------------------------------------------

A famous proverb states that if all you have is a hammer the everything looks like a nail. What is also true but less frequently heard is that when you don't have a hammer in your toolbox, you miss out a lot a nails. 
Eight months ago, I went to one of the local selenium meetups organized by Adam Carmi (Co-Founder of Applitools) and Oren Rubin (Founder of Testim) where I've heard Dave Haeffner that recommended to incorporate Browsermob proxy into Selenium tests (By the way, if you are working with Selenium and have not yet heard of Dave, you probably want to register here to his weekly Selenium tips). So, I did some reading and decided to give it a try. I did a quick proof-of concept and then went struggling to try and stitch BMP to our project (Library conflicts can cause all sorts of insidious problems) - Finally, after several hours of work that spread over several months - as there is always something more urgent to do than an independent pursuit of an idea - I managed to run our tests through a proxy. 
The next step was to show off to my team - I spent around 15 minutes (including the learning curve) and added a simple check: for every request checked the HTTP response status and printed all the unexpected ones. As a result I found out that some pages are asking for resources without reason (the reason for that is buried under layers upon layers of legacy code - so we have decided to leave it as is). 
At any rate, what I did or didn't find is the least interesting thing around here, the more interesting phenomenon was that once we accepted the new capabilities that we now had, we suddenly started having all those new ideas of things we now can and should do - all of them are valid and valuable checks that we did not previously thought of - on top of the improvements we intended for our existing tests, there were some new tests we came up with just because we now could easily do them with our new and shiny tool. Previously, we have not thought about them because we had other things laid out in front of our eyes. We had selenium API that is all about DOM elements, we had database checks that are focused around what is written where, and we were checking our logs as well. We are improving our work with them constantly, but in the meanwhile we missed (and are still missing) a whole world around us. 
For me, this experience was very educating. I can definitely use this as a reminder to me that there are always more areas to look at - metadata, memory consumption, the actual usage of the software in the real world, and a million other things. Expanding our capabilities in what was previously a blindspot has almost instantly improved our testing and our ideas - I see no reason it won't do the same for you. 

Thursday, December 3, 2015

בחישה קצרה בקלחת

Trying to stir things a bit

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

-------------------------

Last week I got a meeting summon with a title "Periodic check-up with HR" (or something along those lines) - once every 6 months, or a year, or whenever they get around to do this, our HR "business partners" (I have no idea what does this mean, but this is the official title for the HR person that is my contact point for everything under the general HR domain) try to meet every employee in order to see how things are, whether there are any complaints, requests or things that bother them. Pretty nice of them, isn't it? At any rate - a 30 minutes talk with no goal other than to listen. So, in the worst case scenario - I would have spent half an hour while someone was listening to me vent some steam. I certainly won't say no to that. 
I came to this talk with the same message I get to every meeting with someone that is either part of, or have a direct channel to, upper management.  I'm unhappy about the attitude towards testing as a profession in our company. Even though I know that inside the team our contribution is recognized and appreciated, and even though as a tester I am able to significantly influence "my" product, once we get to the department level, I feel as if we are missing a lot that can and should be done. For instance, one can point on the fact that different test team have different skills level. not just a different skill-set, that is reasonable to have, as the products are different, but the basic capabilities of the test teams is different. One team is simply better than the team next to it in the same building. There are differences in the expectations set for the different teams and even in the minimum requirements when recruiting a new junior team member. In addition, there is no-one around that fills a role of a "testing expert" testers learn from. In short, even though actual testing is appreciated, it doesn't seem as if anyone considers it to be a profession that one should invest and get better in. Adding to that the fact that most of our teams are working in a Scrum-but, I really don't understand why am I part of a "QE department", or what do I gain from that.  
So, each time I find myself having this type of conversation with anyone that has anything to do with upper management ("upper" being a relative term here, from the viewpoint of the corporation I'm working in, they are probably considered as mid-level management) I try to advocate for the idea that something needs to be fixed - either abolish the concept of "QE department" and remove the bureaucratic hassle caused by having two departments managing each team, or add some value to being part of a dedicated testing department - Have some unified standards to testing, a common test approach or shared goals, testing-centered training - anything. 
While talking about this subject and trying to understand better what is it exactly I'm missing, one of the things that came up was that I don't see anyone around that seems interested in what's going on in any sort of a testers community - no one seems to be consuming any sort of professional content - books, blogs, podcasts, local meetups, nothing.  Currently I know of two persons that want, and do an effort to participate in a strong testing community - my direct manager and myself (though, to be fair, my department's director does read at least some professional texts, which is more that I can say about the rest of the testers around).Then, the HR business partner suggested something - Since I'm already spending time reading, why won't I share interesting things I find with the rest of the testers?
Frankly, I have thought of this idea several times, and decided that I don't want to be one of those annoying guys that sends spam to a large group of uninterested people. At this point she suggested an idea I have not previously considered - create a new mailing list that will be dedicated to the subject. This way only those who opted-in will receive what I share, and it may encourage others to share as well. 
And so I did - after a surprisingly short affair with our India based IT support, I was got my mailing list, and sent an invitation to all of the QE department. Now, all I have to do is to wait for people to join (despite a very low initial interest shown, I suspect that my director will be applying some sort of pressure on certain persons to join). One way or the other, I suspect it will be a useful experiment to conduct - either I will succeed at creating some sort of professional interest in testers around me, or I'll know that no-one around me cares enough even to passively listen. At any rate, if we accept James Bach's approach, this will be a step for me becoming a testing expert, at least in my local environment (For those that don't have the time to listen to a one-hour lecture, Bach's claiming that one of the criteria to being a testing expert, and probably the most important of them, is to have the reputation of one). 
So, let's see where will it take me. 

Saturday, November 14, 2015

תיעוד בדיקות - למה זה טוב?

What's the purpose of test documentation?

Today's post is a response to something I read online. Since the writer of that article probably doesn't read Hebrew, I will change the regular order and start this time with the English version.

In her post, Nicola Owen presents an interesting question: What's the purpose of test documentation? Her answer to this is simple - Test documentation is meant to communicate information.
Out of this simple statement she then continues on to examine the possible audiences of such communication efforts and provides an interesting insight to the way each audience is changing her mindset and focus points while writing the documentation.
However, while very interesting, I could hear my inner voice revolt. "I don't document test cases in order to communicate! at least not only for that" . So, I took a moment or so to stop and think "what do I use test documentation for?" and what was it in "communicating information" that got me ticked off?
Before I start, I would like to clarify a point that was a bit ambiguous for me - what is "test documentation"? It might be just my poor control of English that led me to understand it this way, but I differentiate "documentation" from "documents". The first is a term borrowed from the programming context, where it usually refers to the comments that explains what is being done in that weird piece of code just next to it. The latter is a bit more general and refers to any type of document produced during any of the testing phases. So, "documents" will contain everything - test plans, requirements, bugs, detailed test cases and possibly also my grocery store latest receipt (ok, that might be stretching it a bit too far). Test documentation, however, are mostly the step-by-step description of test cases performed, along with their run status. One might also debate whether filed bugs are part of it (Which, as far as I was able to judge, are referred to in the original post) but in order to keep things simple, I will exclude them.
Anyway, to the list of what I do with test documentation:

  1. Communication with my future self or with my testing teammates.
    Yes, even though it's not the only thing I do, it is still very important for me. Those documents will later help me to recall how to use a feature I have not used for a year, or recall which configuration parameter controls what functionality and sometimes even whether some peculiar behavior of the system is intentional or not.
    Communicating outside of the test team is usually not done with test documentation but rather with an oral discussion, or filed bugs (that may or may not contain steps to reproduce the issue, according to the specific context of this bug). 
  2. Organizing and formalizing data - I don't work well with fine details, I can focus on them from time to time, but I need to sit down explicitly and rephrase them in order to truly understand them and not be distracted by the bigger picture. Forcing myself to write down every tiny details drawn my attention to it: I notice what data is being written to which table in the database, which lines are relevant in the log files and I formalize a way to use the software. When I do that, I get more familiar with the software I am testing. 
  3. Think a bit more about my tests - This is probably strongly related to the previous bullet: I can't recall the last time I wrote my test cases and did not find something that needed changing or that should be added to the test. 
  4. review and control over what I am doing - yes, it is a bit similar to the communication part, only I do not intend to pass information, but rather to verify that I have covered everything I intended to cover and did not forget anything important as I was performing the tests. 

From those goals I derive my way of writing the test steps: Since I will be using them as a reference in the future, or someone new to the team will use them to learn about this feature, I write extensive descriptions that rely on the reader being generally familiar with the system, but otherwise will be very detailed, sometime up to the point of "Copy/Paste" commands.
As I use test cases in order to rethink my testing and to review the gaps I may have left, I also add to each step a title explaining its intention and providing me with a short way of understanding the step, or test case.

Finally, I would like to note that while writing test cases is one of the most hated tasks in our team, writing them down is proving useful again and again and again.


Edit - I just got to read this post I really liked it, because it emphasizes an important point that I only half mentioned in my third bullet - while writing down a test case I often find some bugs just because I stopped to think about it.
-----------------------------------------------------------------------------

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

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

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

Friday, November 6, 2015

בשביל מה אני צריך כלי לניהול בדיקות?

What do I need a test management tool for?

נתחיל עם הבהרה קצרה - אני בהחלט צריך כלי לניהול בדיקות. כן, מה שנכנס לשם הוא בעיקר מקרי-בדיקה (או איך שלא מתרגמים test case), ואני בהחלט מסכים עם הטענה שמקרי בדיקה אינם בדיקות (ויש גם מאמר כתוב כאן), אבל לפחות במקרה שלי - יש ערך לכתיבת מקרי הבדיקה (תיעוד שמסביר איך להפעיל דברים, תזכורת לעתיד שמשהו נבדק, או לא נבדק, דרך למדוד סוג של "כיסוי", ועוד כל מיני דברים).
בכל מקרה, בשבוע שעבר מנהל המחלקה שלי החליט לחפור מחדש השוואה שערכתי בין שני כלים לניהול בדיקות לפני שנתיים ולחשוב אם אנחנו רוצים להחליף את כלי ניהול הבדיקות שלנו. מבחינתי, זוהי הזדמנות לחשוב מחדש על מה אני מצפה לקבל מכלי הבדיקות שאני משתמש בו.
מה שהניע את התהליך אצלי אי שם ב2013 היה השוואת כלי ניהול בדיקות שקראתי בבלוג של עדי מור, בעקבותיה החלטתי לנסות ולהיפטר מהכלי שהשתמשנו בו והרגיז אותי מאוד - HP Quality Center (אנחנו עדיין משתמשים בו, בגרסה 10.0 שעדיין כתובה בactiveX ונראית כאילו מיטב טכנולוגיית שנות התשעים הושקע בה). ישבתי והשקעתי קצת זמן בחיפוש כלים, תחת מגבלה אחת - ההנהלה דרשה שהכלי ישב על שרתים שלנו ולא איפשהו בענן. 
תוך כדי חיטוטים וחיפושים הופתעתי מאוד לגלות שבסופו של יום, QC הוא אחד הכלים הטובים ביותר שראיתי. מתוך חמישה או שישה כלים, היחיד שהיה בר השוואה אליו היה QAComplete של SmartBear.  
הפעם, אולי, לא נהיה כבולים לשירותים שאינם בענן, כך שיכול להיות שנסקור כמה כלים חדשים ונגלה הפתעות (יש לי מוצר אחד על הכוונת, אבל לצערי אין להם גרסת ניסיון שהצלחתי למצוא, אז לא יצא לי לבחון את המערכת הזו). 
בכל מקרה, כיוון שאני לא מוצא את הרשימות שלי מאז, זו לא תהיה סקירה משווה של מוצרים (אם אחזור על ההשוואה אשתדל לפרסם אותה כאן). במקום זאת, הנה רשימת השיקולים שלי בבחירת כלי ניהול בדיקות, מסודרת לפי סדר חשיבות: 
  1.  קודם כל, ניהול דרישות. מבחינתי, חשוב שיהיה לי מקום בו אני יכול לשמור את הדרישות של כל המוצר שלי כפי שהן כרגע. זה עוזר לי להתמצא, עוזר לי לחשוב על בדיקות ועוזר לי למצוא בדיקות ישנות שאולי קשורות למשהו. ממערכת ניהול הדרישות אני מצפה לדברים הבאים:
    1. הירארכיה. היכולת להגדיר מודול שלם כדרישה ואז לפצל אותו לתתי דרישות. 
    2. קישור לבדיקות  - די טריוויאלי. 
    3. קישור לדרישות אחרות - המודל ההירארכי של עץ דרישות הוא חשוב, אבל בדרך כלל ישנם קשרים שאינם בתוך אותו העץ. נניח, אם מחייבים לקוחות על שליחת SMS, מודול החיוב מושפע ממודול שליחת SMS.
    4. דיווח מצב - האם יש בדיקות שמכסות את הדרישה? האם הן רצו? עברו? מה מצבן של כל תתי הדרישות? מה מצבן של כל הדרישות בגרסה? 
    5. סינון, או, בלע"ז - פילטור. היכולת למצוא דרישות לפי מסננים שונים (כמו מספר גרסה, סוג דרישה, קשר לדרישות אחרות וכו'). 
    6. חלוקה לסוגי דרישות שונים - אצלנו חשוב לנו לזהות דרישות אבטחה ודרישות ביצועים, נוסף על הדרישות הפונקציונליות. לא מצאנו עדיין צורך בסוג דרישות נוסף, אבל במוצרים אחרים דברים כמו "חוויית משתמש" או "עמידה בתקנים" יכולים להתאים גם הם. 
  2.  חיפוש בבדיקות קיימות - אחד הדברים המרכזיים בהם מערכת ניהול הבדיקות תורמת לעבודה היומיומית שלי היא כשאני משתמש בה כדי למצוא מידע לגבי פיצ'רים שנכתבו מזמן. לפעמים קורה שדווקא בתוך תסריטי הבדיקה אני מצליח למצוא תשובות לכל מיני שאלות שצצות. 
  3. כתיבת בדיקות נוחה - אחד הדברים שהכי כואבים לי בשימוש בQC 10.0 הוא שזה ממש מרגיז לכתוב תסריטי בדיקות. הנה כמה דברים שיכולים לעזור:
    1. ממשק גרפי נוח - זה נחמד כשהמסך נראה יפה, וגם מקשי-קיצור עוזרים מאוד. עם זאת, גיליתי שנוח לי יותר לכתוב במבנה של צעדים ולא בטקסט חופשי. 
    2. החלפת טקסט - לפעמים יש דברים שמשתנים תוך כדי פיתוח. למשל - שמות משתני קונפיגורציה. אם שינינו את "isEnabled" ל"isActive", אני לא רוצה לעבור בדיקה, בדיקה ולשנות את הטקסט. פונקציונליות כמו "החלף הכל", או כמו טבלה שממפה משתנים לטקסט הופכת את החיים לקלים יותר. 
    3. העתק\הדבק ושכפול - בדרך כלל, כשאני כותב תסריטי בדיקה לאותו פיצ'ר, אני מוצא שצעדי האתחול דומים מאוד, וחלק מהפעולות דומות מאוד. העתקה נוחה של תסריט, או של כמה צעדים בתסריט היא הבדל משמעותי. 
    4.   קישור בין צעדים - קורה לי לפעמים שאני כותב "התוצאה צריכה להיות כמו התוצאה בצעד 3", כדי לחסוך מעצמי את הצורך לתקן עשרים מקומות אם התוצאה הצפוייה משתנה. אבל מה שקורה אז הוא שבין צעד 2 לצעד 3 נכנס צעד נוסף ומשנה את המספור. עכשיו אני צריך למצוא את כל המקומות בהם הפניתי לצעד 3 ולהחליף את ההפנייה לצעד 4.
      דוגמה שנייה לצורך הזה הוא כאשר אני רוצה לומר "חזור על צעדים 5-9 עם משתמשים מהסוגים הבאים...".  
  4. דו"חות - בסופו של יום, ההנהלה רוצה את הכלי כדי לדעת כל מיני דברים כמו "כיסוי לעומת תכנון", "מספר כשלונות", "חומרת התקלות שנמצאו" ומגוון דברים אחרים.  אני לא אתעקש על הגדרת דו"ח בעצמי אם הדו"חות המובנים בכלי עונים על הצרכים שלי, אבל זה בהחלט יכול להיות משהו שימושי.  
  5. הרצת בדיקות - בעיקר כדי למלא את הדו"חות בתוכן, חשוב לי לדעת אילו בדיקות רצו, אילו עברו ואילו נכשלו. 
    1. קישור הרצה לגרסה. - אני רוצה להיות מסוגל להריץ את אותה בדיקה על כמה גרסאות שונות ולראות את הסטטוס הרלוונטי לכל גרסה. 
    2. משתני סביבה - לפעמים בדיקה נכשלת רק כשהיא רצה עם מסד נתונים של אוראקל.
    3. משתני בדיקה - לפעמים, באותה סביבה יכולים להיות כמה משתנים (למשל - סוג משתמש). אולי בדיקה של login נכשלת רק עבור מנהלי מערכת?
    4. עריכת הבדיקה מתוך מסך הריצה - כי כמעט תמיד, תוך כדי הרצה צצים דברים שצריך לתקן. 
  6. קונפיגורביליות - גם בתוך החברה שלי, צוותים שונים ירצו שהמערכת שלהם תיראה קצת אחרת. עוד שדה, פחות שדה, כן חובה\לא חובה.  
  7. התממשקות עם כלים אחרים. מבחינתי, הכלים המרכזיים איתם אני רוצה להתממשק הם Jira, בו אנחנו מנהלים את המשימות והבאגים שלנו, וVersionOne, שם אנחנו מנהלים את הסיפורים, את הספרינטים ואת הbacklog שלנו.
    בקטגוריה הזו אני גם סופר את היכולת לייבא נתונים מכלי ניהול הבדיקות הנוכחי שלנו. 
  8. התממשקות עם אוטומציה - זה לא מאוד קריטי לי כרגע, כי האוטומציה מנהלת לוגים ודו"חות משלה, אבל אם יש API נוח שמאפשר לי לקחת בדיקה ולעדכן אותה באופן אוטומטי, זה כנראה לא יכול להזיק. יכול להיות שזה דורש תחזוקה גבוהה מכדי שזה יהיה רעיון טוב, אבל אם הכלי מאפשר לי לגשת אליו מתוך האוטומציה, בשפה בה היא כתובה (ולא, כמו שעשו QC עד גרסה 11, להכריח את המשתמש לעבוד עם אובייקטים מוזרים בvbscript) אני אראה זאת בחיוב.
  9. ייצוא נתונים - כי בסופו של יום, כלי ניהול בדיקות לא צריך להיות חתונה קתולית. 

זהו, פחות או יותר. עכשיו נשאלת השאלה - מה שכחתי?

-----------------------------------------------------------

I'll start with a short disclaimer - I do, indeed, need a test management tool. Even though I am familiar and quite agree with the claim that "Test cases are not testing" (There is also a written paper here), I find that, at least in my environment, there is some added value to writing test cases (documentation, proof for the future me that something was checked, a way of measuring some sort of "coverage" and some other stuff as well).
 Last week my director dug up a comparison I made between two such tools and rethink whether we want to switch our current tool, For me, this is a great opportunity to think about my expectation from a test management tool. 
What had originally started my quest back in 2013 was this post from Adi Mor's blog. Following her footsteps, I decided to try and get rid of the annoying tool we were (and still are) using - HP Quality Center (we are using version 10.0, that still uses activeX and looks as if the best technology available in the 90's was used in it's construction). I invested some time comparing different solutions I could find, with one limitation - The system had to be on-premise and not somewhere in the cloud. During my search, I was surprised to find out that QC was actually one of the better tools out there. Out of five or six tools, the only comparable product I could find was SmartBear QAComplete. 
This time, we might not be tied to on-premise solutions only, and if this will be the case, I might have a candidate in mind, but sadly they don't offer a free trial for me to play with, so I'm not sure that it answers all my needs. 
Anyway, since I can't really find my notes from back then, this post won't be a comparison, but rather a list of my requirements from such a tool, ordered (roughly) by priority:

  1. First of all, requirements management. For me, it is important to have a place where I can keep my product's full requirement-tree. It helps me find my way around, helps me think and helps me find old requirements that might be relevant to a new feature (as well as find old tests covering an almost forgotten requirement that just now someone from support has asked "why does our system behave like that?"). I expect the following properties: 
    1. Hierarchy. I want to be able to define "this is a sub-requirement of that. both of those are not a "module" (which may be something bigger). 
    2. Link to test cases - pretty obvious. If I spent time writing test cases, I want to be able to find them (Otherwise I wouldn't take the time to write them down). 
    3. Linking to other requirements - sometimes I want to say "this requirement is related to that one over there, even though they are not in the same part of the tree, or even in the same module. For instance, if I charge my customers for sending SMS messages, then the requirement "when attempting logging-in, send a user with one-time password via SMS" will affect the billing requirements. 
    4. Status report - Are there any test cases covering the requirement? have they been run? passed? 
    5. Filtering - by version, by type, by a custom field - I want to be able to find requirements easily. 
    6. Marking requirements type - In our place, we use security and functional requirements, as well as performance. in other contexts there might be use for other types. 
  2. Search text in existing test-cases - one of the main reason we write test cases is that we found it a useful way to keep a knowledge base - sometimes the only way to find an answer, or to recall how to use a long forgotten system (we have a few of those) is to search for a test case that describes the specific area. 
  3. Convenient to write test cases - this is one of the pains we are experiencing with QC 10.0 - it's really annoying to write test cases. here are some things that can help: 
    1. An easy-to-use GUI, it helps if it looks good, and hotkeys are a great helper. I also discovered that I prefer structured steps over just a free-text box
    2. Search  & replace - Imagine you are writing some test cases. being a nice person, you keep mentioning the name of the parameter that should be turned on or off. Then, the parameter name is changed. going over the all of the places where you have used it can be a real fuss. 
    3. Copy/Paste  & cloning - Sometimes, there are similar test cases. if it's easy to copy and paste test steps, it makes my life easier. If I can clone a test and change the details I want - it makes my life easier. 
    4. Linking between steps - Being lazy, I often write stuff like "the expected results are the same as in step 2". which is great, but then step 2 becomes step 4 after two more steps were added before them. If excel can keep track of cells in a formula, can a test management tool do the same? 
  4. Reports - By the end of the day, my managers (and sometime myself too) just want to see the overall picture - Have I covered my requirements? Have the tests been run? How many bugs were found? Generally speaking, how are we doing?  A strong set of built in reports can probably answer all of my questions to a satisfactory level, But being able to create my own reports is also a nice thing. 
  5. Running tests - and by "running" I mean "marking the tests as passed or failed. This should be meaningful and easy. It is important mainly in order to fill the reports, but that's something too. 
    1. linking a version\build to the run - if I have several versions, I may want to run the same test for all of them, I wouldn't want the results to leak between versions (that is - if I re-run a test and now it passes, I care less for the fails that were fixed. If I fail in one version, but then I run the test on the previous version and it passes, I still want to see the fail. 
    2. Linking to environment configuration - sometimes a test will fail only when using oracle DB. we should know that. 
    3. Test parameters - some time, a test is run many times with slight variations. For instance, the system I test has several dozens of customers. Sadly, many of them have special configuration. A simple test may fail for one customer only because someone made a mistake when tweaking this customer's configuration. I want to be able to say "for this test case, I want to maintain separate tracks for the values in *this* field. 
    4. Editing the test case script from the run screen - because almost always I will spot mistakes, or changes that should be done, when I am running the test. 
  6. Configuration - Even in my company, different teams will want different things - extra fields for one team, a set of default values for another.
  7. Integration with tools - Jira and versionOne are the tools we are working with. I also refer here to the ability to export data from our current tool. 
  8. Integration with automation - Or, as the folks call it - a decent API. it's not critical for me at the moment, but in the long run I would love to connect my automation to my test management tool.
  9. Exporting data - 'Cause, you know, choosing a tool isn't a catholic wedding. 

Now, have I forgotten something?