Being a QA professional is a challenging task and sometimes, pressured by deadlines, spontaneous errors, stress and pressure, QA engineers develop harmful habits that they inadvertently apply to the work process.

Today we will present you the top 3 bad habits for QA professionals, according to Simple Programmer.

Bad Habit #1: Assuming Strange Behavior is Right Behavior

Often when testing a new feature, QA professionals encounter a strange behavior. Sometimes it has to do with refreshing a page or navigating to a place they weren’t expecting. Or perhaps an unexpected button appears. And when QA engineers have a deadline, they miss these seemingly insignificant changes that actually have a significant impact on the final result and quality. Furthermore, the fact that these quirks didn’t impress you doesn’t mean that end users won’t notice them and may even quit using the app or product because of them.

Bad Habit #2. Getting caught up in the details

This is the opposite of bad habit #1. Sometimes QA engineers are so focused on finding every single thing that’s wrong with an application, no matter how minor, that they fall into “analysis paralysis” and halt their team’s progress.

Experts advise on focusing on actual usage scenarios. The QA engineer’s goal is to ensure that the software works effectively for users and is protected against malicious attacks. Searching for bugs for the sheer pleasure of searching is the wrong approach that hinders productivity.

Bad Habit #3. Writing automated tests

QA professionals who have become familiar with writing automated tests often begin to feel a particular interest and enjoyment in the automation process. A certain burst of energy arises as they tackle technical challenges and observe automated test execution. When a new feature needs to be tested, it is important to make time for it and also for QA professionals to look at it from the end-users – the customers. Test automation can lead to those situations where functionality cannot be adequately tested. At the same time, QA specialists may miss key functionality.

We all know that security and governance are two areas in which a lot of time and money are being invested, and developers are increasingly asked to take on a larger role in the development life cycle. This year’s list of companies to watch reflect those changes in the industry, as startups find gaps to fill and established companies pivot to areas of greater need. Here’s the list of companies to keep an eye on in 2022.

Mabl

WHAT THEY DO: Automated end-to-end testing

WHY WE’RE WATCHING: Mabl is a low-code, intelligent test automation platform. Agile teams use mabl’s SaaS platform for automated end-to-end testing that integrates directly into the entire development life cycle. Its low-code UI makes it easy to create, execute, and maintain software tests. The company’s native auto-heal capability evolves tests with your changing UI, and comprehensive test results help users quickly resolve bugs before they reach production.

APIsec

WHAT THEY DO:  API security

WHY WE’RE WATCHING: APIsec provides a fully automated API security testing platform, giving DevOps and Security teams continuous visibility and complete coverage for APIs. APIsec automates API testing, provides complete coverage of every endpoint and attack vector, and enables continuous visibility.

Spectral

WHAT THEY DO: Code security

WHY WE’RE WATCHING: Spectral’s platform helps developers ensure their code is secure by integrating with CI tools, by enabling their pre-commit tool to automate early issue detection, and by scanning during static builds with plugins for JAMStack, Webpack, Gatsby, Netlify and more.

Curiosity Software

WHAT THEY DO: Testing

WHY WE’RE WATCHING: With its mantra of “Don’t trap business logic in a testing tool,” Curiosity offers an open testing platform, and is creating a “traceability lab” that links technologies across the whole SDLC. If something changes in one place, the impact of this change should be identified across requirements, tests, data, and beyond.

Komodor

WHAT THEY DO: Kubernetes troubleshooting

WHY WE’RE WATCHING: After raising $25 million, the company is positioning its platform as the single source of truth for understanding Kubernetes applications, whereas extant observability solutions tend to take an ops-centric view of things.

Lightstep

WHAT THEY DO: DevOps observability

WHY WE’RE WATCHING: With a new beginning under the ServiceNow umbrella (it acquired Lightstep earlier this year), the company’s ex-Googlers built Change Intelligence software to enable any developer, operator or SRE to understand changes in their services’ health and what caused those changes. This, the company says, will deliver on the promise of AIOps — to automate the process of investigation changes within complex systems.

Cribl

WHAT THEY DO: Observability data collection and routing

WHY WE’RE WATCHING: Cribl’s LogStream delivers a flexible solution to enable customers to choose what data they want to keep, in what format, in which data store – and the assurance that they can also choose to delay any or all of those decisions with a complete copy in very low-cost storage.

Unqork

WHAT THEY DO: No-code platform

WHY WE’RE WATCHING: Enterprise-grade no-code application platforms such as Unqork have radically expanded the scope and capabilities of no-code. These platforms empower large organizations to rapidly develop and effectively manage sophisticated, scalable solutions without writing a single line of code. Unqork late last year raised $207 million in funding, bringing the company’s valuation to $2 billion.

Push Technology

WHAT THEY DO: Intelligent event data platform

WHY WE’RE WATCHING: Winners of 12 industry awards in 12 months, the company’s 6.7 release of its Diffusion platform raises the bar for messaging and event brokers.

Rezilion

WHAT THEY DO: Autonomous DevSecOps

WHY WE’RE WATCHING: With $30 million in September Series A funding in its coffers, Rezilion will build out its Validate vulnerability platform based on the company’s Trust in Motion philosophy, and the company expects to add new solutions that help autonomously mitigate risk, patch detected vulnerabilities and dynamically manage attack surfaces.

Rookout

WHAT THEY DO: Live debugging

WHY WE’RE WATCHING: The company this year launched its X-Ray Vision feature for debugging third-party code and of Agile Flame Graphs to profile distributed applications in production, its integration with Open Tracing, and its introduction of Live Logger. And, CTO Liran Haimovitch’s podcast “The Production-First Mindset” is wildly popular.

Spin Technology

WHAT THEY DO: Application security and ransomware protection

WHY WE’RE WATCHING: Spin Technology has been highlighted as a Top 5 Online SaaS Backup Solutions for the Microsoft Office 365 ecosystem by the Data Center Infrastructure Group. Spin uses Artificial Intelligence to improve threat intelligence, prevention, prediction, and protection.  It can also enable faster ransomware attack detection and response, as well as automate backup and recovery while reducing the need for human cybersecurity experts and leading to time and effort savings for enterprise organizations.

Swimm

WHAT THEY DO: Code documentation

WHY WE’RE WATCHING: Onboarding, outdated documentation and project switching all slow developers down. By syncing documentation with code, Swimm enables developers to get up to speed more quickly on the projects they’re assigned to.

Organisations are optimizing and updating how they build and deploy software, trying to create a seamless continuous integration/continuous delivery (CI/CD) structure. Leveraging tech like AI, machine learning and automation is certainly helping to make this process as efficient as possible. But optimizing speed must be carefully balanced with maintaining — and improving — quality.

Where and how does testing fit into accelerating software development pipelines?

Shift-left testing has gone from a new concept to a recognized buzzword, to reality for many digitally evolving organizations. Instead of running QA after code is developed, this testing is now taking place earlier and earlier in the software development life cycle (SDLC). This is done in part with the help of the developers who are actually responsible for building the code.

Testing earlier in the SDLC has the potential to slow down development, which runs against the priority of developers building and shipping code as quickly as they can. But this slowdown has been worth it for many brands, leading to a reduced number of bugs released to end-users and cost savings involved for fixing bugs later in development or once deployed. Essentially, many organizations are on board with compromising a bit of speed for an overall better user experience.

Collaboration and real-time reviews

At the core of shift-left testing is the notion that every member of a team is working together in the name of improved quality, but that shouldn’t mean that release velocity is sacrificed to a great degree in the process.

Pair programming — where two developers work together to create code— is a great example of how important collaboration and real-time reviews can be used to improve code quality at the outset. With pair programming, one developer writes the code and one review it in real-time so as to make the process as efficient and the code as clean as possible early on.

This real-time review process goes against the grain of traditional automation but is nonetheless an important tool in shifting testing and quality processes left. Real-time review and sprint testing methods like pair programming are useful steps to take while test automation matures.

They also offer benefits that test automation cannot because only human testers can provide the dynamic and unbiased validation and verification of software that machines are simply not yet capable of providing. Automation can tell you if the intended result was achieved, for example, but cannot tell you if the experience was intuitive, easy to use or inclusive of all potential end-users.

The human element

Automated software testing does all it needs to do to tell developers and QA teams if the software is working or not working. But in the wild, where that software is used and sees its value recognized, it isn’t so simple. When software is only tested in a lab environment, it doesn’t encounter all these other variables. Automated testing simply does not cover the diversity involved in real user experience by the billions of humans accessing applications every day, around the world.

For this reason, organizations committed to providing the highest quality of user experience and accessibility for their users and customers will keep humans involved in software testing.

Offsetting with automated testing

Developers are an invaluable resource to organizations. IT leaders naturally want the majority of developer time to be spent focused on developing applications. Yes, some organizations with less mature QA setups do need to spend some time on quality and testing, but ideally, as little time as possible should be spent away from their main priority of developing exceptional software.

Shifting testing left has pulled developers further into the mix of testing responsibility, however. This can reduce developer productivity, and as we know, reduce release cycle speed. But automated testing capabilities can actively offset these areas of compromise.

All in the name of user experience

The benefits of automated testing practices can’t be understated. Automated tools pick up on issues that humans sometimes miss, and they do it in a way that is agile and efficient. But as long as the end product is being used by people, it is people who also need to be involved in some aspect of the testing.

Adding this human element into the mix alongside the efficiency of automated testing is the best way to make sure an application is ready and accessible for any prospective user.

Stakeholders rely on their enterprise applications to work quickly and efficiently, with absolutely no downtime. Anything short of that could result in a slew of business performance issues and ultimately lost revenue. Take the recent incident in which CDN provider Fastly failed to detect a software bug, resulting in massive global outages for government agencies, news outlets, and other vital institutions.

Effective and thorough testing is a critical mission for software development across categories including business software, consumer applications and IoT solutions. But as continuous deployment demands ramp up and companies face an ongoing tech talent shortage, inefficient software testing has become a serious pain point for enterprise developers, and they’ve needed to rely on new technologies to improve the process.

The Benefits of Test Automation

The key to quickly implementing continuous software development and deployment is robust automation. Converting manual tests to automated tests not only reduces the amount of time it takes to test but can also reduce the chance of human error and allows minimal defects to escape into production. Just by converting manual testing to automated testing, companies can reduce three to four days of manual testing time to one, eight-hour overnight session. Therefore, testing does not even have to be completed during peak usage hours.

Automation solutions also allow organizations to test more per cycle in less time by running tests across distributed functional testing infrastructures and in parallel with cross-browser and cross-device mobile testing.

Challenges in Test Automation

Despite all the benefits of automated software testing, many companies are still facing challenges that prevent them from reaping the full benefits of automation. One of those key challenges is managing the complexities of today’s software testing environment, with an increasing pace of releases and proliferation of platforms on which applications need to run. There are many more requirements for automated testing with so many conflicting specifications and platform-specific features – meaning there are just as many potential pitfalls.

Software releases and application upgrades are also happening at a much quicker pace in recent years. The faster rollout of software releases, while necessary, can break test automation scripts due to fragile, properties-based object identification, or even worse, bitmap-based identification. Due to the varying properties across platforms, tests must be properly replicated and administered on each platform – which can take immense time and effort.

Therefore, robust, and effective test automation also requires an elevated skill set, especially in today’s complex, multi-ecosystem application environment. Record-and-playback testing, a tool that records a tester’s interactions and executes them many times over, is no longer sufficient.

To meet the high demands of software testing, automation must be coupled with Artificial Intelligence (AI). Truly robust automation must be resilient, and not rely on product code completion to be created. It must be well-integrated into an organization’s product pipelines, adequately data-driven, and fully aligned with the business logic.

Organizations can allow quality assurance teams to begin testing earlier – even in the mock-up phase – through the use of AI-enabled capabilities for the creation of a single script that will automatically execute on multiple platforms, devices and browsers. With AI alone, companies can experience major increases in test design speed as well as significant decreases in maintenance costs.

Furthermore, with the proliferation of low-code/no-code solutions, AI-infused test automation is even more critical for ensuring product quality. Solutions that infuse AI object recognition can enable test automation to be created from mockups, facilitating test automation in the pipeline even before product code has been generated or configured. These systems can provide immediate feedback once products are initially released into their first environments, providing for more resilient, successful software releases.

To remain competitive, all businesses need to be as productive and efficient as possible, and the key to that lies in properly tested, functioning, performant enterprise applications. Cumbersome, manual testing is no longer sufficient, and enterprises that continue to rely on it will be caught flat-footed and getting outperformed and out-innovated. Investing in automation and AI-powered development tools will give enterprises the edge they need to stay ahead of the competition.

In the new process, an Angular team member will review a ticket manually and identify it as either a feature request or an issue. After that, the Angular team will verify whether feature requests align with existing projects on the roadmap and see whether to prioritize them or not.

If a feature request collects enough votes within the 60-day window, the bot will automatically mark it down for consideration. Angular is also considering requests with 20 or more votes and iterating if a different number of votes will get better results.

The team will then manually review it again and see if it matches up with Angular’s future vision, and if it does, it will move it to its prioritization queue. If it doesn’t, Angular will close it with an explanation and determine whether the feature is a better fit for an external module that the community can distribute as part of the platform. Minko Gechev wrote in a blog post:

“Although tempting, it’s unrealistic and unhealthy to incorporate all the requests for features. If Angular takes this path, there are risks for the framework becoming unlearnable and unmaintainable. But clearly, such feedback is precious — there are hundreds of bright ideas coming from the community that align well with Angular’s future vision and are worth exploring.

He also commented that by actively closing more feature requests, they set better expectations and make it clear that they are trying to focus on the work that impacts the largest number of developers.

Here are the top 5 problems QA Teams face when it comes to automated testing:

1. Unrealistic expectations of automated testing
2. Using the wrong tools
3. Automate useless tests and neglecting important test cases
4. Choosing the wrong testing time
5. Lack of proper testing

Unrealistic Expectations for Automated Testing

It’s no secret that test automation has many benefits. Most importantly, it helps the QA team save time, efforts and resources. Doesn’t this mean that automating as many processes will improve efficiency accordingly? Not quite. Unrealistic expectations people have for test automation can mess up the entire testing process. You risk having too many test cases and QAs not doing their job.

Manual testing matters. You should never ignore manual testing. In some instances, testing an application manually is a way better solution than writing automated test scripts.

Manual testing is suited for:

• UI and usability testing
• Quick compatibility testing on e.g. one device or two
• One-time testing
• Ad-hoc testing
• Localization (L10N) and internationalization (I18N) testing.

Non-automated aspects of testing remain. Automated test scripts need people who support them. So, even if you insist on automating as much of your testing efforts as possible, you’ll still have non-automated pieces of work left.

Solution: A clear testing strategy.

Using the Wrong Tools

Test automation won’t work effectively if you don’t use the right tools. With so many different testing solutions on the market, it’s easy to get deluded. Choosing the wrong tool may result in scalability problems on top of never meeting your initial test automation goals.

Solution: Choose your tools wisely.

Automating Useless Tests and Neglecting the Important Test Cases

Sadly, when it comes to automation, QA teams often start by randomly automating test cases. This leaves them with low test coverage and too many useless tests. Moreover, with this approach, you risk not covering the important scenarios and having gaps in software quality.

Solution: Find out what’s worth automating.

Before writing test scripts, researching is mandatory. Discover what’s worth automating and then you can start implementing automation where it’ll have the most impact. Select a proper testing approach, mind test metrics and reports.

Choosing the Wrong Testing Time

Today, many teams still see testing as something that happens after development. Only when the whole build is ready, QAs start doing their job. This outdated approach can’t guarantee the high quality of software. It doesn’t allow QAs to test all the layers properly and there’s usually not much time left for testing.

Solution: Run automated tests in parallel with the development process.

Testing shouldn’t take place only in the final stages. If you want test automation to be effective, start running tests since the early stages of the development and continue to do so through the software development life cycle. Testing is a vital part of the continuous delivery pipeline: without test automation, there’s no successful CI/CD implementation.

Lack of Proper Testing

Among the test automation problems, this is one is the trickiest. The lack of proper testing occurs when QAs rely on automation too much and focus on tests passing rather than discovering bugs. The thing is, automation gives a false sense of security. With automated tests running repeatedly, it’s tempting to reduce human intervention and responsibility for the results. Such an approach has devastating outcomes like poor test design, inconsistent and ineffective testing.

Solution: QA team training.

Before implementing automation, train your team properly. Make sure they know their roles in the process and have enough technical skills to support the tests. Also, enforce test automation with exploratory testing to achieve more precise results.

The is about the continuing problem that developers face around testing the past few years, with a majority of respondents saying delays due to code testing and review process was a frequent source of delay in the development process.

One specific piece of feedback from a customer noted that “testing delays everything.” Another complaint was that their software delivery teams passed testing responsibilities to their quality assurance employees in lieu of writing end-to-end testing suites, something they said has led to “very long” bottlenecks when shipping code to production. Other complaints highlighted how their employees do not like reviewing code and find it to be “a chore.”

It is perhaps unsurprising that automation is being steadily incorporated into more of the software development process. However, there are complications, with developers expressing frustration about the technical limitations and lack of practical automation options for parts of the code testing process.

“The strongest light at the end of the testing tunnel may be found in the use of artificial intelligence/machine learning,” the report states, noting that adoption of such tools has more than doubled over the past year and a substantial number of their customers say it is the most important skill they could learn for their future careers.

The sentiments point to growing acceptance within the developer community that security, like software development, is an iterative and continuous process. While “DevSecOps” has been around for decades, it’s clear that many organizations have yet to integrate the concept in part or in whole. TJ Jermoluk, CEO of Beyond Identity, who works to build passwordless identity and authentication services into the software updating process noted:

“The nature of a zero-trust system is that security is continuous and it’s checked all the time. You have to move from being bound to checking security at the perimeter of things to checking it at everything…at every single point where any form of transaction is done, whether its access to a database or an application or checking in source code.”

One of the biggest changes from previous years is around the adoption of Kubernetes, the open-source platform for automating cloud-based containers, workloads and services that can also be used to conduct end-to-end code testing and review. Other tools like static and dynamic attack surface testing saw big jumps in use as well.

The survey was conducted on 4,294 GitLab customers. While it drew from multiple industries, disciplines and regions, the most common respondent was male (81%), a software developer or engineer (41%) who was located in Asia (50%).

Facebook announced its support for the Rust Foundation and added that it is committed to sustaining and growing the Rust open-source ecosystem and community.

According to Facebook, it currently has multiple teams throughout the company writing Rust code and even possesses a dedicated Rust team that is primarily responsible for the growth of Rust development inside the company as well as contributing to open source. Joel Marcey, the open-source ecosystem lead at Facebook, and now board director at the Rust Foundation commented:

“We are joining the Rust Foundation to help contribute to, improve and grow this language that has become so valuable to us and developers around the world. We look forward to participating with the other foundation members and the Rust community to make Rust a mainstream language of choice for systems programming and beyond.”

Updated Google Play guidance

Google is pre-announcing a change in its policy for app metadata and introduced new guidelines on store listing preview assets. The company also introduced the policy change to display the app title, icon and developer name on the store listing page.

mabl announces new native Jira integration

Now teams will be able to integrate automated testing and issue tracking into their DevOps pipeline with the new Jira integration in support of Open DevOps from Atlassian. Izzy Azeri, co-founder at mabl commented:

“There’s no question that the flexibility, security, and scalability of the cloud enables a wide variety of new capabilities that supercharge agile software development. Jira is one of the most popular tools among quality engineers, and this new native Jira integration ensures that high-velocity teams can continue to deliver high quality applications as they move workflows with Jira to the cloud.”

The enhanced integration provides the ability to easily collaborate on finding and fixing software bugs, improving visibility into issues, quickly triaging reported issues and re-running existing tests.

GCC 11.1 released

This GCC 11.1 release switches the default debugging format to DWARF 5 [1] on most targets and switches the default C++ language version to -std=gnu++17.

The release also improves C++20 language support, both on the compiler and library sides, adds experimental C++23 support, some C2X enhancements and various optimization enhancements.