Technology keeps changing, and so does the approach to how software applications need to be tested. Here are some trends that you should foresee to work in 2020.

There are several technology areas on which we foresee new trends in software Testing. So we planned a series of blog posts, each focusing on specific areas of a trend that Software tester needs to look into for 2020.

In this post, we want to do a short detail on the most happening trends in the software development world. That’s “DevOps”
What is DevOps: DevOps is a set of practices that combines software development and information-technology operations which aims to shorten the systems development life cycle and provide continuous delivery with high software quality

DevOps and Software Testing
The waterfall method of conducting software development has been becoming obsolete year by year. Agile has been the choice, to scale up turnaround times and improve productiveness on how the project team delivers the expectations of the business. Most of the software development teams have adopted Agile, but the irony is that the Agile turns out to be Hybrid Agile eventually, as the Agile manifesto is usually maneuvered to fit the comfort zone of the project teams or the corporate policies itself.

So to scale up development times and optimize end to end due diligence between Software Development and Operations, DevOps is the new approach around the block.

So how does it work and what does it mean?

So what it means is that this approach will reduce manual intervention and upscale development and testing turnaround times by the use of automated tools. As the entire working model of DevOps is a synergy of tools, the use of open-source tools becomes a mandate to reduce cost and accommodate affordability.

Some of the popular open-source tools for Software Testing are

So, with the use of these kinds of test automation tools, a testing team integrates the test scripts onto a CI server tool like Bamboo or Jenkins, which will use directional and sequential scripts to automatically execute test cycles on the testing environment whenever development team does new commits to the code. “Continuous Feedback” from the test teams allows the developers to fix issues and upscale turnaround times. This continuous feedback is from both development and the operational side of the DevOps stack of tools, which is what makes it unique and revolutionary.

About Resolve6 Software Solutions

As one of the leading technology shops for IT skill development and job placement services, in Toronto, Canada, our job placement program covers skill development in all the above tools, in order to prepare an aspirant to be an effective test automation specialist. No prior development knowledge is required for any new bee who joins our program. We have over 17 years of experience in transforming new aspirants into successful IT professionals.

Technology has created our software-defined world of today. As technologies change and evolve, we see the rise of new software development trends to further augment this growth. 2018 was no exception. We saw some exciting developments in the world of software development. We witnessed the rise of cloud-based software development, the cementing of DevOps, and the ever-growing importance of testing. But what about the year ahead? Here’s a look at some of the trends that will impact software development in 2019

Artificial Intelligence (AI):
Gartner estimates that the revenue from the AI industry will touch $1.2 trillion by the end of 2019. By 2022 the business value derived from AI is expected to reach $3.9 trillion. With the digital transformation wave taking over almost all organizations, it is clear that AI will continue to trend in the software universe for the next couple of years.

In 2019 we will see the use of AI to speed up and improve the accuracy of software development- be it in automatic debugging, for creating intelligent assistants to speed up development processes, to automate code generation, or to create and train an automated system to produce accurate estimates to develop MVPs faster…the AI impact will be all around and hard to ignore.

Blockchain, the meta-technology, holds the promise of completely reshaping software development. Blockchain consists of a single ledger of transactions and enables smart contracts. It has a distributed database that is accessible to a peer-to-peer network but is protected against unauthorized access. The technology is secured by cryptographic technique making the applications developed using this tech more secure.

Blockchain has already made its presence felt in several different sectors be it retail, banking, financial services, healthcare, and public administration. It is only a matter of time before Blockchain becomes a prime focus for organizations involved in software development. As security becomes top of the mind, the need for blockchain-based applications will increase. 2019 looks like a good year to jump on this technology trend.

Progressive Web Apps:
Progressive Web Apps leaped to our attention when Gartner announced it as a software trend in 2017. In 2019 however, with a more mature app ecosystem in place, we expect to see Progressive Web apps become more dominant and gain that promised place. As the app economy gets stronger and the mobile environment evolves, progressive web apps are gradually going to become the new normal in this changing environment.
Research shows that progressive web apps show a 68% increase in mobile traffic and are 15 times faster to load and install as compared to native apps. Progressive web apps also require 25 times less device storage space in comparison to native apps. These applications are also less complex to develop, are easy to maintain and provide the benefits of mobile experience with the features of browser technology. What’s not to love?

Security Rules:
Security has been on everyone’s mind in the software development space. The increased focus of security during software development is only going to increase in this year. Research from Alert Logic showed that data loss and leakage is one of the biggest concerns for cybersecurity professionals (67%). Threats to data privacy were the concern for 61% while 53% were concerned with breach of confidentiality.

Owing to the huge impact security issues can have on a software product and its users, organizations are conscious of baking security into the process of software development. Software development companies also have to keep a close eye on regulatory considerations for specific industries.

They must also follow security best practices and ensure that all security guidelines and protocols are met consistently. To make security more robust, organizations are also looking at Managed Security Providers or MSP’s for robust application security without compromising on development timelines.

Automated Testing:
While test automation has been around for a while, automated testing will continue to be a trend in 2019. This will continue for as long as there is a need to release better-tested products into the market faster -that means, forever! As testing gets deeply ingrained into every software development methodology, test automation will get even more pervasive with testing teams striving for greater levels of automated test coverage.

In 2019 we will witness test automation leveraging AI for better test accuracy. Tests will become more comprehensive, more intelligent, and more dependable. Even with that, that they will become faster and less taxing. The products will become better tested and more robust as a result.

Borrowing from, and evolving the technologies that help to automate testing, Robotic Process Automation or RPA will also become a dominating trend in 2019. RPA will drive to automate high-volume repeatable tasks, thus making them faster, more accurate, and less effort-intensive.

2019 promises to be an exciting year in the world of software development. It will be interesting to see how these trends develop over the course of the year. Check back with us at the end of the year for a review of our predictions. And, do feel free to add more about the trends you think will dominate software development and testing in 2019.

The premise behind the Reuse Model is that systems should be built using existing components, as opposed to custom-building new components. The Reuse Model is clearly suited to Object-Oriented computing environments, which have become one of the premiere technologies in today’s system development industry.

Within the Reuse Model, libraries of software modules are maintained that can be copied for use in any system. These components are of two types: procedural modules and database modules.

When building a new system, the developer will “borrow” a copy of a module from the system library and then plug it into a function or procedure. If the needed module is not available, the developer will build it, and store a copy in the system library for future usage. If the modules are well-engineered, the developer, with minimal changes, can implement them.

The Reuse Model steps
The Reuse Model consists of the following steps:

– Definition of Requirements  Initial system requirements are collected. These requirements are usually a subset of the complete system requirements.
– Definition of Objects  The objects, which can support the necessary system components, are identified.
– Collection of Objects  The system libraries are scanned to determine whether or not the needed objects are available. Copies of the needed objects are downloaded from the system.
– Creation of Customized Objects  Objects that have been identified as needed, but that are not available in the library are created.
– Prototype Assembly  A prototype version of the system is created and/or modified using the necessary objects.
– Prototype Evaluation  The prototype is evaluated to determine if it adequately addresses customer needs and requirements.
– Requirements Refinement  Requirements are further refined as a more detailed version of the prototype is created.
– Objects Refinement Objects are refined to reflect the changes in the requirements.

Problems/Challenges Associated with the Reuse Model
A general criticism of the Reuse Model is that it is limited for use in object-oriented development environments. Although this environment is rapidly growing in popularity, it is currently used in only a minority of system development applications.

The incremental method is in many ways a superset of the Waterfall Model. Projects following the Incremental approach subdivide the requirements specifications into smaller buildable projects (or modules).

Within each of those smaller requirements subsets, a development life cycle exists which includes the phases described in the Waterfall approach. The goal is to produce a working portion of the application demonstrating real functionality early in the broader SDLC. Each subsequent “increment” adds additional functionality to the application. Successive rounds continue until the final product is produced. Several of the
development models are variants of the Incremental model including Spiral and RAD.

The V-Model is considered an extension of the Waterfall Model. The purpose of the “V” shape is to demonstrate the relationships between each phase of specification development and its associated dynamic testing phase. This model clearly shows the inverse relationship between how products move from high level concepts to detailed program code; then, dynamic testing begins at the detailed code phase and progresses to the high level user acceptance test phase.

On the left side of the “V,” often referred to as the specifications side, verification test techniques are employed (to be described later in this skill category). These verification tests test the interim deliverables and detect defects as close to point of origin as possible. On the right hand side of the “V,” often referred to as the testing side, validation test techniques are used (described later in this skill category). Each of the validation phases test the counter opposed specification phase to validate that the specification at that level has been rendered into quality executable code

The V-Model enables teams to significantly increase the number of defects identified and removed during the development life cycle by integrating verification tests into all stages of development. Test planning activities are started early in the project, and test plans are detailed in parallel with requirements. Various verification techniques are also utilized throughout the project to:

– Verify evolving work products
Software Testing Principles and Concepts
– Test evolving applications by walking through scenarios using early prototypes
– Removing defects in the stage of origin (phase containment) results in:
– Shorter time to market
– Lower error correction costs
– Fewer defects in the production system
– Early test planning yields better test plans that can be used to validate the application against requirements
– Regardless of the development methodology used, understanding the V-model helps the tester recognize the dependence of related phases within the life cycle.

The Waterfall Model is the earliest method of structured system development. Although it has come under attack in recent years for being too rigid and unrealistic when it comes to quickly meeting customer’s needs, the Waterfall Model is still widely used. It is attributed with providing the theoretical basis for other SDLC models because it most closely resembles a “generic” model for software development

The Waterfall Model consists of the following steps:

1) System Conceptualization – Refers to the consideration of all aspects of the targeted business function or process, with the goals of determining how each of those aspects relates with one another, and which aspects will be incorporated into the system.

2) Systems Analysis – Refers to the gathering of system requirements, with the goal of determining how these requirements will be accommodated in the system. Extensive communication between the customer and the developer is essential.

3) System Design – Once the requirements have been collected and analyzed, it is necessary to identify in detail how the system will be constructed to perform necessary tasks. More specifically, the System Design phase is focused on the data requirements (what information will be processed in the system?), the software construction (how will the application be constructed?), and the interface construction (what will the system look like? What standards will be followed?).

4) Coding – Also known as programming, this step involves the creation of the system software. Requirements and systems specifications from the System Design step are translated into machine readable computer code.

5) Testing – As the software is created and added to the developing system, testing is performed to ensure that it is working correctly and efficiently. Testing is generally focused on two areas: internal efficiency and external effectiveness. The goal of external effectiveness testing is to verify that the software is functioning according to system design, and that it is performing all necessary functions or sub-functions. The goal of internal testing is to make sure that the computer code is efficient, standardized, and well documented. Testing can be a labor-intensive process, due to its iterative nature.

There are a variety of potential deliverables from each life cycle phase. The primary deliverables for each Waterfall phase are shown in Table along with “What is tested” and “Who performs the testing.”

Development Phase Deliverable What is Tested Who Perform Testing
System Conceptualization Statement of need Feasibility of System Business Analysts, Product Owner, Testers
Systems Analysis Statement of user requirements Completeness and accuracy of requirements in describing user need Business Analysts, Product Owner, Testers
System Design System design specification Completeness and accuracy of translation of requirements into design Design Analysts, DBA, Developers, Testers
Coding Application software Design specifications translated into code at module level Developers
Dynamic Testing Tested system, error reports, final test report Requirements, design specifications, applications software Developers, Testers, Users
Maintenance System changes Requirements, design specifications, application software Developers, Testers, Users

Problems/Challenges associated with the Waterfall Model

Although the Waterfall Model has been used extensively over the years in the production of many quality systems, it is not without its problems. Criticisms fall into the following categories:

– Real projects rarely follow the sequential flow that the model proposes.

– At the beginning of most projects there is often a great deal of uncertainty about requirements and goals, and it is therefore difficult for customers to identify these criteria on a detailed level. The model does not accommodate this natural uncertainty very well.

Developing a system using the Waterfall Model can be a long, painstaking process that does not yield a working version of the system until late in the process.

Early systems development often took place in a rather chaotic and haphazard manner, relying entirely on the skills and experience of the individual team members performing the work. Today, many organizations still practice Ad-hoc Development either entirely or for a certain subset of their development (e.g. small projects).

The Software Engineering Institute (SEI) at Carnegie Mellon University points out that with Ad-hoc Process Models, “process capability is unpredictable because the software process is constantly changed or modified as the work progresses. Schedules, budgets, functionality, and product quality are generally (inconsistent). Performance depends on the capabilities of individuals and varies with their innate skills, knowledge, and motivations. There are few stable software processes in evidence, and performance can be predicted only by individual rather than organizational capability.”

“Even in undisciplined organizations, however, some individual software projects produce excellent results. When such projects succeed, it is generally through the heroic efforts of a dedicated team, rather than through repeating the proven methods of an organization with a mature software process. In the absence of an organization-wide software process, repeating results depends entirely on having the same individuals available for the next project. Success that rests solely on the availability of specific individuals provides no basis for long-term productivity and quality improvement throughout an organization.”

Continue to Read about Waterfall Model

Software Development Life Cycle models describe how the software development phases combine together to form a complete project. The SDLC describes a process used to create a software product from its initial conception to its release.

Each model has its advantages and disadvantages, so certain models may be employed depending on the goal of the application project. Testers will work on many different projects using different development models. A common misconception is that projects must follow only one methodology; for instance, if a project uses a Waterfall approach, it is only Waterfall. This is wrong.

The complexities of projects and the variety of interconnected modules will often be developed using best practices found in a variety of models. The tester will need to tailor the best testing approach to fit the model or models being used for the current project. There are many software development models. These models are:

1) The Ad-Hoc Ad-Hoc
2) The Waterfall Model
3) The V-Model
4) The Incremental Model
5) The Iterative Development Model
6) Prototype/RAD Model
7) The Spiral Model
8) The Reuse Model

Continue to read about the Ad-Hoc Model

At current epic of Information and Technology progressive development, the analyzers generally encounter broad utilization of test information in programming testing life cycle.

The analyzers don’t just gather/keep up information from the current sources, additionally they create gigantic volumes of test information to guarantee their quality blasting commitment in the conveyance of the item for certifiable utilize.

In this way, we as analyzers should ceaselessly investigate, learn and apply the most effective methodologies for information gathering, era, support, automation and far reaching information administration for any sorts of utilitarian and non-practical testing.

To understand the Testing Process in an Agile Development Methodology, it is important to understand the Agile Development paradigm. 
 Although the Agile Software Development Manifesto came into existence in February 2001, the concepts existed long before that and were expressed in different ways. Spiral Development Methodology is one such example.

Understanding Agile Software Development:
The Agile Software Development primarily focuses on an iterative method of development and delivery. 
The developers and end users communicate closely and the software is built. A working piece of software is delivered in a short span of time and based on the feedback more features and capabilities are added. 
The focus is on satisfying the customer by delivering working software quickly with minimum features and then improvising on it based on the feedback. The customer is thus closely involved in the Software Design and Development Process. 
The delivery timelines are short and the new code is built on the previous one. 
Despite this, high quality of the product cannot be comprised. 

This creates a different set of challenges for Software Testing.

How is Testing approach different in an Agile Development Scenario?
The Testing Strategy and Approach in Agile Development could be very different from traditional bureaucratic methods. In fact it could vary with project needs and the project team. 
In many scenarios, it may make sense to not have a separate testing team. 
The above statement should be understood carefully. By not having a testing team we do not consider testing to be any less important. In fact testing can done more effectively in short turn around times, by people who know the system and its objectives very well. 

For example in certain teams Business Analysts could be doing a few rounds of testing each time the software version is released. Business Analysts understand the Business Requirements of the Software and test it to verify if it meets the requirements. 

Developers may test the software. They tend to understand the system better and can verify the test results in a better way. Testing for AGILE Software Development requires innovative thinking and the right mix of people should be chosen for doing the testing.

What to test?
Given the relatively short turn around times in this methodology it is important that the team is clear on what needs to be tested. Even though close interaction and innovation is advocated rather than processes, sufficient emphasis is given to the testing effort. 

While each team may have its own group dynamics based on the context, each code has to be unit tested. The developers do the unit testing to ensure that the software unit is functioning correctly. 
Since the development itself is iterative it is possible that the next release of code was built by modifying the previous one. Hence Regression Testing gains significant importance in these situations.

The team tests if the newly added functionality works correctly and that the previously released functionality still works as expected. 

Test Automation also gains importance due to short delivery timelines. Test Automation may prove effective in ensuring that everything that needs to be tested was covered. 
It is not necessary that costly tools be purchased to automate testing. Test Automation can be achieved in a relatively cost effective way by utilizing the various open source tools or by creating in-house scripts. These scripts can run one or more test cases to exercise a unit of code and verify the results or to test several modules. 
This would vary with the complexity of the Project and the experience of the Team

Typical bugs found when doing agile testing?
Although nothing is typical about any Agile Development Project and each project may have its own set of complexities, by the very nature of the paradigm bugs may be introduced in the system when a piece of code is modified/enhanced/changed by one or more Developers.

Whenever a piece of code is changed it is possible that bugs have been introduced to it or previously working code is now broken. New bugs/defects can be introduced at every change or old bugs/defects may be reopened.

Steps Taken to Effectively Test in Agile Development Methodology:
As a wise person once said there is no substitute to hard work. 
The only way one can effectively test is by ensuring Sufficient Test Coverage and Testing Effort Automated or otherwise. 
The challenge could be lack of documentation, but the advantage could be close communication between team members thereby resulting in greater clarity of thought and understanding of the system. 

Each Time Code is changed Regression Testing is done. Test Coverage is ensured by having Automated Scripts and the right mix/combination of People executing the Test Cases. 
Exploratory Testing may also be encouraged. Exploratory Tests are not pre-designed or pre-defined. The Tests are designed and executed immediately. Similarly ad hoc testing may also be encouraged. Ad-hoc testing is done based on the tester’s experience and skills. 

While automated Test Cases will ensure that the Test Cases scripted are executed as defined, the team may not have enough time to design and script all the test cases.

Ensuring software test coverage:
To ensure that delivered product meets the end user’s requirements it is important that sufficient testing is done and all scenarios are tested. 

Sufficient Test Coverage in an Agile Development Scenario may be tricky but with close cooperation and the right team dynamics it may not be impossible. 

The objectives of the Project should be clear to the entire team. Many teams advocate Test Driven Development. At every stage the Software is tested if it meets the Requirements. Every Requirement is translated to a Test Case and Software is validated/ verified. While the Processes and Documentation are not stressed upon sufficient steps are taken to ensure that the software is delivered as per the User Expectations. This implies that each Software delivery should be tested thoroughly before it is released. 

The timelines being short requires that the person testing the software has sufficient knowledge about the system and its objectives

Page 2 of 4
1 2 3 4