Necessary Conversations – 1

Thanks for meeting with me <fill in Project Manager’s name>!  I appreciate this opportunity to explore the testing approaches for this project.  I realize we have just started planning and have no product designs yet, but this is the best time to have this conversation.

Soon, our team will begin to absorb and understand business needs, and transform them into viable products.  The Testing team, Testers and Test Engineers, look forward to collaborating with the team on that effort.

Yes, I can see where you might believe there is nothing to test.  Many are mistaken in this belief that there must be a product before testing can execute.  I would argue that the business needs will require some scrutiny and I believe Testers are best equipped to ask questions about assumptions and details.  These questions will help clarify the needs, clarify product definitions, and reduce the number of defects resulting from misunderstood or poorly written definitions.

Why the Test Engineers, then?  I’m glad you asked.  They listen to conversations for opportunities to make testing smoother for everyone.  By everyone, I mean Testers and Developers.  Basically, we have been practicing Shift Left, that is, moving evaluations closer to product construction.  We believe it can make a difference on this project.

How?  When the project team delivers unit tests with their minimal viable products, we know requirements are probably met.  This helps the Testing team focus on risks.  The time to complete testing is likely shorter.  That improves Pace.

Also, unit tests provide a first look at the quality of the product.  Both Testers and Developers review these tests.  More scenarios may be added to the unit test suite so the quality improves.  Unit tests are a leading indicator of quality and improve the confidence of Quality in the product.

The unit tests execute with every build.  If the build fails, the project team stops until they know the Build passes.  No sense in letting defects deploy because when they do, it is both unplanned down time for the team and an administrative defect management exercise.

Lastly, a growing suite of unit tests become the regression test.  We don’t need a large testing event (saving time and improving pace).  Additionally, the product team can confidently refactor and maintain the product in the long term which supports the Team.

Thanks for indulging me!  I look forward to a great project!

Challenging Questions – 1

The challenge becomes one of changing the question from

Why would we need a tester at this design meeting?

To

Why isn’t the tester invited to the <any product discussion> meeting?

 

Unit Test Advocacy

Unit tests – those tests created, executed, and maintained by developers – are no longer optional or a luxury.  In a world that demands CI/CD environments, unit tests are a necessity that keeps product updates flowing into production.  Unit tests are not the domain of developers, they are the domain of quality advocacy.  They are activities that are part of a team that accepts and pursues quality products AS a team.

Unit Tests Impact Pace, Quality, the Build, and the Team

  • Unit tests aid pace in detecting defects early and reducing post construction testing.
  • Unit tests improve quality by encouraging collaboration with the testing team to identify multiple scenarios and executing them early.
  • Unit tests help determine the status of the product by executing tests before check-in and after a build.
  • Lastly, unit tests demonstrate respect for your future self and your teammates. Everyone depends on prompt, valid, and valuable information provided by unit tests.

Testing as an Advocacy

When you work in testing long enough, you develop or adopt positions on many aspects of testing.  Some positions may be influenced by your environment, some by your peers (respected and otherwise), and some by practice.  Work in testing longer and you may want to share your positions and occasionally encourage others to adopt them.  We see this with testing models or techniques, testing schools of thought, and testing automation.  I believe it is testing positions and the varied interpretations, discussions, and debates that makes the craft a satisfying career choice.

I believe it is becoming something more.

With the introduction and practice of agile methodologies (Scrum, DevOps, et al), the practice of testing inside those methodologies has grown in importance.  Testing must not “wait until the end”, or plan large testing events “after the code is deployed to the test server”.  Waiting impedes project pace by time spent waiting and by discovering defects that were in the code while we were waiting.
The demands of business are driving the adopting of CI/CD and testing can not only help with that, it can drive it.  Testing must drive project pace and to drive project pace, we must become advocates.

Testers advocate for testability, shift left, and buying more than building.

Testability
Testers must advocate for testability in requirements and designs.  Testing can no longer afford to wait for information.  Rather, it must influence requirements for a single clarity and collaborate with team members to share that clarity.
Additionally, testers must actively participate is product designs (high level and detailed) to influence them for testability.  Request the design be transparent with key information and behaviors by using some form of logging, and request the design be controllable by having the ability to mock product objects.  When a product has good testability, it easier to test and can be tested earlier and quicker.

Shift Left
Testers must advocate for Shift Left.  Shift Left encourages new and changed products be evaluated closer to construction.  In many cases, this means more unit tests and deeper unit tests.  In some cases, the unit tests become the regression suite that can execute at any time.  Regression no longer need occur at the end of development!  We need to know as soon as possible if a recent change has impacted the application.
If much of the testing is shifted left, what do testers do?  They are reviewing the unit tests and suggesting more, they are exploring risks, and they are exploring environmental dependencies such as security, configurations, and connectivity.

Buy More Than You Build
Testers must advocate for buying tools and utilities rather than requesting them be built.  There are certainly many cases where building a tool or utility makes sense.  For several other cases, buying tools and utilities can get testers testing quickly.

I believe by advocating some or all of these ideas, testers become project drivers and CI/CD supporters.

Lead on, Testers!

An RPA Journey

Last Summer, I was assigned to a Robotic Process Automation (RPA) project as the Lead Developer. RPA is a growing field because the automation can improve work throughput at a greater accuracy.

We recently completed the development and introduced our automated process.  A process that once require tens of hours was completed in minutes.  While it was very gratifying to deliver this product, I look forward to returning to test engineering soon.  As I take leave of this RPA world, I thought about the development experience and wanted to share some thoughts.

From Test Engineer to RPA Developer?
I was looking for a different gig within my company.  One platform was experimenting with RPA and thought a Test Engineer (that is, a person with automation experience) would be the best fit.  When I investigated the job a little more, there was some chance that I could explore AI.  I was offered the position and started learning about RPA and an RPA tool.

Emperor’s New Clothes
RPA is marketed as tools that can save labor, improve accuracy, and increase productivity at a lower cost all through automation.  In my opinion, all of that is true.  I also believe that RPA tools are marketed more towards the business side of an enterprise.  The sirenic user interface of an RPA tool may have you believe that anyone can create process automation.  The reality is that these tools are used to write programs, and writing programs – even RPA programs – is challenging.

The RPA tool is actually just another Integrated Development Environment (IDE).  Make no mistake – it is used to create scripts that interact with your applications in the same way as your employees.  In that sense, the creation of a script is very much a software development effort and must be treated as such.  There are no robots here and the use of the word “robot” is very misleading and should be considered window dressing.

If you believe that someone with Excel macro experience can use RPA tools to deliver high quality, error free automation, you will be, in many cases, profoundly disappointed.  Excel macros and RPA programs are on opposite ends of a development complexity spectrum.  Without an understanding of software development methodologies, basic programming concepts, data quality, or detailed process definitions, it is possible to realize significantly less benefit than expected.  In my opinion, the “best practices” recommended by RPA tool companies are a sad substitute for software development experience.

Early in the project, I found many similarities between what I could do in Visual Studio (also an IDE) in C# and the RPA tool.  With my experience in software development, I was able to learn the RPA tool quickly.  The RPA user interface is but an abstraction of basic programming concepts, and it reminded me of the Lego Mindstorms IDE used by many children to build and program small mechanical machines (these machines can perform some sophisticated activities as demonstrated annually by many First Lego League teams).
In my opinion, placed into the hands of a professional developer (or developers), the RPA tools can deliver great products that can benefit your enterprise.  However, that benefit can be realized only with a strong working partnership between the development team and your business team.

Tests and Testing Tell the Story
The first process we automated was complex.  It was as complex as a new API and warranted the normal approach of decomposing it into components.  The components were described in multiple story cards and we started construction.

At the end of a story card, we found it valuable to create unit tests for the components.  Even the tests were built in the RPA tool.  In this manner, we could evaluate multiple scenarios easily.  When we had a critical mass of components, the development team met in what we called an “Integration Session” to assemble the components into the automated process.

We evaluated the automated process with sample input data, and we were able to provide diverse scenarios that exercised the process.  We found defects and corrected them.  We were also able to demonstrate the automated process to our business team members frequently.

Discoveries Along the Way
The description of our development approach should sound familiar to agile practitioners.  Agile provided us the flexibility we needed to learn and adapt.

For example, we wrote code to collect a set information for a person from an application.  We discovered that, sometimes, there is more than one person.  We refactored to collect a set of information per person.

We wrote code to place numbers into a spreadsheet and retrieve formula results.  We discovered that, sometimes, the spreadsheet provides feedback and the formulas require a macro to make adjustments.  We refactored to detect the feedback and run the macro.

We continued in this way until we deployed the process and started using production data.  While we still made discoveries and refactored, we also realized that the cost of some changes may not have enough benefit to justify the change.  We discovered “done” and, as hard as it was, we needed to say “enough”.  That doesn’t mean our discoveries are not addressed rather it means the project met its goals.  The discoveries and enhancements will be addressed over time.

Right Size Your Team to the Process
When considering processes for RPA, the complexity and effort should help set the level of project management.
Our team is a handful of developers and business consultants.  To resolve details for our first process, we required information from our business consultants frequently.  Additionally, we relied on a separate team for test data.  Since RPA is a software development effort and the process complexity was high, I appreciated the benefits our project manager brought to our project.
However, the second process was far simpler.  In my opinion, it was simple enough that a two developers could complete it without the need for project management.

Celebrate The Team
Over the course of my project, the developers and I worked with some wonderfully gifted and passionate business people.  They knew their business processes, they knew some of the challenges, and they believed in the promise of process automation to improve their productivity.  Together, we defined, built, tested, and celebrated the products we created.

Deploy small, deploy often.

I recently a part of a production deployment.  It is not like a deployment of the early 2000s where everything went up and you expected it to work.  No.  It was deployed in parts because, well, we forgot stuff and we discovered stuff.

We deployed the product and started it up.  We discovered something we didn’t expect.  In the early 2000s, we would have executed the back out plan and deployed another day (a delay in business value).  However, this is 2019.  We made a correction in production and tried again.  We did this several times until we finally had the entire product operating as expected.  Early reviews of its functions say that the product was even operating successfully (read: providing business value now).  I love testing in production!

Could we have had a better plan for deployment?  Yes!  Based on this experience, our next deployment will be better.  Ain’t that being agile?

Did we deploy the product that was approved by multiple interested parties?  Hell no!  We deployed something that demonstrated excellent functionality in a non-production environment.  When we deployed to production, we solved issues like forgotten configurations, forgotten files, and an unexpected data format.  That is, we LEARNED a lot about our product in another environment, corrected our mistakes and misses, and got it working.  When it started working, then the real learning started!

We discovered some things our product could not do because of data quality (by the way, our error handling caught these!).  These will be addressed in a future deployment.  We discovered some functionality that needs tweaking.  This will be addressed in a future deployment.

Going forward, we deploy small and deploy often.  We will learn as we did above because it is soooo valuable!  Testing in production is not a crime, it is a learning experience!  If you can, go forth and learn!

Here’s a New Idea You’ll Love!

Think about the last time you heard an idea or suggestion that was extremely, violently, and orthogonal to how you think, believe, or live.  Of course your reaction to it was welcoming, engagingly curious, and you had a deep, deep desire to try it.

Probably not.

I see this occasionally, as many testers might, when I suggest alternatives to existing or established testing practices.  In my experience, the reaction is usually negative.  Occasionally, there is so much push back that surmounting just the negativity would be a day’s work.

My approach has been to keep trying because I hope, perhaps a quixotic hope, that one day they may ask the key question.  I listen for this question every time I make my wild suggestions.  I hope, just once, they would ask how.

“Joe, how would that crazy idea be possible?”

For now, I wait until they are ready.  Forcing the idea and my notions of implementing it would waste time and drive them away.

How have you approach the suggestion of your crazy ideas?