Daily Posts

Should feel like an intellectual exercise between friends

From one of my favorite books – How google works

“Intellectual” – testing the limits of a candidates thinking capacity

Can they dissect a problem in smaller questions to answer

Do they enjoy the process

“Friends” – the candidate must feel comfortable and open to speak their mind

Interviewers coming across as authoritative figures or assertive are less likely to foster that environment

I have seen wonders happening when the other person is open in sharing what they are ‘really’ thinking

Don’t judge any answer on the spot, come across as helping and empathetic

That goes a long way in helping the ‘real person’ come out and talk

More than often it’s not but it must

There are a couple of reasons for this from my understanding

Automation results are not important since they might not be checking an important part of the test strategy

Or the effort is in some way being duplicated

Or there is not enough by in from the complete team on this

Whatever the case may be, it should be considered important

Which will not happen IMHO unless the push comes from upper management

More on that here:

https://goo.gl/yYuWSv

Years ago I had to make this choice, between staying open or closing

That’s when I started believing in sharing and caring and till date is one of my strongest values

I was at a crossroad between closing my knowledge to myself to safeguard safety of my job

Or opening up, risking my job (what I thought) but spreading the good which I always have been passionate about

It was faith that helped me stand firm, despite seeing imminent harm coming my way

I decided to keep spreading good because

All that’s up to me is choosing between the right and tough path, or the easy and wrong path

The result was never really in my hands, it has been and always will be as God decided

All I can have is believe and faith

But once I walked this path,

It all reciprocated back in many times more

The result was far better than could have imagined

This is more of a reminder for me than to anyone else

Keep sharing, keep caring and keep believing..

It’s going to be a far more rewarding life than locking yourself into a tomb of selfishness

Whenever making a decision, default state should be open

The TCP/IP protocol case in point

Just by keeping it open, the internet was born

Another example, Jenkins

Keeping it open to connect and open source, it’s the most common CI tool and brought about the concept way early than it’s time

We usually have our default state as closed, under special circumstance we open it up

This strategy is not as effective anymore in this age

I’ve learned you need both detail and a minimal version

I’m always big time on logging test results

I am happy when our results provide sufficient debug information

So the engineer can figure out the problem just by looking at the log files

For which you will need screenshots of errors (in UI’s case)

Also the results need to be ‘readable’ and ‘similar’ to the test cases rest of the team is used to

And lastly, recently I’ve felt I need two versions, the detailed report with screenshots of errors

And a smaller version for archiving purposes

Helps to go back and see what test was failing 6 months earlier while diagnosing a problem

More here:
https://goo.gl/z2g9ui

From the age of craftsman to industrialism and back to craftsman

A few hundred years ago there were no Jobs, because no one employed anyone (like today)

It was the age of craftsmanship, each person used to sell their skill individually

Came along the industrial revolution and we needed ‘obedient and intelligent clerks’ to do the same task day in and out

With time we’ve become smart enough to automate any process which is repeatable

Hence all those workers doing the same job day in and out will be replaced by machines

But craftsman are now on the rise, we look for ‘innovation’, ‘newness’ which is not repeatable (Credits: Seth Godin)

In the context for testing, are we doing ‘innovation’, or just mundane repeatable tasks..

Testing IMHO is anything but a repeatable set of instructions

Thoughts?

#RedefiningSoftwareQuality

And by connect I mean talk to them in person?

I don’t know who is the least, but software engineers are surely are one of the last to talk

We’d rather spend more time typing it on some form of electronic media instead of talking to the person

Using technology is good, but typing to someone down he hall is not cool..

80% communication is through body language

A research showed 86% of sales pitch outcomes were predicted correctly without hearing a WORD of what was being said

More on communication and Engineers here:

One of them could be to use Jenkins running multiple Agent nodes

That means yes there are other ways (other than Jenkins)

Agent nodes in Jenkins (more commonly referred to as slave nodes) are used run ‘jobs’ on multiple environments

And there are a lot of different ways you can do this setup

From having multiple physical machines, to VMs to dockerized environments to cloud hostings or SaaS services (Sauce Labs)

The variables I’d consider against each:
– Upfront cost and time
– Vs on-going / maintenance cost and time
– Scalability in the long term
– Support for all needed environments
– Team skill set / learning curve

Everyone has a preference, in some cases I found VMs did a good job

However my preference would be for Docker, and if budget allows hosting services

Anything else you’d add to the equation?

Which unfortunately dimishes with age

I see my kids as toddlers are curuious every second they are awake

Sometimes I wonder what happens to us as we grow, where does this urge to explore and learn go

There can be many things attributed to it, from educational methods to the society at large

What’s important is to keep the fire alive

Stay foolish, stay hungry to learn, explore and share

You can be old at 18 by stopping to learn and explore

Or you can be young at 60 by staying hungry and willing to learn and evolve

Remember when it took ages to setup localhost servers like TomCat back in the day?

I am amazed how that process has changed by now

Created a front end application in Angular 4 a few months ago

Before starting I was dreading from the localhost server installation

To my surprize, NPM did the whole thing in the blink of an eye..

I call this abstraction over abstraction

Libraries and whole frameworks have been developed smoothening the process

Now you can spend less time making code bases compatible with one another and focusing more time on the architecture and logic

Or just a general I’ll do task A, and be open to anything that comes your way to do also?

We have a lot of distractions around us (more than we should have)

And the human mind can truly focus only on one thing at a time

That’s when the 2x – 10x effects come in – through focus (also known as ‘deep thinking’)

With a to the minute plan, at least for work hours, you would react all day to external events

Which would have diminishing returns and you wouldn’t accomplish as much as you could have

Track your day and be very particular about where you spend your time

After all, time is the most valuable asset we all have!

And are the terms framework, library, tools and dependencies interchangeable?

You might say they are not, but I’ve often seen these terms used for the same things

I’m not trying to distinguish between them all, but framework has a much larger meaning than the rest

Therefore any one library, tool or dependency cannot be a framework

Dot Net is a framework, no one would call JavaScript a framework?

Then why do we call automation libraries like RestAssured, JUnit etc. a framework?

More here

One way is to write (BDD) feature files for the story

User stories are an improved form of the traditional ‘FRS / SRS’

And sometimes the ambiguity we saw with traditional requirements can be felt in stories as well

Feature files explaining how the implementation should work is a great way of clarifying

It makes the ‘subjective’ nature of the story to a more ‘absolute’ expected behavior

And you can link your gherkin files to your user story

More on that here

If the purpose of end to end is testing different layers of the technology stack, this certainly does not do the job

UI automation does check the logic and data back to DB and return till the UI

But testing at the UI has a limited scope compared to service or DB level

If you do have UI automation checks, assuming your testing actually testing the complete technology stack is not accurate

Some scenarios are going through, but you might be, missing out on a lot

Therefore, having tests on layers should really be considered ‘end to end’ – complete stack testing

#RedefiningSoftwareQuality

I’ve seen different people having different interpretations of the term

Most common and (correct) IMHO is testing along the stack

A test which covers functionality of the UI, service, business layer and the DB

Hence end to end – from UI to DB

The other meaning taken is testing a use case from start till the end

The ‘ends’ meaning start and end of one complete user flow

This meaning is seldom used, I think is not the correct term and should be described as use case or something to that affect.

#RedefiningSoftwareQuality

Agile is not a direct pre-req to CI, although they both work towards the same goal

Agile is a development process encouraging to develop, ship and iterate quickly

Continuous Integration facilitates shipping quickly

By using tools to move a software update from development to deployment

So yes, you can achieve CI without strictly following agile

But some form of agile practices might be essential

CI would not be effective with a waterfall resembling process

More here:
https://lnkd.in/fYvwAiF

Today’s research concluded there is no ‘simple’ way

We as automation engineers can understand the necessity of clearing cache

However, turns out this is now a standard development practice to handle revisioning of your client side scripts / files

In which case you don;t need to clear cache to see the latest changes

In the abnormal case where it is not done by your AUT,

The only way I found was running ‘incognito’ mode.

The closest solution was Chrome’s ‘command line switches’, but there is none for clearing cache or running in ‘disable cache mode’

To do that (disable cache in regular mode) from the UI for testing:

https://lnkd.in/fnfAnuA

If someone knows a way to do this through scripting (JavaScript, cmd whatever), let me know (for chrome)

Might not be strictly any one, but my vote is for soft science

IMHO: Testing is about validating an ‘imagination’

An imagination of a feature, which a bunch of people from different backgrounds decided on

And mostly not everyone was imagining the same thing to begin with

And sometimes most stake holders are not on the same page till the very end either

So, it’s more about managing ‘perceptions’ of what the feature should do

And therefore, more of a social science than a hard / pure science

#RedefiningSoftwareQuality

Creating: recording and deleting data..

Either you create data on the fly, or have it in the system before hand (like seed data)

Recording meaning forms to write test data in, DB, excel / csv, other file formats, within the tool and my favorite: JSON

Deleting: once the test is executed delete all data not needed anymore aka clean up script

And my favorite data management style: Restore the DB. Have a baseline with all the seed data, restore that before execution. Before executing next time restore again..

From an article I wrote for TEST Magazine (Sept 2017 issue):
https://goo.gl/TFtSqE

What goes in the user story and the feature file?

Feature file: behavior of the feature described in ‘simple language’ (called gherkin)

This is what I use to help distinguish:

User stories define the ‘what’ of the feature to implement

And the feature file explains ‘how’ the implementation will behave

Both have thier own place and importance, therefore should not be tried to combine into one another

Plus I feel this is where BDD has the greatest value, elaborating the user story in terms of the precise desired behavior of the implementation and used across the team

More here:
https://lnkd.in/fRrAM7Z

Intros:

Jenkins – A Continuous Integration tool – move from code build to running checks to deployment

Pipeline – A process in introduced in Jenkins v2.0 to schedule tasks one after the other

Groovy – A n Object oriented language built for the Java platform – can be used as a scripting language (like in Jenkins)

What’s amazing about this?

I feel it gives you lots of control over configuration

The syntax is very clear and straight (for the most part),

And things get ‘dead’ easy with the ‘pipeline syntax’ help Jenkins provides which generates snippets of codes for you based on selected options

Can your brain focus on multiple things at the same time?

In the information economy the people to thrive are who invent

The terms knowledge worker(Peter drucker) and smart creatives (google founders) are common

Yet how much of our time do we spend on thinking deeply?

Shallow activities, just passing the buck around does not create the needed value

At the minimum work with focus and precisely on one thing only

More on the subject: “Deep Work” by Cal Newport

Is there any tool that can go well to the last mile? I think not..

After all software products are developed using many frameworks right?

I feel the biggest challenge tools face these days are integrations

Firstly – the automation pyramid right – test on all layers (UI, API and DB)

I don’t know of any one tool that can hit all these levels effectively

Secondly tools are usually great at few things, not at everything

You might want to use different libraries for different purposes

A tool might be great at object recognition, but has a not so good reporting structure

To bring a full circle, you would eventually need CI support as well

Definitely use more than one tool, in fact plan to use multiple tools from the get go

More at:
https://lnkd.in/fahFtQq

Use tools which provide a resultant benefit – Need of the hour for automation folks

After every few months a new shiny tool comes along demanding our attention

In a frenzy of not to be left behind in the ‘next big thing’ everyone rushes to it Cucumber (used just for automation only) is a good case in point

Cal Newport in Deep Work suggests weighing benefits vs cost for using social media tools

Use the tool only if the benefit outweighs Identify the main goal and key few activities that support this goal

How beneficial is this tool towards that?

Now apply this to automation, will using cucumber just within the automation team generate a resultant benefit

I have a strong feeling it will not

Take Away: Stop running towards implementing the next shiny thing, unless it supports your project objectives

How was it born and what concepts were adopted from the start?

From my study seems we took a lot from TQM

Which I feel might have worked then, but not applicable today

I find hardly any synergies between software and physical products quality measurement

Until recently you would hear people from testing talking about six sigma

What does that have to do with software testing?

The Quality gurus like Edward Deming’s had great findings

But could not be taken ‘as is’ for software testing without any enhancement or even changes

Here we would run into a distinction between Quality and Testing

And I’m not super certain if I want to go there

The question I am trying to figure out:

Is software testing and / or quality built on concepts suited for today’s software?