Introduction to automated quality assurance
•Download as PPT, PDF•
0 likes•2,887 views
This document discusses automated quality assurance tools and how they can be used to complement manual quality assurance techniques. It provides an overview of common automated QA tools like Checkstyle, PMD and FindBugs, describing their strengths and weaknesses. Checkstyle performs source code analysis to check for coding standard compliance and best practices. PMD also analyzes source code but focuses more on design-level issues. FindBugs analyzes bytecodes to find bugs, using data flow analysis. The goal in this class is to teach students to apply the right mix of automated and manual QA to build high quality systems efficiently.
Report
Share
Report
Share
![Objectives ,[object Object],[object Object],[object Object]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
findbugs Bernhard Merkle
The document discusses different levels of static analysis from micro to macro to architecture levels. It then provides an overview of static analysis, tools for static analysis including FindBugs, examples of bugs FindBugs can detect, bug categories and patterns, analysis techniques used by FindBugs, and how to develop bug detectors for FindBugs.
Finding bugs that matter with Findbugs
FindBugs is a static analysis tool that looks for bugs in Java code based on predefined bug patterns. It analyzes code without executing it and flags issues related to correctness, bad practices, performance, security, and concurrency. Some common bug patterns it finds include null pointer dereferences, ignored return values from methods, and potential infinite recursive loops. The tool is useful for finding bugs early before testing or deployment. Google and other companies use FindBugs to analyze their Java codebases and have found and fixed hundreds of issues through this process.
Back-2-Basics: .NET Coding Standards For The Real World (2011)
Revamped for 2011 (90% new material), this session will guide any level of programmer to greater productivity by providing the information needed to write consistent, maintainable code. Learn about project setup, assembly layout, code style, defensive programming and much, much more. Code tips are included to help you write better, error free applications. Lots of code examples in C# and VB.NET. This session is based off my latest book, David McCarter's .NET Coding Standards.
Working With Legacy Code
The document discusses strategies for working with legacy code, which is code inherited from previous developers or older versions that often lacks tests and good documentation. It defines legacy code and outlines challenges like poor structure, dependencies, and lack of tests. It then provides approaches for modifying legacy code like identifying what to change and test, breaking dependencies, writing tests, and refactoring code in small, tested increments. Specific tactics are presented like using seams, sprouting methods, and interfaces to break dependencies and allow testing legacy code. The importance of understanding the system and increasing test coverage before making changes is emphasized.
Rock Your Code with Code Contracts
This document contains information about conference DVDs and an introduction to code contracts in .NET. It summarizes that code contracts are a way to define preconditions, postconditions, and class invariants for software components to specify their interfaces and ensure correctness. It provides examples of using the System.Diagnostics.Contracts namespace in C# to add preconditions and postconditions to methods. Contracting types can make them more robust by validating arguments and object states.
Exception handler
The finally clause in Java is used to specify code that is always executed regardless of whether an exception is thrown or caught in the try block. Clean-up code, like closing an open file or database connection, is commonly placed in a finally block to ensure it runs even if an exception occurs.
Working Effectively with Legacy Code
Book review: Working Effectively with Legacy Code, by Michael C. Feathers
Agenda
- The mechanics of change
- Changing software
- Dependency breaking techniques
This session is for developers who need to work on code projects that where written without good unit-testing.
Mining Fix Patterns for FindBugs Violations
Several static analysis tools, such as Splint or FindBugs, have been proposed to the software development community to help detect security vulnerabilities or bad programming practices. However, the adoption of these tools is hindered by their high false positive rates. If the false positive rate is too high, developers may get acclimated to violation reports from these tools, causing concrete and severe bugs being overlooked. Fortunately, some violations are actually addressed and resolved by developers. We claim that those violations that are recurrently fixed are likely to be true positives, and an automated approach can learn to repair similar unseen violations. However, there is lack of a systematic way to investigate the distributions on existing violations and fixed ones in the wild, that can provide insights into prioritizing violations for developers, and an effective way to mine code and fix patterns which can help developers easily understand the reasons of leading violations and how to fix them.
In this paper, we first collect and track a large number of fixed and unfixed violations across revisions of software. The empirical analyses reveal that there are discrepancies in the distributions of violations that are detected and those that are fixed, in terms of occurrences, spread and categories, which can provide insights into prioritizing violations. To automatically identify patterns in violations and their fixes, we propose an approach that utilizes convolutional neural networks to learn features and clustering to regroup similar instances. We then evaluate the usefulness of the identified fix patterns by applying them to unfixed violations. The results show that developers will accept and merge a majority (69/116) of fixes generated from the inferred fix patterns. It is also noteworthy that the yielded patterns are applicable to four real bugs in the Defects4J major benchmark for software testing and automated repair.
Recommended
findbugs Bernhard Merkle
The document discusses different levels of static analysis from micro to macro to architecture levels. It then provides an overview of static analysis, tools for static analysis including FindBugs, examples of bugs FindBugs can detect, bug categories and patterns, analysis techniques used by FindBugs, and how to develop bug detectors for FindBugs.
Finding bugs that matter with Findbugs
FindBugs is a static analysis tool that looks for bugs in Java code based on predefined bug patterns. It analyzes code without executing it and flags issues related to correctness, bad practices, performance, security, and concurrency. Some common bug patterns it finds include null pointer dereferences, ignored return values from methods, and potential infinite recursive loops. The tool is useful for finding bugs early before testing or deployment. Google and other companies use FindBugs to analyze their Java codebases and have found and fixed hundreds of issues through this process.
Back-2-Basics: .NET Coding Standards For The Real World (2011)
Revamped for 2011 (90% new material), this session will guide any level of programmer to greater productivity by providing the information needed to write consistent, maintainable code. Learn about project setup, assembly layout, code style, defensive programming and much, much more. Code tips are included to help you write better, error free applications. Lots of code examples in C# and VB.NET. This session is based off my latest book, David McCarter's .NET Coding Standards.
Working With Legacy Code
The document discusses strategies for working with legacy code, which is code inherited from previous developers or older versions that often lacks tests and good documentation. It defines legacy code and outlines challenges like poor structure, dependencies, and lack of tests. It then provides approaches for modifying legacy code like identifying what to change and test, breaking dependencies, writing tests, and refactoring code in small, tested increments. Specific tactics are presented like using seams, sprouting methods, and interfaces to break dependencies and allow testing legacy code. The importance of understanding the system and increasing test coverage before making changes is emphasized.
Rock Your Code with Code Contracts
This document contains information about conference DVDs and an introduction to code contracts in .NET. It summarizes that code contracts are a way to define preconditions, postconditions, and class invariants for software components to specify their interfaces and ensure correctness. It provides examples of using the System.Diagnostics.Contracts namespace in C# to add preconditions and postconditions to methods. Contracting types can make them more robust by validating arguments and object states.
Exception handler
The finally clause in Java is used to specify code that is always executed regardless of whether an exception is thrown or caught in the try block. Clean-up code, like closing an open file or database connection, is commonly placed in a finally block to ensure it runs even if an exception occurs.
Working Effectively with Legacy Code
Book review: Working Effectively with Legacy Code, by Michael C. Feathers
Agenda
- The mechanics of change
- Changing software
- Dependency breaking techniques
This session is for developers who need to work on code projects that where written without good unit-testing.
Mining Fix Patterns for FindBugs Violations
Several static analysis tools, such as Splint or FindBugs, have been proposed to the software development community to help detect security vulnerabilities or bad programming practices. However, the adoption of these tools is hindered by their high false positive rates. If the false positive rate is too high, developers may get acclimated to violation reports from these tools, causing concrete and severe bugs being overlooked. Fortunately, some violations are actually addressed and resolved by developers. We claim that those violations that are recurrently fixed are likely to be true positives, and an automated approach can learn to repair similar unseen violations. However, there is lack of a systematic way to investigate the distributions on existing violations and fixed ones in the wild, that can provide insights into prioritizing violations for developers, and an effective way to mine code and fix patterns which can help developers easily understand the reasons of leading violations and how to fix them.
In this paper, we first collect and track a large number of fixed and unfixed violations across revisions of software. The empirical analyses reveal that there are discrepancies in the distributions of violations that are detected and those that are fixed, in terms of occurrences, spread and categories, which can provide insights into prioritizing violations. To automatically identify patterns in violations and their fixes, we propose an approach that utilizes convolutional neural networks to learn features and clustering to regroup similar instances. We then evaluate the usefulness of the identified fix patterns by applying them to unfixed violations. The results show that developers will accept and merge a majority (69/116) of fixes generated from the inferred fix patterns. It is also noteworthy that the yielded patterns are applicable to four real bugs in the Defects4J major benchmark for software testing and automated repair.
Control statements
The document discusses control structures in Java, including selection (if/else statements), repetition (loops like while and for), and branching (break and continue). It provides examples of if/else, switch, while, do-while, for, and break/continue statements. The key structures allow sequencing, selecting between alternatives, and repeating actions in a program.
Mastering Mock Objects - Advanced Unit Testing for Java
A high-level description of mock testing techniques and their implementation for the Java programming language.
This presentation specifically focus on the JMockit and JMock frameworks.
Exception Handling - Part 1
In this core java training session, you will learn Exception Handling. Topics covered in this session are:
• Exception Handling
• Exception Class hierarchy
• Types of Exception
• Keywords for Exception Handling
For more information about this course visit on this link: https://www.mindsmapped.com/courses/software-development/learn-java-fundamentals-hands-on-training-on-core-java-concepts/
Using PHPStan with Laravel App
PHPStan is a static code analysis tool that find a new category of bugs that weren't discovered by other tools like SonarQube. In these slides we discuss:
- What is code analysis and its types.
- What do static code analysis tools focus on.
- PHPStan Levels.
- PHPStan setup and configuration.
- Adding PHPStan to GitLab CI/CD pipeline.
Java - Generic programming
This presentation introduces some advanced concepts of generics in Java. These slides introduce the following concepts:
- Generic classes and methods
- Type variable bounds
- Type erasure process
- Generics and inheritance
- Wildcard types
The presentation is took from the Java course I run in the bachelor-level informatics curriculum at the University of Padova.
Working Effectively with Legacy Code: Lessons in Practice
Code rots. Even the best designs can fall into chaos, weighed down by changing requirements, hard-coded dependencies, and overzealous cut-and-paste. Eventually, the mess has to be cleaned up, but there's just one problem: There are no tests. No one knows exactly what the code is supposed to do. You will think you're fixing it, but instead you'll break it--and you won't even know.
A few months ago, I inherited just such a mess. In this talk, I'll explore Michael Feathers' classic Working Effectively with Legacy Code, a comprehensive and accessible guide to refactoring the even the ugliest, most neglected code bases. Using real examples, I'll explain how Feathers' techniques are working for me.
Generics and collections in Java
Generics and Collections
The document discusses generics and collections in Java. It defines generics as a style of programming that allows algorithms to operate on objects of different types while providing compile-time type safety. The Java collections framework supports generics to specify the type of objects stored in a collection. Common collection classes like ArrayList, LinkedList, and HashMap are discussed along with their key characteristics.
An introduction to mutation testing
The document provides an introduction and overview of mutation testing. It explains that mutation testing involves deliberately introducing small errors or mutations into code to test if tests can detect those errors. It discusses how mutations are made by changing operators or statements, running tests on the mutated code, and analyzing whether tests fail as they should to kill the mutations. The document uses an example of mutating a subtraction method to demonstrate how mutation testing works and what it reveals about test coverage and adequacy.
Exception Handling
This document discusses exception handling in C++. It covers key concepts like try/catch blocks, throwing exceptions, stack unwinding, and the standard exception hierarchy. The main points are:
1) try blocks enclose code that might throw exceptions, while catch blocks handle specific exception types.
2) Functions throw exceptions using throw, which are matched to catch blocks. Uncaught exceptions cause stack unwinding.
3) The standard exception class is the base for user-defined exception classes. Exceptions are typically caught by reference.
Beyond PITS, Functional Principles for Software Architecture
This talk introduces the core concepts of functional programming, why it matters now and how these principles are adopted for programming.
Beyond the usage of the functional principles for programming in the small, their applicability to the design of components and further on to the architecture of software systems is also explored along with relevant examples.
The code samples used in the talk are in Haskell / Java 8 / Scala / Elm and JavaScript, but deep understanding of any of these languages are not a pre-requisite.
Unit Testing in Java
Unit testing involves writing code to test individual units or components of an application to ensure they operate as intended. A unit test targets a specific function or class and ensures the code works correctly. A test suite is a collection of test cases that test a module. Frameworks like JUnit simplify the unit testing process and allow for test automation. JUnit tests are created in the same project structure with a "Test" suffix and use annotations to define test cases and suites. Tests can then be run and results analyzed to measure code coverage.
Java chapter 2
This document provides an overview of basic Java programming concepts including:
- Variable types such as primitives (int, double, char etc.), identifiers, and constants.
- Declaring and assigning values to variables including literals, compatible data types, and type casting.
- Operators for arithmetic, assignment, increment/decrement, and precedence. Errors from division by zero or incompatible types are discussed.
- Strings, escape sequences, and concatenation.
A Closer Look at Real-World Patches
Bug fixing is a time-consuming and tedious task. To reduce the manual efforts in bug fixing, researchers have pre- sented automated approaches to software repair. Unfortunately, recent studies have shown that the state-of-the-art techniques in automated repair tend to generate patches only for a small number of bugs even with quality issues (e.g., incorrect behavior and nonsensical changes). To improve automated program repair (APR) techniques, the community should deepen its knowledge on repair actions from real-world patches since most of the techniques rely on patches written by human developers. Previous investigations on real-world patches are limited to statement level that is not sufficiently fine-grained to build this knowledge. In this work, we contribute to building this knowledge via a systematic and fine-grained study of 16,450 bug fix commits from seven Java open-source projects. We find that there are opportunities for APR techniques to improve their effectiveness by looking at code elements that have not yet been investigated. We also discuss nine insights into tuning automated repair tools. For example, a small number of statement and expression types are recurrently impacted by real-world patches, and expression-level granularity could reduce search space of finding fix ingredients, where previous studies never explored.
JMockit
This document provides an overview of JMockit, a mocking framework for unit testing Java code. It discusses how to install JMockit, use annotations like @Mocked and @Injectable to mock classes and instances, set up expectations to define mocked method return values, partially mock classes by mocking specific methods, mock constructors, and verify mocked method calls were made using verifications. The document also explains how to use JMockit's code coverage reporting and addresses common scenarios for when to use expectations, mockups, constructor mocking, and verifications.
"Formal Verification in Java" by Shura Iline, Vladimir Ivanov @ JEEConf 2013,...
This document discusses formal verification and testing methods for software. It defines formal verification as mathematically proving software correctness against a specification, while testing involves running software with different inputs to check for errors. The document outlines some key differences: formal verification provides a lower bound on quality by guaranteeing absence of certain failures, while testing only provides an upper bound. It also discusses techniques like deductive verification using theorem proving. Later sections cover topics like type systems, annotations, and pluggable type checking tools like the Checker Framework.
JMockit Framework Overview
JMockit is a Java mocking framework that provides tools for isolating code dependencies during unit testing. It uses bytecode instrumentation to remap classes at runtime, allowing final classes and static methods to be mocked. Expectations define mock object behavior, and verifications ensure mocks are used as expected. JMockit provides a more powerful and flexible mocking approach than alternatives like Mockito through its instrumentation and expectations/verifications APIs.
Exception handling in c++ by manoj vasava
Exception handling in C++ provides built-in features to detect and handle runtime errors such as division by zero or accessing arrays out of bounds. Exceptions are unusual conditions that may occur during program execution and exception handling provides a type-safe way to cope with unpredictable problems at runtime rather than terminating the program. Exception handling is needed for object-oriented and distributed programs because traditional error handling solutions are not always appropriate.
Exception handling in c programming
The document outlines an end semester presentation by Group C on the topic of algorithms and computing labs. It includes the contents of the presentation which cover errors and exception handling basics, examples of exception occurrence and handling methods, and three example programs of increasing difficulty. It lists the group members and how presentation tasks were divided among them. It also includes details on grading criteria and a question/answer session.
Write readable tests
The presentation describes the properties of a good unit test. The code examples are written in java, but should make sense in each object oriented programming language.
Looking for Bugs in MonoDevelop
An important event has taken place in the PVS-Studio analyzer's life: support of C#-code analysis was added in the latest version. As one of its developers, I couldn't but try it on some project. Reading about scanning small and little-known projects is not much interesting of course, so it had to be something popular, and I picked MonoDevelop.
Ensuring code quality
This document discusses various tools and procedures for ensuring high code quality in Java development, including:
- Enforcing coding standards through code reviews and unit testing as part of the software development lifecycle.
- Measuring software quality through metrics like ease of testing and number of defects.
- Using static code analysis tools like FindBugs to identify issues and ensure compliance with best practices.
- Monitoring runtime performance with tools like JConsole and VisualVM.
Quality assurance of large c++ projects
This document discusses quality assurance techniques for large C++ projects. It describes the differences between quality assurance and quality control, with QA focusing on preventing defects during development, while QC finds defects in finished products. A variety of techniques are listed and their estimated effectiveness rates at finding defects. The document advocates using source control, build tools, coding standards, code reviews, unit testing, static analysis, code coverage, runtime verification tools, and continuous integration to improve quality assurance.
More Related Content
What's hot
Control statements
The document discusses control structures in Java, including selection (if/else statements), repetition (loops like while and for), and branching (break and continue). It provides examples of if/else, switch, while, do-while, for, and break/continue statements. The key structures allow sequencing, selecting between alternatives, and repeating actions in a program.
Mastering Mock Objects - Advanced Unit Testing for Java
A high-level description of mock testing techniques and their implementation for the Java programming language.
This presentation specifically focus on the JMockit and JMock frameworks.
Exception Handling - Part 1
In this core java training session, you will learn Exception Handling. Topics covered in this session are:
• Exception Handling
• Exception Class hierarchy
• Types of Exception
• Keywords for Exception Handling
For more information about this course visit on this link: https://www.mindsmapped.com/courses/software-development/learn-java-fundamentals-hands-on-training-on-core-java-concepts/
Using PHPStan with Laravel App
PHPStan is a static code analysis tool that find a new category of bugs that weren't discovered by other tools like SonarQube. In these slides we discuss:
- What is code analysis and its types.
- What do static code analysis tools focus on.
- PHPStan Levels.
- PHPStan setup and configuration.
- Adding PHPStan to GitLab CI/CD pipeline.
Java - Generic programming
This presentation introduces some advanced concepts of generics in Java. These slides introduce the following concepts:
- Generic classes and methods
- Type variable bounds
- Type erasure process
- Generics and inheritance
- Wildcard types
The presentation is took from the Java course I run in the bachelor-level informatics curriculum at the University of Padova.
Working Effectively with Legacy Code: Lessons in Practice
Code rots. Even the best designs can fall into chaos, weighed down by changing requirements, hard-coded dependencies, and overzealous cut-and-paste. Eventually, the mess has to be cleaned up, but there's just one problem: There are no tests. No one knows exactly what the code is supposed to do. You will think you're fixing it, but instead you'll break it--and you won't even know.
A few months ago, I inherited just such a mess. In this talk, I'll explore Michael Feathers' classic Working Effectively with Legacy Code, a comprehensive and accessible guide to refactoring the even the ugliest, most neglected code bases. Using real examples, I'll explain how Feathers' techniques are working for me.
Generics and collections in Java
Generics and Collections
The document discusses generics and collections in Java. It defines generics as a style of programming that allows algorithms to operate on objects of different types while providing compile-time type safety. The Java collections framework supports generics to specify the type of objects stored in a collection. Common collection classes like ArrayList, LinkedList, and HashMap are discussed along with their key characteristics.
An introduction to mutation testing
The document provides an introduction and overview of mutation testing. It explains that mutation testing involves deliberately introducing small errors or mutations into code to test if tests can detect those errors. It discusses how mutations are made by changing operators or statements, running tests on the mutated code, and analyzing whether tests fail as they should to kill the mutations. The document uses an example of mutating a subtraction method to demonstrate how mutation testing works and what it reveals about test coverage and adequacy.
Exception Handling
This document discusses exception handling in C++. It covers key concepts like try/catch blocks, throwing exceptions, stack unwinding, and the standard exception hierarchy. The main points are:
1) try blocks enclose code that might throw exceptions, while catch blocks handle specific exception types.
2) Functions throw exceptions using throw, which are matched to catch blocks. Uncaught exceptions cause stack unwinding.
3) The standard exception class is the base for user-defined exception classes. Exceptions are typically caught by reference.
Beyond PITS, Functional Principles for Software Architecture
This talk introduces the core concepts of functional programming, why it matters now and how these principles are adopted for programming.
Beyond the usage of the functional principles for programming in the small, their applicability to the design of components and further on to the architecture of software systems is also explored along with relevant examples.
The code samples used in the talk are in Haskell / Java 8 / Scala / Elm and JavaScript, but deep understanding of any of these languages are not a pre-requisite.
Unit Testing in Java
Unit testing involves writing code to test individual units or components of an application to ensure they operate as intended. A unit test targets a specific function or class and ensures the code works correctly. A test suite is a collection of test cases that test a module. Frameworks like JUnit simplify the unit testing process and allow for test automation. JUnit tests are created in the same project structure with a "Test" suffix and use annotations to define test cases and suites. Tests can then be run and results analyzed to measure code coverage.
Java chapter 2
This document provides an overview of basic Java programming concepts including:
- Variable types such as primitives (int, double, char etc.), identifiers, and constants.
- Declaring and assigning values to variables including literals, compatible data types, and type casting.
- Operators for arithmetic, assignment, increment/decrement, and precedence. Errors from division by zero or incompatible types are discussed.
- Strings, escape sequences, and concatenation.
A Closer Look at Real-World Patches
Bug fixing is a time-consuming and tedious task. To reduce the manual efforts in bug fixing, researchers have pre- sented automated approaches to software repair. Unfortunately, recent studies have shown that the state-of-the-art techniques in automated repair tend to generate patches only for a small number of bugs even with quality issues (e.g., incorrect behavior and nonsensical changes). To improve automated program repair (APR) techniques, the community should deepen its knowledge on repair actions from real-world patches since most of the techniques rely on patches written by human developers. Previous investigations on real-world patches are limited to statement level that is not sufficiently fine-grained to build this knowledge. In this work, we contribute to building this knowledge via a systematic and fine-grained study of 16,450 bug fix commits from seven Java open-source projects. We find that there are opportunities for APR techniques to improve their effectiveness by looking at code elements that have not yet been investigated. We also discuss nine insights into tuning automated repair tools. For example, a small number of statement and expression types are recurrently impacted by real-world patches, and expression-level granularity could reduce search space of finding fix ingredients, where previous studies never explored.
JMockit
This document provides an overview of JMockit, a mocking framework for unit testing Java code. It discusses how to install JMockit, use annotations like @Mocked and @Injectable to mock classes and instances, set up expectations to define mocked method return values, partially mock classes by mocking specific methods, mock constructors, and verify mocked method calls were made using verifications. The document also explains how to use JMockit's code coverage reporting and addresses common scenarios for when to use expectations, mockups, constructor mocking, and verifications.
"Formal Verification in Java" by Shura Iline, Vladimir Ivanov @ JEEConf 2013,...
This document discusses formal verification and testing methods for software. It defines formal verification as mathematically proving software correctness against a specification, while testing involves running software with different inputs to check for errors. The document outlines some key differences: formal verification provides a lower bound on quality by guaranteeing absence of certain failures, while testing only provides an upper bound. It also discusses techniques like deductive verification using theorem proving. Later sections cover topics like type systems, annotations, and pluggable type checking tools like the Checker Framework.
JMockit Framework Overview
JMockit is a Java mocking framework that provides tools for isolating code dependencies during unit testing. It uses bytecode instrumentation to remap classes at runtime, allowing final classes and static methods to be mocked. Expectations define mock object behavior, and verifications ensure mocks are used as expected. JMockit provides a more powerful and flexible mocking approach than alternatives like Mockito through its instrumentation and expectations/verifications APIs.
Exception handling in c++ by manoj vasava
Exception handling in C++ provides built-in features to detect and handle runtime errors such as division by zero or accessing arrays out of bounds. Exceptions are unusual conditions that may occur during program execution and exception handling provides a type-safe way to cope with unpredictable problems at runtime rather than terminating the program. Exception handling is needed for object-oriented and distributed programs because traditional error handling solutions are not always appropriate.
Exception handling in c programming
The document outlines an end semester presentation by Group C on the topic of algorithms and computing labs. It includes the contents of the presentation which cover errors and exception handling basics, examples of exception occurrence and handling methods, and three example programs of increasing difficulty. It lists the group members and how presentation tasks were divided among them. It also includes details on grading criteria and a question/answer session.
Write readable tests
The presentation describes the properties of a good unit test. The code examples are written in java, but should make sense in each object oriented programming language.
Looking for Bugs in MonoDevelop
An important event has taken place in the PVS-Studio analyzer's life: support of C#-code analysis was added in the latest version. As one of its developers, I couldn't but try it on some project. Reading about scanning small and little-known projects is not much interesting of course, so it had to be something popular, and I picked MonoDevelop.
What's hot (20)
Mastering Mock Objects - Advanced Unit Testing for Java
Mastering Mock Objects - Advanced Unit Testing for Java
Working Effectively with Legacy Code: Lessons in Practice
Working Effectively with Legacy Code: Lessons in Practice
Beyond PITS, Functional Principles for Software Architecture
Beyond PITS, Functional Principles for Software Architecture
"Formal Verification in Java" by Shura Iline, Vladimir Ivanov @ JEEConf 2013,...
"Formal Verification in Java" by Shura Iline, Vladimir Ivanov @ JEEConf 2013,...
Similar to Introduction to automated quality assurance
Ensuring code quality
This document discusses various tools and procedures for ensuring high code quality in Java development, including:
- Enforcing coding standards through code reviews and unit testing as part of the software development lifecycle.
- Measuring software quality through metrics like ease of testing and number of defects.
- Using static code analysis tools like FindBugs to identify issues and ensure compliance with best practices.
- Monitoring runtime performance with tools like JConsole and VisualVM.
Quality assurance of large c++ projects
This document discusses quality assurance techniques for large C++ projects. It describes the differences between quality assurance and quality control, with QA focusing on preventing defects during development, while QC finds defects in finished products. A variety of techniques are listed and their estimated effectiveness rates at finding defects. The document advocates using source control, build tools, coding standards, code reviews, unit testing, static analysis, code coverage, runtime verification tools, and continuous integration to improve quality assurance.
Introduction & Manual Testing
The document discusses various software development life cycle models and testing methodologies. It introduces the waterfall model, prototyping model, rapid application development model, spiral model, and component assembly model. It then covers testing fundamentals, test case design, white box and black box testing techniques, and the relationships between quality assurance, quality control, verification and validation.
Manualtestingppt
The document discusses various software development life cycle models and testing methodologies. It introduces the waterfall model, prototyping model, rapid application development model, spiral model, and component assembly model. It then covers testing fundamentals, objectives, design of test cases, white box and black box testing techniques, and the relationships between quality assurance, quality control, and validation/verification.
Software testing
This document provides an overview of software testing. It discusses how software testing is used to find defects and validate that software meets requirements. While testing cannot prove that software is perfect, it helps evaluate quality by comparing behavior to standards and user needs. The document also notes that the cost to fix defects rises significantly if found later in development or after release.
Coding and testing in Software Engineering
The document discusses various aspects of software engineering coding practices. It describes the coding phase where design is transformed into code and tested. It emphasizes the importance of coding standards and guidelines to ensure uniform and understandable code. It also discusses code review, documentation, testing approaches like black box and white box testing, and the objectives of testing.
Software testing (2)
This document discusses various software testing methodologies. It begins by defining software testing and its objectives. It then covers topics like verification and validation, unit testing, integration testing strategies, validation testing, system testing types, and software testing strategies. The remainder of the document focuses on different types of testing like white-box testing, black-box testing, and grey-box testing along with techniques like structural testing, code coverage, equivalence partitioning, and boundary value analysis.
Unit_5 and Unit 6.pptx
The document discusses software coding and testing. It covers coding standards and guidelines, code review techniques like code walkthroughs and inspections, and types of software documentation. It then discusses various software testing strategies and techniques, including unit testing, integration testing, regression testing, smoke testing, and validation testing. The goal of testing is to find errors before delivery to end users. Different testing types focus on different parts of the software development process from individual code components to integrated systems.
Code review
Code review in TFS is an important concern. In this presentation we will learn now to implement best practices while doing code review with TFS.
Static Analysis
This document discusses improving software quality at SAKS.com through static analysis even before testing. It recommends using static analysis tools like FindBugs, CheckStyle, PMD, and JavaScript Lint to analyze code and detect bugs. FindBugs uses data flow analysis to detect bug patterns in Java code and has found many real bugs at Google. Static analysis is most effective when used continuously and can catch 5-10% of quality problems. The document outlines plans to continue using Cruise Control for continuous integration and to add FindBugs and other analysis tools to generate reports.
Code coverage & tools
Code Coverage & Tools, Clover ,Cobertura ,Emma
File Can be downloaded from:
http://community.scmgalaxy.com/
Testing concepts
Foundation level testing Concepts,Non function testing ,Non-Functional testing ,Selenium Tool,
What is Software Testing Software Testing is an activity in software development.
It is an investigation performed against a software to provide information about the quality of the software to stakeholders.
Software testing is associated with the two terms.
Validation: Are we doing the right job?
Verification: Are we doing the job right?
Case study "Virtual Show Room" – VSR,water fall model,General Principles of Testing,
The General V-Model
Unit Testing
Component Testing
Integration Testing
System Testing
Acceptance Testing
Automating The Process For Building Reliable Software
This document discusses automating the software testing process to improve reliability. It notes that manual testing is time-consuming and error-prone, taking up 50% of software budgets. Automating unit testing, integration testing, code coverage analysis, traceability between tests and requirements, and regression testing can help address these issues. Test-driven development is presented as a philosophy that involves writing tests before code, improving quality and reducing costs by finding defects earlier. Automated tools can generate test harnesses, measure coverage, and link tests to requirements and code.
Parasoft .TEST, Write better C# Code Using Data Flow Analysis
Data flow analysis is a type of static code analysis that examines how values are propagated through a program. It is more effective than pattern matching or regular static analysis at finding defects related to interactions between methods and classes that may be difficult to uncover through testing alone. Static analysis tools using data flow analysis can simulate execution paths to detect potential issues without requiring the code to be compiled and run. Developers are encouraged to use static testing tools to catch defects early in development, as prevention of bugs is more efficient than finding and fixing them later.
Software Testing Certification
Software Testing is the backbone of any IT product, Services Company. Industry size is about USD$13 billion globally and is one of the biggest recruiters and job creators in India. Software testing can be manual and automated. Vskills certification will focus on the different concepts of testing, automated testing necessary documentation and project management needs and metrics for testing, automated testing and different tools for testing like load testing, cost driven training and GUI based testing. Some different test automation tools will be introduced.
http://www.vskills.in/certification/Certified-Software-Testing-Professional
Certified Software Testing Professional
Vskills Offering certification in Software Testing, This Course is intended for professionals and technical graduates seeking career in Software industry and wanting to excel in chosen areas. It is also well suited for those who are already working and would like to take certification for further career progression. Indian IT industry is moving up the value curve, and today’s scenario demands more specialization and that is where a certification of this type will add value.
White box & black box testing
- Full unit dedicated to Software Testing which covers topics such as White Box and Black Box Testing.
[India Merge World Tour] Coverity
The document discusses Coverity Development Testing which helps reduce risks in software development through continuous integration and development testing. It highlights how software complexity and speed of development have outpaced traditional testing methods. Coverity aims to move quality, security and testing earlier in the software development lifecycle through static analysis, issue management, and developer workflow integration. The document provides an overview of how Coverity's static analysis works and how it can find critical defects that are difficult to detect with traditional testing alone.
To Improve Code Quality in Your Software Development Projects- Code Brew Labs...
Improving code quality is crucial for the success of any software development project. It enhances maintainability, and readability, and reduces the likelihood of bugs. To Boost your software development company in Dubai.
Unit testing - An introduction
The document discusses unit testing, describing it as an automated piece of code that invokes and checks the behavior of a method, providing benefits like proving code works, catching bugs early, and improving design without breaking code. It provides best practices for unit testing like making tests independent and focused on testing one thing, using Arrange-Act-Assert structure, and avoiding dependencies on external resources. The document also distinguishes unit tests from acceptance tests, noting unit tests focus on functionality at a method level while acceptance tests verify requirements across the full system.
Similar to Introduction to automated quality assurance (20)
Automating The Process For Building Reliable Software
Automating The Process For Building Reliable Software
Parasoft .TEST, Write better C# Code Using Data Flow Analysis
Parasoft .TEST, Write better C# Code Using Data Flow Analysis
To Improve Code Quality in Your Software Development Projects- Code Brew Labs...
To Improve Code Quality in Your Software Development Projects- Code Brew Labs...
More from Philip Johnson
Kukui Cup 2012 Energy Data
This document presents a preliminary report on energy consumption data from buildings at the University of Hawaii (UH) and Hawaii Pacific University (HPU) during their 2012 Kukui Cup energy reduction competition. The data shows that buildings at UH generally saw an increase in energy use from August to October, while buildings at HPU remained flat. The competition appeared to temporarily flatten the rising trend at UH when participation was over 60%. Buildings with 100% participation at HPU saw up to a 20% reduction, while most buildings at both universities showed little impact from the competition.
Introduction to ICS 691: Software Engineering for the Smart Grid
This seminar provides an introduction to software engineering for the smart grid. It will be conducted as a graduate seminar with students leading discussions and presenting on research papers. The seminar topics will focus on areas related to smart grid software research. Assessments will include seminar preparation, presentation, and engagement as well as biweekly progress reports on an individual smart grid software project.
Kukui Cup 2012 Organizing Committee February Meeting
The February meeting of the Kukui Cup/UH 2012 Organizing Committee covered the following topics:
1. Introductions and feedback on past Kukui Cup events, noting things that were liked and could be improved.
2. A review of the 2011 t-shirts, swag, schedule, and point system to gather feedback for 2012.
3. A discussion of workshop reviews and promotional video production for the 2012 Kukui Cup.
4. Next steps including providing feedback over the summer and helping plan events in fall 2012.
How to plan a Kukui Cup
For those interested in planning their own Kukui Cup energy challenge, some of the issues they will need to consider.
Honors thesis overview: Katie Amberg-Johnson
The document discusses using molecular tweezers to investigate the fracture point of the σ54 core binding domain during transcription initiation. The experiment involves generating DNA handles, attaching them to the purified core binding domain protein, and then using molecular tweezers to apply force and simulate the "tugging" by the activator binding domain. This could reveal if the two subdomains of the core binding domain unfold separately or together under stress.
Introduction to Issue Driven Project Management
The document introduces issue-driven project management (IDPM), a simple approach for small group software projects. IDPM divides work into tasks represented as issues on an issue tracking system. Tasks are assigned as issues to individual team members and status is updated as tasks are started, completed, or new tasks identified. Daily stand-up meetings are used to assign new tasks, ensure forward progress, and quickly address any blockers or breakdowns.
Introduction to continuous integration
The document introduces continuous integration (CI), discussing its motivation, benefits, and how to implement it using the Hudson/Jenkins open source tool. CI ensures that code commits can be automatically built, tested and integrated to find issues early. The document recommends setting up a Jenkins server to regularly pull code from source control, run tests, and email developers on failures, improving the development workflow.
Introduction to WattDepot
A brief overview of WattDepot, a system for collection, storage, analysis, and visualization of energy data.
Introduction to Subversion and Google Project Hosting
This document introduces Subversion (SVN) and Google Project Hosting. It describes basic SVN concepts like repositories, working copies, commits, updates and revisions. It explains how SVN uses repository-wide revisions rather than file-based versions. Branches, tags and trunks are organized conventionally in an SVN repository. Google Project Hosting provides a free SVN server and issue tracker for open source projects.
Introduction to Version Control and Configuration Management
Version control systems like SVN aim to address three classic configuration management problems: the double maintenance problem of multiple copies needing separate updates, the shared data problem of developers accessing the same files, and the simultaneous update problem of file clobbering during concurrent edits. SVN improves on CVS by using a database backend instead of file versions, supporting repository-wide instead of file-based versions, and using directory-based tags and branches. Distributed version control systems like Git store a full code repository locally and support decentralized workflows without a central server.
A beginners guide to testing
Testing is important because software errors can have serious consequences like customer bank balances being inflated by $763 billion or radiation therapy machines overexposing patients. Testing helps verify that software meets its specifications and functions as intended. There are two main types of testing: static testing which analyzes source code without running programs, and dynamic testing which executes programs to look for errors. It is difficult to exhaustively test all possible inputs for non-trivial programs, so test cases must strategically sample a small percentage of inputs to uncover many defects. Both black box and white box testing methods aim to design effective test cases.
Introduction to Software Build Technology
This document introduces build and packaging technologies, including Ant, Ivy, Maven and Make. It discusses the motivation for using build tools in modern software development which involves multiple developers, platforms and environments. It provides an overview of Ant, Make, Maven and Ivy, comparing their features and advantages. It also describes how to structure an Ant-based build system using the example robocode-pmj-dacruzer project.
Introduction to Software Review
The document discusses software review methods and optimal review practices. It describes different review methods from walkthroughs to inspections and their goals and attributes. Inspections are highlighted as the most formal review method, involving preparation, an orientation, planning, a review meeting, rework, and verification stages. The goals of technical reviews are also outlined, including improving quality and knowledge while minimizing costs.
Introduction to Robocode
This document introduces Robocode, an open-source robot simulation game. It is used to teach students Java programming skills through developing robots that can move, scan for others using radar, and fire guns, while gaining points for survival and hitting opponents. Students will download Robocode, run sample robot matches, and use Eclipse to develop and run their own robot by learning skills like movement, targeting, and firing to make their robot win matches against others.
Codings Standards
The document discusses coding standards and conventions for collaborative Java development. It outlines general principles like adhering to style and least astonishment. It also describes specific formatting, naming, documentation, and programming conventions like using meaningful names, commenting code, making fields private, and exception handling best practices. Automated tools like Checkstyle and Eclipse formatters can help enforce standards but may require configuration. Additional standards for the class are on the website.
Interactive Development Environments
An interactive development environment (IDE) is a software tool that aids in computer programming. Key features of an IDE include language-aware editing, project management, integrated compilation and debugging. While IDEs take more time to learn than basic text editors, they allow developers to work more efficiently on large software projects through features like code navigation, refactoring and testing. For these reasons, potential employers often expect job candidates to be skilled with IDEs like Eclipse rather than basic text editors.
Introduction to Intermediate Java
The document discusses modern Java constructs introduced after Java 5, including collections, generics, autoboxing, enumerated types, annotations, and how to properly design classes to work with collections. It provides code examples and best practices for using these constructs and highlights resources like Java in a Nutshell and Effective Java for further reading.
Professional Persona
This document discusses the components that make up a professional persona, which is an online presence that potential employers can view. It identifies the key elements as: 1) a professional portfolio website, 2) an online engineering blog, 3) participation in open source projects, 4) involvement in professional social networks, and 5) engagement with technical societies and activities. The goal is to help students establish an attractive online presence that showcases their skills and accomplishments to future employers.
01.intro
This document provides an overview of the ICS 314 and 613: Software Engineering course taught by Philip Johnson. It outlines the instructor's background and contact information, goals of the course, what constitutes "quality" software, open source development principles, standards and feedback, course structure, prerequisites, grading, differences between 314 and 613, lectures and labs, quizzes, engineering log requirements, developing a professional persona, collaboration vs. cheating policies, and lessons learned from past students.
iHale Milestone 2 Kickoff
This document provides an overview of the TeamHawaii Solar Decathlon software system interface milestone 2 kickoff. The goal is to implement monitoring and control for five house systems by April 2011 to explore the design space of these capabilities. It discusses what makes a house "smart" through integration, data collection, and control. The system architecture collects data from house systems through various interfaces to a central iHale API and repository for monitoring and sending control commands. Details are provided on assumptions for milestone 2 capabilities for each system and issues to consider regarding monitoring and control capabilities.
More from Philip Johnson (20)
Introduction to ICS 691: Software Engineering for the Smart Grid
Introduction to ICS 691: Software Engineering for the Smart Grid
Kukui Cup 2012 Organizing Committee February Meeting
Kukui Cup 2012 Organizing Committee February Meeting
Introduction to Subversion and Google Project Hosting
Introduction to Subversion and Google Project Hosting
Introduction to Version Control and Configuration Management
Introduction to Version Control and Configuration Management
Recently uploaded
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
Climate Impact of Software Testing at Nordic Testing Days
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
TrustArc Webinar - 2024 Global Privacy Survey
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
Pushing the limits of ePRTC: 100ns holdover for 100 days
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
UiPath Test Automation using UiPath Test Suite series, part 5
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Large Language Model (LLM) and it’s Geospatial Applications
Large Language Model (LLM) and it’s Geospatial Applications.
Mind map of terminologies used in context of Generative AI
Mind map of common terms used in context of Generative AI.
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
National Security Agency - NSA mobile device best practices
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
A tale of scale & speed: How the US Navy is enabling software delivery from l...
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Generative AI Deep Dive: Advancing from Proof of Concept to Production
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
20 Comprehensive Checklist of Designing and Developing a Website
Dive into the world of Website Designing and Developing with Pixlogix! Looking to create a stunning online presence? Look no further! Our comprehensive checklist covers everything you need to know to craft a website that stands out. From user-friendly design to seamless functionality, we've got you covered. Don't miss out on this invaluable resource! Check out our checklist now at Pixlogix and start your journey towards a captivating online presence today.
Introducing Milvus Lite: Easy-to-Install, Easy-to-Use vector database for you...
Join us to introduce Milvus Lite, a vector database that can run on notebooks and laptops, share the same API with Milvus, and integrate with every popular GenAI framework. This webinar is perfect for developers seeking easy-to-use, well-integrated vector databases for their GenAI apps.
Full-RAG: A modern architecture for hyper-personalization
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
Recently uploaded (20)
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?
Climate Impact of Software Testing at Nordic Testing Days
Climate Impact of Software Testing at Nordic Testing Days
Pushing the limits of ePRTC: 100ns holdover for 100 days
Pushing the limits of ePRTC: 100ns holdover for 100 days
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdf
UiPath Test Automation using UiPath Test Suite series, part 5
UiPath Test Automation using UiPath Test Suite series, part 5
Large Language Model (LLM) and it’s Geospatial Applications
Large Language Model (LLM) and it’s Geospatial Applications
Mind map of terminologies used in context of Generative AI
Mind map of terminologies used in context of Generative AI
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
GraphSummit Singapore | Neo4j Product Vision & Roadmap - Q2 2024
National Security Agency - NSA mobile device best practices
National Security Agency - NSA mobile device best practices
Monitoring Java Application Security with JDK Tools and JFR Events
Monitoring Java Application Security with JDK Tools and JFR Events
A tale of scale & speed: How the US Navy is enabling software delivery from l...
A tale of scale & speed: How the US Navy is enabling software delivery from l...
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024
Generative AI Deep Dive: Advancing from Proof of Concept to Production
Generative AI Deep Dive: Advancing from Proof of Concept to Production
20 Comprehensive Checklist of Designing and Developing a Website
20 Comprehensive Checklist of Designing and Developing a Website
Introducing Milvus Lite: Easy-to-Install, Easy-to-Use vector database for you...
Introducing Milvus Lite: Easy-to-Install, Easy-to-Use vector database for you...
Full-RAG: A modern architecture for hyper-personalization
Full-RAG: A modern architecture for hyper-personalization
Introduction to automated quality assurance
- 1. Automated Quality Assurance Philip Johnson Collaborative Software Development Laboratory Information and Computer Sciences University of Hawaii Honolulu HI 96822
- 6. A Quick Tour of Automated QA Tools
- 19. The three primary Automated QA tools for this class