Hello,

As part of on-going operations to improve the functionality and the performance of PractiTest we will be carrying out maintenance operations to our servers during the weekend of August 9th, 2014. Even though most of our maintenance does not usually cause any downtime, this specific operation will require us to have some downtime in our service.

In order to minimize the impact of this operation we have scheduled our maintenance to happen on Saturday, August 9th, 2014 at the following time:

• GMT – 5:00 to 9:00
• CEST – 7:00 to 11:00
• Eastern US – 1:00 to 5:00
• Pacific US – 22:00 (Friday Aug 8) to 2:00 AM
• Eastern Australia – 15:00 to 19:00

You can follow our live updates for this operation via PractiTest’s Twitter account.

As always, we will be more than happy to provide additional information and answer any questions you may have. Feel free to send your questions to our support.

Best regards,
The PractiTest Team

5 Agile Principles You Can Apply to Every Type of Development Process

Date: 2013-01-01

There is something professional consultants may not want you to know:

You don’t need to make major changes to your development processes in order to gain many of the benefits from Agile principles.

If you take the time to truly understand Agile (and not only repeat the Pros & Cons circling around the web), you’ll appreciate the fact that Agile is not a methodology but an approach to software development that can be applied to every methodology. Sure, methodologies such as SCRUM and XP were designed to make specific use of Agile principles, but this doesn’t mean you need to work this way in order to gain all or most of the benefits of Agile.

Some work Agile without even noticing it

A couple of months ago we talked to a customer who told us they wanted to work using Agile principles but had not had the time yet to implement SCRUM in their organization. The team’s manager mentioned that a SCRUM consultant had come to talk to them about implementing Agile, but after further review he decided it would be better to wait until their current release was out the door, within the next 6 to 9 months, to make all the necessary process changes.

This manager, being so impressed with what he heard, asked the team to make small changes and start implementing some of the ideas the consultant had suggested. And so, the team started having short 15 to 20 minute update meetings each morning over coffee and bagels.

Instead of having each programmer work on long tasks that could take between 6 to 8 weeks to complete, they started organizing tasks for shorter periods and worked in task teams of 2 or 3 programmers.

Another thing they did was to get the testers to work earlier and more closely with the developers, beginning during the coding phase itself, Testers would perform preliminary tests on the unfinished product and also give programmers ideas on how they could improve their Unit and Integration tests. As part of this process, programmers also “learned” how to run part of the manual test cases themselves before committing their changes as part of their “internal sanity.”

Finally, the manager asked the whole team to schedule a formal meeting with Product Marketing at the end of each month where they would demo the progress of the features. During these meetings Marketing would also provide feedback that could still be implemented for the current version’s development without delaying the release.

The manager told us that since they started working this way the productivity and the general working environment in the team improved greatly, and that he was really looking forward to implementing SCRUM in the team.

What he had not understood was that, without making any revolutionary changes to the way they work, they were already implementing an important number of Agile practices and experiencing their benefits.

The Road of Small Changes and Improvements

The story of this manager is a great example of how Agile can be implemented using small changes to your overall process. There is no real need to carry out a revolution in order to achieve many of the results you are looking to gain.

Following are a number of ideas that can be taken from the story above and that we believe can be implemented quickly regardless of which development methodology your team is currently using.

(1) Work in small/er chunks

Instead of working with a small number of very large requirements or tasks, break them down into smaller, more easily managed chunks that can be completed in shorter time intervals (days or weeks). This way you are making sure tasks don’t start taking up more resources than you originally allocated (because if your planning assumptions start slipping you will notice it within 2 weeks instead 2-3 months into the work) and most importantly, you will be able to deliver features faster to Testing and to Product Marketing and get feedback in time to make the necessary fixes and adjustments without affecting your release date.

(2) Increase the collaboration and communication between programmers and testers

If the idea is to get feedback about the features to the developers as quickly as possible then the best way to do so is to test sooner, many times, even in parallel to development.

You can achieve this in multiple ways, for example by inviting testers to run their test directly on the development environment as soon as parts of the features are ready (instead of waiting until everything is completed).

Another way is by having testers work with developers to plan and write their Unit and Integration tests in ways that will help them catch more bugs more quickly. And finally, how about we start teaching programmers how to run at least part of the manual and automatic tests written by the testers as part of their Sanity Sessions before committing their code? We see many teams where developers have their own Test Sets in PractiTest that they need to run before committing their code to the main branches.

(3) Have more automated tests and run them more often

This is one of the first principles applied by Agile teams but in fact, it is logical for every type of project. Make a commitment and a conscious investment in automation.

Start by instructing your developers to create Unit and Integration tests for each new feature or major bug fix.

You can also have your testing team create automatic tests to cover as much of your product as possible, and instruct your developers to code in ways that will make this functional automation simpler and more robust (for example, by using correct instrumentation of the GUI elements).

But creating your tests is not nearly enough. You need to have a framework that runs these tests as often as possible and provides immediate feedback to programmers whenever they’ve introduced a bug.

Today there are a number of very good Continuous Integration Frameworks (such as Jenkins, Bamboo or TeamCity), all of them can be integrated into PractiTest using our Robust API. Finally, you will also make sure your programmers comply with the golden of rule of “you broke it, you fix it. RIGHT AWAY!”

(4) Seek quick feedback and continuous improvement

The greatest enemy of improvement is human behavior: no one likes being criticized, and we mean that. No one!

That is why whenever we work on something, we don’t like showing it to others unless we feel it is complete and our audience will be able to understand “exactly” what we did.

But as you may already understand, this is counter-productive in programming because if we wait too much to get feedback then we won’t be able to implement any changes without missing our delivery targets.

So what can you do?

Basically, overcome the trauma of being criticized by making it a policy to have everyone present their progress to the rest of the team and product marketing – as they are working.

Work on creating a culture where people know how to give and receive feedback. You can achieve this by making sure feedback is always directed to the work and not to the person, and also by having people give feedback on both the good and bad things in the product (and not only focus on stuff that needs to be fixed).

It may not be easy at first, but it will be easier with time and the value gained by this is simply incredible.

(5) Embrace change and work accordingly

This may be the cornerstone of Agile – the realization that regardless of how hard you work on planning your project and how good you are at it, in the end, stuff will change and you will need to adjust your plans.
But, slogans aside, how do you embrace change?

First of all plan less, not less deep but yes, less for the long-term since you cannot foresee exactly what your reality will be a few months down the line.

Seek feedback sooner rather than later, make sure that if you do need to change features and plans, you know this 2 to 4 weeks into the project and not 6 to 9 months into it.

Plan for change and make sure your team is aware that change will indeed come and it will be accepted; this makes it easier for them when they are faced with that reality and need to cope with it.

Making small changes should be part of your work culture.

One of the best principles you can adopt from Agile is the understanding that just as the product and the requirements are constantly changing, so should your work processes be dynamic and adaptive.

Be open to asking questions about whether you are working in the best and most effective way or if you can make small (or large) improvements to the process?

Be open to feedback, seek it and even reward the people who give it. Once you are able to introduce the acceptance of feedback into your company culture, you will see how things really start improving, almost on their own.

A quick guide to Agile testing in PractiTest

Date: 2012-02-01

More and more teams are switching to Agile development, in order to increase their efficiency and meet the competitive requirements of the field and their users.

Agile software development is very different from more traditional forms of development. As such, it – only logical that adapting an Agile development methodology will require a change in the testing process.

Managing your Agile testing process using PractiTest

Agile testing is a team effort, and therefore requires high-quality communication between team members. Since the testing process may seem less “organized”, it – very important that the relevant information is available to all parties involved. You should always know what should be tested, who – testing what and where everything stands.

Here at PractiTest we are ardent believers of agile development and testing, and we try to design our test management software accordingly. Many of our features can contribute significantly to your agile testing process (as well as make your life a lot easier regardless of your testing methodology). Using Traceabiliy between entities, dynamic views instead of rigid folders, the flexibility of our customization settings, and the graphical information displayed in the Dashboard – your testing process can be more effective than ever before.

User stories

In more traditional testing methods, you would use the Requirements module to define how your system under test (SUT) should work, and what should be tested. In an Agile testing process, you can replace the traditional requirements with user stories – short and precise descriptions of your end users’ needs. You can then organize your User Stories using Custom Views.

Sharing tests in the test library

In PractiTest you can write and manage your Acceptance Tests (i.e. – tests designed to ensure that your requirements are met) within the Test Library, linking them back to the User Story where they originated.

You can then use the history, comments and notifications features to allow everyone to add their inputs into these tests, and to be informed about any changes made by other users.

You can simply create a test for each User Story, where developers can provide their inputs to testers as they come up with ideas during the design or coding process.

Creating tests sets for each user story

We recommend creating Test Sets for each User Story Independently. These test sets can contain the acceptance tests, functional tests, and any other testing operations needed for a specific User Story. This way you can get a better sense of coverage and completion for each User Story. It is also recommended to use the Tractability function to link between tests and their user stories.

Grouping issues based on their target sprint and user story

When you report issues, use custom fields to assign them the sprint in which they should be solved.

Also, in order to have tractability between issues, tests and requirements, you should link your tests to their relevant user stories. You can report issues directly from your test runs (using “fail and issue”), or link the issues back to the tests they originated from, for full tractability.

Using views to organize your issues based on Sprints, Users Stories, Modules, etc.

A good practice is to use the Issues Module not only to report bugs, but also to manage all the tasks of your User Stories and Sprint. Create tasks to keep track of the activities of your project and their individual statuses.

Provide visibility using a Summary Dashboard and additional Dashboards per User Story

You can use the Dashboard to keep your team up to date with the status of the Sprint in general, and of each User Stories in particular.

With the help of the views you have in each of your modules, create one dashboard centralizing all the information for your Sprint, and then create additional dashboard tabs with information for each User Story independently.

Automation Tests Support Beta is now Publicly available

Date: 2011-02-01

Hi,

This weekend we released a new version of PractiTest with one feature in particular that has been requested by a number of customers – the public release of our Automation XBot Plugin.

Using the XBot, you can run automated tests and scripts created with virtually any tool (Selenium, Watir, QTP, etc) or any homegrown testing framework. You can learn more about the XBot from our Automated Tests documentation, and if you want to take part in this Public Beta just send us an email and we will activate this feature in your projects.

This version comes with a number of small additions in the Report Center, such as the ability to export your reports to PDF format as well as to work with Views on Requirement Reports.

The current release also fixes a number of smaller issues that were reported by some of you in the last couple of weeks.

We’ll be happy to get your feedback on these or any of the rest of PractiTest, you mail us directly or use our User Feedback Forum.

Multiple-select lists, Issue status resolution, and more added features

Date: 2010-01-01

With this new year we are releasing a new version that brings some of the functional features requested by many of you lately:

• Multi-select lists, with the ability to choose more than one value for the same field.
  
• Issue status resolution field, in cases where you want to add not only a status but a resolution. For example to specify the kind of fix performed, or the reason an issue is being rejected.
• Bulk deletion of tests, when doing mass operation on tests that require you to delete large numbers at once.
• And other smaller features and fixes throughout the system.

As always, we invite you to share any comments or feedback with us, both via our support hot-line or our user feedback site.

Last but not least we wanted to wish you a Joyful, Successful and most importantly Happy New Year!

PractiTest at the IGT Cloud Summit

Date: 2009-06-01

Last week we participated in the IGT Cloud Summit that took place in Exodia, Tel Aviv. It was pretty fun and we’ve got some pictures to share. We also met some interesting companies who presented their ideas and product.

Our logo (part of the 20 ‘cloud’ companies that were presenting that day):

Joel also gave a short presentation, explaining about the real need for PractiTest that came from, yes, our users: