Did you know that Thomas Edison was the first person to call a technological defect a ‘bug’ back in 1877? He was implying that an imaginary insect was the cause of all the trouble he was having while creating a new telephone design. Many years later, the first software bug was found - and this time, it was an actual bug! On September 9 of 1947, a team of computer scientists reported the first software bug in the form of a moth trapped in one of the computers at Harvard University. Fascinating, right? Somewhere along the line, people realized that these bugs needed to be dealt with, and so software testing has taken quite a journey over the years. Let’s take a look!
Code de-bugging line-for-line
Software testing is not hundreds of years old, but its history might go back further than you would think. The first software test team was formed in 1958 by Gerald M. Weinberg while working as a manager for Project Mercury, the first human spaceflight program in the United States. By 1967, the topic was starting to pick up and IBM published a white paper with the title "Evaluation of the Functional Testing of Control Programs". This was one of the first calls for a disciplined approach to software testing and probably stemmed from the frustration of spending hours debugging code by inspecting it line for line (if you are bored and up for a challenge, try line-for-line debugging and let us know how it goes - we're curious).
The start of manual testing
The NATO Science Committee was quick to follow in 1968 with a topic of discussion at the Software Engineering Conference: quality assurance for software products. The conference included a working paper with the title 'Checklist for planning software system production,' and here an important question was raised: 'Is the product tested to ensure that it is the most useful for the customer in addition to matching functional specifications?' (a very valid question that still holds true today!) This was a good example of manual testing in its primitive stages. Testing took place but not necessarily in a planned or sequential way.
In 1976, the focus shifted to reducing the cost of maintenance and fixes when Michael Fagan proposed the use of code inspections. In the same year, the December issue of IEEE Transactions included a paper by Barry Boehm that showed his cost-of-change curve. The curve displayed how the costs of changing software, especially fixing defects, rises exponentially as time goes by. Just a few years later in 1979, Glenford Myers published the book ‘The Art of Software Testing.’
Basic test documents and exploratory testing
And then it happened: in 1983, the first version of the IEEE 829 Standard for Software Test Documentation was published. It included documents intended for use across eight defined stages of software testing and at the time it was an incredibly exciting development. However, it wasn’t until 1998 that the first European certification for software testers became available. The British Information Systems Examination Board created the certification, and the first course was taught by Dorothy Graham and Mark Fewster. In the same year, exploratory testing was introduced in the Testing Computer Software Handbook (Second Edition).
Continuous Integration and scripted manual testing
In 2000, Martin Fowler wrote the first version of the paper Continuous Integration: a groundbreaking moment in software testing history. Fowler was already discussing topics such as self-testing code, automated build scripts, and the importance of automation in order to find integration errors as quickly as possible.
Context-driven testing, Saas, and Agile
2001 was also a big year for software testing: a book about experiences in context-driven testing by the name Lessons Learned in Software Testing was published. In the same year, the acronym SaaS (Software as a Service) was first used in the article Software as a Service: Strategic Backgrounder. Can you believe these common software terms have been in use for almost 20 years - and are still used widely today? It’s safe to say that software testing was already well established by this point.
The third wonderful thing from 2001 was the publication of the Agile Manifesto. We don’t need to tell you how popular the Agile software development and delivery approach is. From here, a community of devoted users grew that embraced Agile principles and continues to do so today.
In 2002, another buzzword in software testing was created when Kent Beck published his book Test Driven Development (TDD). It outlined the software development technique in which tests are written before the functionality is coded. 2003 saw the foundation of the Association for Software Testing, and by 2005, SoapUI was released to SourceForge as a tool for web service testing. 2007 introduced another software testing standard, ISO 29119, and 2009 saw the First Agile Testing Days conference and a strengthened testing community. In 2012, the first Let’s Test Conference was held, and in 2013 the Society for Software Testing was founded.
2016 saw perhaps the biggest development in software testing yet, although we might be a bit biased here: the foundation of Virtuoso! But we'll come back to that in a bit.
As the complexity of software has increased, so have the methodologies, tools, and practices of testing. Testers today have a bouquet of options to choose from when performing testing - the culmination of many years of software testing developments.
There’s data-driven testing, where applications can be tested with different sets of input data to make sure they work correctly with changing input values. There are TDD and BDD (behavior-driven development): TDD is where the development team writes the tests with a focus on the implementation of a feature, while BDD has automated specifications created by users or testers and focuses on system behaviors. Keyword-driven testing for manual or automated testing, automated test scripts, end-to-end testing to identify system dependencies, stress testing, codeless solutions, alpha and beta testing, integration tests, regression testing, reinterpreted Agile methods… Time fails us to talk about all of the many types of testing, methods, and practices that are available for use as part of the software testing process today.
And that brings us to software testing in the present. Today's modern world really relies on the internet and cloud technologies, which equates to higher complexity in software and along with it, an increased demand for software development tools - and of course, testing tools. Although manual testing in the cloud is still widespread, testers (and organizations as a whole) across the globe are realizing that test automation tools for web applications hold amazing potential:
Testing is here to stay, and test automation is the winner of the day. As companies adopt Continuous Integration and Continuous Delivery (CI/CD) as the golden standard, testing can hardly keep up. Testing is a moving target that has to respond continuously to advances in software delivery, and achieving success with CI/CD is increasingly dependent on automation through AI.
Ladies and gentlemen, that's where Virtuoso comes in!
Virtuoso harnesses the innovative power of AI to provide you with a test automation tool that delivers on speed, scale, and quality. Virtuoso’s quality-first, intelligent platform allows anyone to author tests that think like humans. It’s a test automation tool like no other that enables the automation of the most complex tests in the simplest way. Virtuoso is operating in the future - and it’s time for you to catch up!
Book a demo with one of our customer success specialists to see how you can join the fray and get the latest test automation tool to streamline your testing needs.