The document discusses Behavior Driven Development (BDD) and the Python tool Behave. BDD develops applications based on required behaviors and utilizes tests written in plain language. Behave is a Python implementation of BDD that uses the Gherkin language to write tests in plain language steps. It provides reusable step code and generates skeleton step code to document features and requirements.
The document introduces SpecFlow, an open source tool for .NET that supports behavior-driven development (BDD) and acceptance test-driven development (ATDD). It discusses BDD and ATDD workflows and guidelines. The document also overview SpecFlow's features like support for platforms, test runners, and installation methods. It demonstrates using Gherkin language to write executable specifications and SpecFlow's workflow of specifying features, developing code, and testing.
Are you a Java developer and you've seen the fluent and modern specification frameworks available in other programming languages such as Spock or jasmine and wondering why we can't have the same thing?
Then Lambda Behave is made for you! It uses numerous Java 8 features in order to enable cleaner and more readable tests and specifications. This quickie will introduce the framework, explain why you would want to use it over JUnit and cover some of its cool features, including:
• How to write fluent and clean specifications in your domain language
• How to write data driven specifications
• How to integrate these into your build tool or IDE
• How IDE usage can influence library design for the better
http://richardwarburton.github.io/lambda-behave/
This document summarizes a talk on using Behavior Driven Development (BDD) with Cucumber and Java. The talk covers:
- An overview of BDD and its format using user stories and scenarios
- How Cucumber supports BDD with plain text specifications that can be implemented in multiple languages like Java
- The advantages of Cucumber like having a single source of truth and focusing development on customer needs
- Using Cucumber-JVM for Java projects, including running tests with JUnit and the command line
- Setting up a sample project in IntelliJ with Cucumber
- An overview of the Geb framework for automating web tests in Groovy
- Time for questions at the end
Spring Cloud Contract And Your Microservice ArchitectureMarcin Grzejszczak
Consumer driven contracts (CDC) are like TDD applied to the API. It’s especially important in the world of microservices. Since it’s driven by consumers, it’s much more user friendly. Of course microservices are really cool, but most people do not take into consideration plenty of potential obstacles that should be tackled. Then instead of frequent, fully automated deploys via a delivery pipeline, you might end up in an asylum due to frequent mental breakdowns caused by production disasters. We will write a system using the CDC approach together with Spring Boot, Spring Cloud Contract verifier. I'll show you how easy it is to write applications that have a consumer driven API and that will allow a developer to speed up the time of writing his better quality software.
API Automation Testing Using RestAssured+CucumberKnoldus Inc.
The slides cover the introduction to cucumber, testNG, RestAssured why is BDD used, Basic concepts, and terminologies used in RestAssured, cucumber and TestNG.
The document discusses using Gatling for continuous performance testing. It recommends making performance testing part of the development process rather than something done by specialists separately. Gatling allows developers to define load testing scenarios in a Scala DSL and get reports on performance. The presentation demonstrates recording a browser session in Gatling, modifying the scenario, running a test and interpreting the results. While Gatling gives performance feedback quickly, it is best for monitoring trends rather than determining a system's maximum load capacity.
The document discusses Behavior Driven Development (BDD) and the Python tool Behave. BDD develops applications based on required behaviors and utilizes tests written in plain language. Behave is a Python implementation of BDD that uses the Gherkin language to write tests in plain language steps. It provides reusable step code and generates skeleton step code to document features and requirements.
The document introduces SpecFlow, an open source tool for .NET that supports behavior-driven development (BDD) and acceptance test-driven development (ATDD). It discusses BDD and ATDD workflows and guidelines. The document also overview SpecFlow's features like support for platforms, test runners, and installation methods. It demonstrates using Gherkin language to write executable specifications and SpecFlow's workflow of specifying features, developing code, and testing.
Are you a Java developer and you've seen the fluent and modern specification frameworks available in other programming languages such as Spock or jasmine and wondering why we can't have the same thing?
Then Lambda Behave is made for you! It uses numerous Java 8 features in order to enable cleaner and more readable tests and specifications. This quickie will introduce the framework, explain why you would want to use it over JUnit and cover some of its cool features, including:
• How to write fluent and clean specifications in your domain language
• How to write data driven specifications
• How to integrate these into your build tool or IDE
• How IDE usage can influence library design for the better
http://richardwarburton.github.io/lambda-behave/
This document summarizes a talk on using Behavior Driven Development (BDD) with Cucumber and Java. The talk covers:
- An overview of BDD and its format using user stories and scenarios
- How Cucumber supports BDD with plain text specifications that can be implemented in multiple languages like Java
- The advantages of Cucumber like having a single source of truth and focusing development on customer needs
- Using Cucumber-JVM for Java projects, including running tests with JUnit and the command line
- Setting up a sample project in IntelliJ with Cucumber
- An overview of the Geb framework for automating web tests in Groovy
- Time for questions at the end
Spring Cloud Contract And Your Microservice ArchitectureMarcin Grzejszczak
Consumer driven contracts (CDC) are like TDD applied to the API. It’s especially important in the world of microservices. Since it’s driven by consumers, it’s much more user friendly. Of course microservices are really cool, but most people do not take into consideration plenty of potential obstacles that should be tackled. Then instead of frequent, fully automated deploys via a delivery pipeline, you might end up in an asylum due to frequent mental breakdowns caused by production disasters. We will write a system using the CDC approach together with Spring Boot, Spring Cloud Contract verifier. I'll show you how easy it is to write applications that have a consumer driven API and that will allow a developer to speed up the time of writing his better quality software.
API Automation Testing Using RestAssured+CucumberKnoldus Inc.
The slides cover the introduction to cucumber, testNG, RestAssured why is BDD used, Basic concepts, and terminologies used in RestAssured, cucumber and TestNG.
The document discusses using Gatling for continuous performance testing. It recommends making performance testing part of the development process rather than something done by specialists separately. Gatling allows developers to define load testing scenarios in a Scala DSL and get reports on performance. The presentation demonstrates recording a browser session in Gatling, modifying the scenario, running a test and interpreting the results. While Gatling gives performance feedback quickly, it is best for monitoring trends rather than determining a system's maximum load capacity.
The document discusses using Gatling for continuous performance testing as part of the development process. It recommends designing generic and specialized test scenarios and recording them in Gatling's DSL. A demo shows converting a browser recording to Gatling code and executing the test to generate reports. While this approach provides early feedback on performance impacts, it is noted that it does not determine maximum supported load in production. The benefits seen so far include preventing issues and helping optimize performance.
Consumer Driven Contracts and Your Microservice Architecture @ Warsaw JUGMarcin Grzejszczak
This document discusses using Spring Cloud Contract to help define contracts between microservices. It notes that without contracts, tests between services can break when implementations change. The document demonstrates coding a sample app to check ages for alcohol purchases, then generating contract stubs using Spring Cloud Contract. It addresses questions like storing contracts in a shared repo, generating stubs without writing scripts using WireMock and RestDocs, and learning more about Spring Cloud Contract.
The document describes an upcoming meetup by Cork Software Crafters on continuous delivery of non-breaking changes. It includes an agenda for the event with an introduction, hands-on exercise in groups, and retrospective. The exercise will involve discussing different scenarios for breaking code changes and steps to integrate them non-breakingly, such as UI, API, database changes. Advice is provided on approaches like feature toggles, parallel changes, and database evolution.
The document discusses various code quality metrics that can be used to understand software quality, including defects density, unit test density, code and test coverage, cyclomatic complexity, fan-in and fan-out, and WTFs per minute. While metrics can help identify issues, they cannot determine the precise cause. Metrics should be used carefully to avoid incentivizing behaviors like hiding bugs. Maintaining pride in craftsmanship is important for quality.
It's nice to work on Green Fields projects. But most of us aren't that lucky! Most organisations have large legacy code bases to maintain. And the legacy applications, ugly as they are, are often what generates the revenue!
But legacy code bases are not easy to work with. Adding new features, or even fixing bugs, is slow and fraught with danger. Unexpected regressions are commonplace. Long testing cycles is the norm.
In this talk we will look at some strategies that can enable you to add new features to legacy systems faster and more reliably. We will examine where the hold-ups typically are, and what We will learn how to write cost-effective automated regression tests suites, and how to use unit testing as a way to document your legacy code base for future work, and improve its quality along the way!
Behaviour Driven Development (BDD) - Closing the Loop on a Great Fiori UXJohn Patterson
BDD (Behavior Driven Development) involves defining requirements as structured scenarios to guide development and act as automated tests. It promotes collaboration between developers, testers, and customers. User stories and acceptance criteria written in a common language like Gherkin provide requirements, documentation, and tests. Automating tests based on these scenarios provides fast, reliable feedback to close the development loop.
Behaviour-driven development (BDD) started as an improved variation on test-driven development, but has evolved to become a formidable tool that helps teams communicate more effectively about requirements, using conversation and concrete examples to discover what features really matter to the business. BDD helps teams focus not only on building features that work, but on ensuring that the features they deliver are the ones the client actually needs.
Learn what BDD is, and what it is not
Understand that the core of BDD is around conversation and requirements discovery, not around tools.
Understand the difference and similarities between BDD at the requirements level, and BDD at the coding level.
Learn what BDD tools exist for different platforms, and when to use them
In this session, we discussed approaches for working with legacy untested code in a safe way.
We saw how Approval Testing and Mutation Testing techniques can be combined to quickly build a robust suite of characterization tests that enables us to refactor with confidence.
https://www.meetup.com/Cork-Software-Craftsmanship-Meetup/events/262255659/
An introduction to Behavior-Driven Development (BDD)Suman Guha
BDD helps develop the correct software by codifying customer requirements into automated test scenarios. Traditional QA focuses on adherence to documented requirements but often misses the actual requirements. BDD establishes a feedback loop through automated scenarios to ensure requirements are met. BDD scenarios describe real user behaviors to test software in a continuous integration process. This catches defects early and reduces costs and time compared to traditional waterfall development.
Behavior Driven Development (BDD) is an essential part of an Agile implementation. What makes BDD so powerful is that it brings all members of a scrum team together in the common goal of defining and releasing a quality product.
The talk will provide an introduction to BDD: Gherkin, writing BDD scenarios, common frameworks. The second part of the talk will focus on how BDD fits into the SCRUM team. We will concentrate on ways BDD can be used to bridge the communication gap often present between various SCRUM players to enable them to become more productive by using a common language.
Meningkatkan SOC dan Reusabillity Kode dengan Duo DI - Sidiq Permana (CIO Nus...DicodingEvent
This document discusses dependency injection (DI) and dependency inversion as techniques for improving software design. It explains that DI provides objects their dependencies rather than having them instantiate dependencies directly. This loosens coupling between objects. Dependency inversion defines objects by their abstractions rather than concretions, making objects more adaptable to change. The document provides examples of implementing DI using libraries like Koin and discusses how DI and dependency inversion together can improve software qualities like reusability and maintainability.
Slides from the London Agile Testing Meetup of November 25 2014:
John Ferguson Smart is a specialist in BDD, automated testing and software life cycle development optimization. John is a well-known speaker at many international conferences and events and an accomplished author (John's new book BDD in Action was published last month).
John presents a talk discussing how to write solid, reliable and maintainable automated web tests using the best-of-breed open source technologies like Selenium WebDriver, Serenity, JBehave and Cucumber.
Consumer Driven Contracts and Your Microservice ArchitectureMarcin Grzejszczak
TDD introduced many improvements into the development process, but in our opinion the biggest impact relates to code design. Looking at the code from the usage perspective (by first writing an acceptance test) allows us to focus on usability rather than concrete implementation. Unfortunately, we usually rest on our laurels not trying to uplift this practice to the architecture level.
This presentation will show you how you can use the Spring Cloud Contract Verifier functionality in order to have a fully automated solution to stub your HTTP / Messaging collaborators. Just by adding proper configuration, you'll surround the microservices you are testing with faked stubs that are tested against their producer, making much more realistic tests.
We will write a system using the CDC approach together with Spring Boot, Spring Cloud and Spring Cloud Contract Verifier. I'll show you how easy it is to write applications that have a consumer-driven API, allowing a developer to speed up the time for writing better quality software.
BDD & JBehave emphasize behavior over testing by describing features in plain language from the business perspective. It improves on TDD by making tests more readable and meaningful. Behavior is described using a Given-When-Then format in executable specifications called examples or stories. BDD brings business analysts, developers and testers together with a shared ubiquitous language to specify requirements and automate acceptance tests.
The document discusses code metrics that can be used to evaluate code quality in PHP projects. It introduces various metrics like lines of code, test coverage, cyclomatic complexity, coupling metrics, lack of cohesion in methods, Halstead complexity measures, and maintainability index. It recommends always using tools like PHP Code Sniffer and PHPUnit for testing and recommends adopting tools like PHPSpec, Behat, PHP Copy/Paste Detector and PHPMetrics. It also suggests giving tools like Humbug for mutant testing a try and considering SaaS options with customization efforts.
The document discusses testing approaches for microservices, including unit tests, integration tests, and end-to-end tests. It advocates for an outside-in development approach using behavior-driven development (BDD) with automated tests written at multiple levels to ensure software delivers expected functionality. BDD involves collaboratively defining requirements as structured scenarios to guide development and act as executable tests.
This document discusses contract-driven development using Spring Cloud Contract. It describes how writing contracts upfront to define API behavior can validate that services match expected behavior. The contracts can then be bundled and shared as artifacts that allow clients to test against before integration. This approach aims to address issues like poorly defined APIs, very serial development, and breaking changes by formalizing expectations and enabling collaboration. The document provides an example YAML contract and demos generating test stubs and documentation from contracts. It argues this process can improve communication, catch issues earlier, and allow parallel development.
Tdd vs bdd vs atdd — developers’ methodologies to navigate complex developmen...Katy Slemon
Know key differences between major development methodologies TDD vs BDD vs ATDD in this post that focus on the task of the developers and their creations
Testing stage. being ahead business with cucumberAlex Mikitenko
Cucumber is a tool that allows teams to collaborate and define executable specifications for software features using a common language. It operates at a high level of abstraction to drive implementation rather than simply reflect code. The document discusses how Cucumber can be used with a Spotify engineering model through a BDD workflow involving user stories, business scenarios, step definitions, and page objects. It provides guidelines for writing good behavior specifications and references additional resources for learning more about Cucumber.
DeTesters meetup november 2018 - Continuous performance: load testing with G...Bert Jan Schrijver
The document discusses using Gatling for continuous performance testing. It outlines how performance testing traditionally only occurred a few times per year but that continuous delivery demands it be part of the development process. The performance testing process with Gatling involves designing scenarios, recording tests, executing them, and reporting results. A demo showed creating a simple test in the Gatling DSL and the reports produced. Benefits found so far include preventing production issues and helping optimize performance.
Case Study: Porting a set of point cloud and triangle mesh processing C++ lib...PVS-Studio
The document discusses porting a C++ library for processing point clouds and triangle meshes from 32-bit to 64-bit. An Italian company called E.G.S. S.r.l. that develops 3D simulation solutions used a library called Leios Components that it wanted to port to 64-bit. They hired a company called OOO "Program Verification Systems" to help with the port using their code analyzer Viva64. Viva64 found and corrected issues allowing the large library to be successfully ported to 64-bit in a short timeframe.
VivaMP, system of detecting errors in the code of parallel C++ programs using...PVS-Studio
The article lists the results of investigation of mistakes made by programmers using C++ and OpenMP. Static analysis is offered for automatic detection of these errors. The description of VivaMP analyzer integrating into Visual Studio environment and implementing the set task is described.
The document discusses using Gatling for continuous performance testing as part of the development process. It recommends designing generic and specialized test scenarios and recording them in Gatling's DSL. A demo shows converting a browser recording to Gatling code and executing the test to generate reports. While this approach provides early feedback on performance impacts, it is noted that it does not determine maximum supported load in production. The benefits seen so far include preventing issues and helping optimize performance.
Consumer Driven Contracts and Your Microservice Architecture @ Warsaw JUGMarcin Grzejszczak
This document discusses using Spring Cloud Contract to help define contracts between microservices. It notes that without contracts, tests between services can break when implementations change. The document demonstrates coding a sample app to check ages for alcohol purchases, then generating contract stubs using Spring Cloud Contract. It addresses questions like storing contracts in a shared repo, generating stubs without writing scripts using WireMock and RestDocs, and learning more about Spring Cloud Contract.
The document describes an upcoming meetup by Cork Software Crafters on continuous delivery of non-breaking changes. It includes an agenda for the event with an introduction, hands-on exercise in groups, and retrospective. The exercise will involve discussing different scenarios for breaking code changes and steps to integrate them non-breakingly, such as UI, API, database changes. Advice is provided on approaches like feature toggles, parallel changes, and database evolution.
The document discusses various code quality metrics that can be used to understand software quality, including defects density, unit test density, code and test coverage, cyclomatic complexity, fan-in and fan-out, and WTFs per minute. While metrics can help identify issues, they cannot determine the precise cause. Metrics should be used carefully to avoid incentivizing behaviors like hiding bugs. Maintaining pride in craftsmanship is important for quality.
It's nice to work on Green Fields projects. But most of us aren't that lucky! Most organisations have large legacy code bases to maintain. And the legacy applications, ugly as they are, are often what generates the revenue!
But legacy code bases are not easy to work with. Adding new features, or even fixing bugs, is slow and fraught with danger. Unexpected regressions are commonplace. Long testing cycles is the norm.
In this talk we will look at some strategies that can enable you to add new features to legacy systems faster and more reliably. We will examine where the hold-ups typically are, and what We will learn how to write cost-effective automated regression tests suites, and how to use unit testing as a way to document your legacy code base for future work, and improve its quality along the way!
Behaviour Driven Development (BDD) - Closing the Loop on a Great Fiori UXJohn Patterson
BDD (Behavior Driven Development) involves defining requirements as structured scenarios to guide development and act as automated tests. It promotes collaboration between developers, testers, and customers. User stories and acceptance criteria written in a common language like Gherkin provide requirements, documentation, and tests. Automating tests based on these scenarios provides fast, reliable feedback to close the development loop.
Behaviour-driven development (BDD) started as an improved variation on test-driven development, but has evolved to become a formidable tool that helps teams communicate more effectively about requirements, using conversation and concrete examples to discover what features really matter to the business. BDD helps teams focus not only on building features that work, but on ensuring that the features they deliver are the ones the client actually needs.
Learn what BDD is, and what it is not
Understand that the core of BDD is around conversation and requirements discovery, not around tools.
Understand the difference and similarities between BDD at the requirements level, and BDD at the coding level.
Learn what BDD tools exist for different platforms, and when to use them
In this session, we discussed approaches for working with legacy untested code in a safe way.
We saw how Approval Testing and Mutation Testing techniques can be combined to quickly build a robust suite of characterization tests that enables us to refactor with confidence.
https://www.meetup.com/Cork-Software-Craftsmanship-Meetup/events/262255659/
An introduction to Behavior-Driven Development (BDD)Suman Guha
BDD helps develop the correct software by codifying customer requirements into automated test scenarios. Traditional QA focuses on adherence to documented requirements but often misses the actual requirements. BDD establishes a feedback loop through automated scenarios to ensure requirements are met. BDD scenarios describe real user behaviors to test software in a continuous integration process. This catches defects early and reduces costs and time compared to traditional waterfall development.
Behavior Driven Development (BDD) is an essential part of an Agile implementation. What makes BDD so powerful is that it brings all members of a scrum team together in the common goal of defining and releasing a quality product.
The talk will provide an introduction to BDD: Gherkin, writing BDD scenarios, common frameworks. The second part of the talk will focus on how BDD fits into the SCRUM team. We will concentrate on ways BDD can be used to bridge the communication gap often present between various SCRUM players to enable them to become more productive by using a common language.
Meningkatkan SOC dan Reusabillity Kode dengan Duo DI - Sidiq Permana (CIO Nus...DicodingEvent
This document discusses dependency injection (DI) and dependency inversion as techniques for improving software design. It explains that DI provides objects their dependencies rather than having them instantiate dependencies directly. This loosens coupling between objects. Dependency inversion defines objects by their abstractions rather than concretions, making objects more adaptable to change. The document provides examples of implementing DI using libraries like Koin and discusses how DI and dependency inversion together can improve software qualities like reusability and maintainability.
Slides from the London Agile Testing Meetup of November 25 2014:
John Ferguson Smart is a specialist in BDD, automated testing and software life cycle development optimization. John is a well-known speaker at many international conferences and events and an accomplished author (John's new book BDD in Action was published last month).
John presents a talk discussing how to write solid, reliable and maintainable automated web tests using the best-of-breed open source technologies like Selenium WebDriver, Serenity, JBehave and Cucumber.
Consumer Driven Contracts and Your Microservice ArchitectureMarcin Grzejszczak
TDD introduced many improvements into the development process, but in our opinion the biggest impact relates to code design. Looking at the code from the usage perspective (by first writing an acceptance test) allows us to focus on usability rather than concrete implementation. Unfortunately, we usually rest on our laurels not trying to uplift this practice to the architecture level.
This presentation will show you how you can use the Spring Cloud Contract Verifier functionality in order to have a fully automated solution to stub your HTTP / Messaging collaborators. Just by adding proper configuration, you'll surround the microservices you are testing with faked stubs that are tested against their producer, making much more realistic tests.
We will write a system using the CDC approach together with Spring Boot, Spring Cloud and Spring Cloud Contract Verifier. I'll show you how easy it is to write applications that have a consumer-driven API, allowing a developer to speed up the time for writing better quality software.
BDD & JBehave emphasize behavior over testing by describing features in plain language from the business perspective. It improves on TDD by making tests more readable and meaningful. Behavior is described using a Given-When-Then format in executable specifications called examples or stories. BDD brings business analysts, developers and testers together with a shared ubiquitous language to specify requirements and automate acceptance tests.
The document discusses code metrics that can be used to evaluate code quality in PHP projects. It introduces various metrics like lines of code, test coverage, cyclomatic complexity, coupling metrics, lack of cohesion in methods, Halstead complexity measures, and maintainability index. It recommends always using tools like PHP Code Sniffer and PHPUnit for testing and recommends adopting tools like PHPSpec, Behat, PHP Copy/Paste Detector and PHPMetrics. It also suggests giving tools like Humbug for mutant testing a try and considering SaaS options with customization efforts.
The document discusses testing approaches for microservices, including unit tests, integration tests, and end-to-end tests. It advocates for an outside-in development approach using behavior-driven development (BDD) with automated tests written at multiple levels to ensure software delivers expected functionality. BDD involves collaboratively defining requirements as structured scenarios to guide development and act as executable tests.
This document discusses contract-driven development using Spring Cloud Contract. It describes how writing contracts upfront to define API behavior can validate that services match expected behavior. The contracts can then be bundled and shared as artifacts that allow clients to test against before integration. This approach aims to address issues like poorly defined APIs, very serial development, and breaking changes by formalizing expectations and enabling collaboration. The document provides an example YAML contract and demos generating test stubs and documentation from contracts. It argues this process can improve communication, catch issues earlier, and allow parallel development.
Tdd vs bdd vs atdd — developers’ methodologies to navigate complex developmen...Katy Slemon
Know key differences between major development methodologies TDD vs BDD vs ATDD in this post that focus on the task of the developers and their creations
Testing stage. being ahead business with cucumberAlex Mikitenko
Cucumber is a tool that allows teams to collaborate and define executable specifications for software features using a common language. It operates at a high level of abstraction to drive implementation rather than simply reflect code. The document discusses how Cucumber can be used with a Spotify engineering model through a BDD workflow involving user stories, business scenarios, step definitions, and page objects. It provides guidelines for writing good behavior specifications and references additional resources for learning more about Cucumber.
DeTesters meetup november 2018 - Continuous performance: load testing with G...Bert Jan Schrijver
The document discusses using Gatling for continuous performance testing. It outlines how performance testing traditionally only occurred a few times per year but that continuous delivery demands it be part of the development process. The performance testing process with Gatling involves designing scenarios, recording tests, executing them, and reporting results. A demo showed creating a simple test in the Gatling DSL and the reports produced. Benefits found so far include preventing production issues and helping optimize performance.
Case Study: Porting a set of point cloud and triangle mesh processing C++ lib...PVS-Studio
The document discusses porting a C++ library for processing point clouds and triangle meshes from 32-bit to 64-bit. An Italian company called E.G.S. S.r.l. that develops 3D simulation solutions used a library called Leios Components that it wanted to port to 64-bit. They hired a company called OOO "Program Verification Systems" to help with the port using their code analyzer Viva64. Viva64 found and corrected issues allowing the large library to be successfully ported to 64-bit in a short timeframe.
VivaMP, system of detecting errors in the code of parallel C++ programs using...PVS-Studio
The article lists the results of investigation of mistakes made by programmers using C++ and OpenMP. Static analysis is offered for automatic detection of these errors. The description of VivaMP analyzer integrating into Visual Studio environment and implementing the set task is described.
Comparing PVS-Studio with other code analyzersPVS-Studio
The article discusses comparison of PVS-Studio code analyzer with other solutions in this sphere. As PVS-Studio contains modules for diagnosing 64-bit and parallel errors, it is compared to various types of tools.
I hope you have already rested from the 13-th lesson and now are ready to study one more important error pattern related to arithmetic expressions in which types of different capacities participate.
Difficulties of comparing code analyzers, or don't forget about usabilityPVS-Studio
Users' desire to compare different code analyzers is natural and understandable. However, it's not so easy to fulfill this desire as it may seem at first sight. The point is that you don't know what particular factors must be compared.
Viva64: working up of 64-bit applicationsPVS-Studio
Viva64 is a static code analysis tool that helps detect errors and issues when porting C/C++ applications to 64-bit platforms. It integrates directly with Visual Studio 2005, allowing developers to check for 64-bit portability issues and incorrect code constructions. Viva64 can analyze entire projects and provides detailed diagnostics and references to help developers understand and fix issues. While it cannot replace full testing, using Viva64 during development can significantly improve code quality and reduce bugs when porting to 64-bit.
Potential errors in 64-bit code may occur depending on compiler optimizations and input data sizes. Slight code changes can expose or hide errors, making them difficult to find. Optimizations may use 64-bit registers to avoid overflows, but minor code alterations could cause 32-bit registers and overflows. Therefore, code with potential errors is unstable and hard to test thoroughly.
Development of a static code analyzer for detecting errors of porting program...PVS-Studio
The article concerns the task of developing a program tool called static analyzer. The tool being developed is used for diagnosing potentially unsafe syntactic structures of C++ from the viewpoint of porting program code on 64-bit systems. Here we focus not on the problems of porting occurring in programs, but on the peculiarities of creating a specialized code analyzer. The analyzer is intended for working with the code of C/C++ programs.
The article is a report about testing of portability of Loki library with 64-bit systems with the help of Viva64 code analyzer performed by OOO "Program Verification Systems" Company. It contains recommendations for users of the library. The article will be also useful for the users of other libraries built on templates for it describes the peculiarities of analysis of such libraries.
Lesson 23. Pattern 15. Growth of structures' sizesPVS-Studio
A growth of structures' sizes is not an error by itself but it may lead to consumption of an unreasonably large memory amount and therefore to performance penalty. Let us consider this pattern not as an error but as a cause of 64-bit code inefficiency.
Mobile CRM Webinar: 6 Steps to Mobile ROI for Government AgenciesWaterfall Mobile
Given the importance of delivering meaningful content to a broad audience within the government sector, mobile presents a critical investment for government agencies. However, the mobile ecosystem’s complexity makes it challenging to scope a detailed roadmap. This webinar, from the Msgme Industry Insights series, details exactly how government agencies can be successful using mobile to engage their audience.
PVS-Studio, a solution for developers of modern resource-intensive applicationsPVS-Studio
The PVS-Studio tool
the Viva64 rule set for 64-bit software analysis;
the VivaMP rule set for parallel software analysis;
the general-purpose analysis rule set.
Licensing and pricing policy forPVS-Studio
About the OOO “Program Verification Systems” company
Traps detection during migration of C and C++ code to 64-bit WindowsPVS-Studio
Appearance of 64-bit processors on PC market made developers face the task of converting old 32-bit applications for new platforms. After the migration of the application code it is highly probable that the code will work incorrectly. This article reviews questions related to software verification and testing. It also concerns difficulties a developer of 64-bit Windows application may face and the ways of solving them.
Optimization in the world of 64-bit errorsPVS-Studio
1. The document discusses the difficulty of demonstrating 64-bit errors through simple examples due to compiler optimizations.
2. An example code is provided that contains two errors by using 32-bit integers to index into a large 64-bit array, but it works correctly due to compiler optimizations.
3. A small change is made to the code to prevent the optimizations and cause it to crash as expected when run with the errors.
4. The author notes that 64-bit errors can be hidden by optimizations and evade detection in debugging and testing, but still cause failures when changes are made or on new compiler versions. Close inspection is needed to find these subtle errors.
Changes in programmer tools' infrastructurePVS-Studio
The article describes some observations concerning changes in the infrastructure of tools used by programmers in everyday work. First of all, these changes are related to the release of Visual Studio 2010.
Analysis of the Ultimate Toolbox projectPVS-Studio
While testing the general analyzer included into PVS-Studio 4.00, we checked several open-source projects from the CodeProject site. One of those was Ultimate ToolBox.
Building of systems of automatic C/C++ code loggingPVS-Studio
Sometimes logging of an application's events is the only debugging method. The logging method's disadvantage is the large size of the code which you have to write manually to save the whole necessary information. The article touches upon the method allowing you to build a system of automatic logging of C/C++ code.
Regular use of static code analysis in team developmentPVS-Studio
Static code analysis technologies are used in companies with mature software development processes. However, there might be different levels of using and introducing code analysis tools into a development process: from manual launch of an analyzer "from time to time" or when searching for hard-to-find errors to everyday automatic launch or launch of a tool when adding new source code into the version control system.
The article discusses different levels of using static code analysis technologies in team development and shows how to "move" the process from one level to another. The article refers to the PVS-Studio code analyzer developed by the authors as an example.
The Source SDK is a software development kit compiled by Valve Corporation that is used to create games or mods for the Source engine. I downloaded and checked the project's source codes at the end of 2013 already and intended to write an article about it during the New Year holidays. But laziness prevailed over the craving for creativity, and I sat down to writing the article only on getting back to work. However, I doubt that the source codes have changed during this time. Now you are welcome to have a look at the suspicious code fragments found in the project code by the PVS-Studio code analyzer.
CodePen is a social development platform that allows users to create code snippets called "pens" that contain HTML, CSS, and JavaScript. Users can edit code directly in their browser and see changes update in real-time. Pens can be shared publicly so developers can learn from and be inspired by each other's work. CodePen helps speed up front-end development by providing code examples to learn from and making it easy to experiment with code without needing other tools.
The Development History of PVS-Studio for LinuxPVS-Studio
Earlier this year, we started doing something that we had felt uncertain about for a long time, namely porting PVS-Studio to Linux. In this article, I will tell you how we made the decision to create a product for Linux distributions after 10 years of the Windows version's existence. It's a big job, which, unfortunately, involves much more work than simply compiling the source files for the new platform, as some may think.
PVS-Studio and CppCat: An Interview with Andrey Karpov, the Project CTO and D...Andrey Karpov
The developers of PVS-Studio analyzer regularly publish new articles about their tool (and sometimes about other analyzers as well) where they share the analysis results of various software projects produced by the analyzer and demonstrate code samples in which defects were found. Quite recently, a new product, CppCat, was released, which is a lightweight version of PVS-Studio at a low cost - compared to that of its heavier counterpart. You can find a brief description of the PVS-Studio project for Visual C++ here and here, and for a description of the new product see the article "An Alternative to PVS-Studio at $250".
This post is about love. About the love of the static code analyzer PVS-Studio, for the great open source Linux operating system. This love is young, touching and fragile. It needs help and care. You will help greatly if you volunteer to help testing the beta-version of PVS-Studio for Linux.
The document provides an overview of Behavior Driven Development (BDD) and the Cucumber testing framework. It discusses why teams adopt BDD, what BDD and Cucumber are, and how to set up the Cucumber environment and write feature files using its Gherkin language. Key points covered include that BDD focuses on specifying and testing desired user behaviors, Cucumber serves as documentation, tests, and an aid using plain text scenarios, and the environment setup shows installing Java, Eclipse, Maven, and adding Cucumber dependencies to create and run feature files.
Comparing Functionalities of PVS-Studio and CppCat Static Code AnalyzersAndrey Karpov
Our company develops two code analyzers to check C/C++ projects: PVS-Studio and CppCat. In this article, we are going to tell you about the functional differences between these two tools.
The document discusses best practices for quality software development including defining quality code, design, and processes. It outlines common problems like poor requirements, unrealistic schedules, and miscommunication. It recommends solid requirements, realistic schedules, adequate testing, sticking to initial requirements where possible, and good communication. The document also presents 7 principles of quality development including keeping it simple, maintaining vision, planning for reuse, and thinking before acting. It concludes with tips for developers like focusing on users and tools to aid development.
In Data Engineer’s Lunch #68, Will Angel, Technical Product Manager at Caribou Financial, will provide an introduction to DevOps practices and tooling including testing, deployment automation, logging, monitoring, and DevOps principles. Additionally, we will discuss some of the ways that DevOps for data engineering is different from conventional application development.
Accompanying Blog: Coming Soon!
Accompanying YouTube: https://youtu.be/eBtrOv_qLHQ
Sign Up For Our Newsletter: http://eepurl.com/grdMkn
Join Data Engineer’s Lunch Weekly at 12 PM EST Every Monday:
https://www.meetup.com/Data-Wranglers-DC/events/
Cassandra.Link:
https://cassandra.link/
Follow Us and Reach Us At:
Anant:
https://www.anant.us/
Awesome Cassandra:
https://github.com/Anant/awesome-cassandra
Email:
solutions@anant.us
LinkedIn:
https://www.linkedin.com/company/anant/
Twitter:
https://twitter.com/anantcorp
Eventbrite:
https://www.eventbrite.com/o/anant-1072927283
Facebook:
https://www.facebook.com/AnantCorp/
Join The Anant Team:
https://www.careers.anant.us
The document is a resume for Abhinav Vashishtha. It summarizes his skills and experience in software modeling and development with 6 years of experience. It details his proficiency in methodologies, IDEs, debuggers, programming languages, and databases. It also lists 2 projects from his current role at Amadeus Labs as a senior software developer and 2 projects from previous roles at Robert Bosch and CDAC KP R&D.
Containers, Serverless, Polyglot Development World, And Others…10 trends resh...PROIDEA
During this presentation, you will learn about the 10 changes that might reshape the developer tools market in the next 10 years. Jarek will discuss containers, serverless functions, and how it all supports an agile and CI/CD experience. The move to a polyglot development world means most applications will be written in a mix of languages, with developers favoring tools that help them navigate easily between languages. Jarek will also walk us through the evolution away from stand-alone developer workstations toward cloud-and-container based development environments offered as a service.
Introduction to Behavior Driven Development Robin O'Brien
This document provides an introduction to Behaviour Driven Development (BDD). It discusses that BDD aims to bridge communication gaps between developers and clients by using examples written in a common language. It also provides a practical example of setting up BDD with JBehave and Java in IntelliJ IDEA, including creating a story file, steps class, and linking class. The document demonstrates how BDD allows describing desired system behaviors in a way that is understandable to both technical and non-technical stakeholders.
Tony Bibbs presented on frameworks for PHP development. He discussed when frameworks should and should not be used, common risks of frameworks, and typical framework components like MVC, ORM, templates. His key recommendation was to only change one component of a framework at a time through incremental improvements.
The DevOps paradigm - the evolution of IT professionals and opensource toolkitMarco Ferrigno
This document discusses the DevOps paradigm and tools. It begins by defining DevOps as focusing on communication and cooperation between development and operations teams. It then discusses concepts like continuous integration, delivery and deployment. It provides examples of tools used in DevOps like Docker, Kubernetes, Ansible, and monitoring tools. It discusses how infrastructure has evolved to be defined through code. Finally, it discusses challenges of security in DevOps and how DevOps works aligns with open source principles like meritocracy, metrics, and continuous improvement.
This document summarizes the DevOps paradigm and tools. It discusses how DevOps aims to improve communication and cooperation between development and operations teams through practices like continuous integration, delivery, and deployment. It then provides an overview of common DevOps tools for containers, cluster management, automation, CI/CD, monitoring, and infrastructure as code. Specific tools mentioned include Docker, Kubernetes, Ansible, Jenkins, and AWS CloudFormation. The document argues that adopting open source principles and emphasizing leadership, culture change, and talent growth are important for successful DevOps implementation.
This document provides an introduction to clean coding principles including identifying bad code through code smells, writing tests, and refactoring code. It outlines good practices for writing transparent, reasonable, and usable code and emphasizes writing tests as a safety belt and leaving the codebase in better condition. The document presents object-oriented design patterns, principles, knowledge of languages and libraries, code smells, testing, and code reviews/refactoring as tools for writing clean code. It links to an example of refactoring code in a step-by-step manner and emphasizes writing tests as the starting point and keeping them as the grammar for the system.
Our Cakephp developers have several years of experience in Cakephp Development who write well optimized code that can handle large volume of traffic. Please give us a call and learn more about how we can build and promote your business
The document provides release notes for OpenERP v6.1. Key highlights include:
- Usability improvements like easier installation and configuration out of the box, simplified screens, and improved import/export tools.
- Social and collaboration features like improved email integration and ability to share documents externally.
- New modules for point of sale, payroll, assets, and a portal.
- Technical improvements including a new web interface architecture, improved testing, and developer enhancements.
Массовый параллелизм для гетерогенных вычислений на C++ для беспилотных автом...CEE-SEC(R)
Michael Wong presented on how SYCL and heterogeneous programming can help develop software for self-driving cars. He discussed that graph programming is well-suited for machine vision and machine learning tasks required for autonomous vehicles. SYCL combines C++ and OpenCL to allow developing software today targeting a wide range of future accelerator hardware through its use of open standards and ability to build computation graphs at compile-time. Codeplay provides products like ComputeCpp that implement SYCL and help deliver embedded intelligence.
Similar to Interview with Issam Lahlali, one of the CppDepend tool creators (20)
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Main news related to the CCS TSI 2023 (2023/1695)Jakub Marek
An English 🇬🇧 translation of a presentation to the speech I gave about the main changes brought by CCS TSI 2023 at the biggest Czech conference on Communications and signalling systems on Railways, which was held in Clarion Hotel Olomouc from 7th to 9th November 2023 (konferenceszt.cz). Attended by around 500 participants and 200 on-line followers.
The original Czech 🇨🇿 version of the presentation can be found here: https://www.slideshare.net/slideshow/hlavni-novinky-souvisejici-s-ccs-tsi-2023-2023-1695/269688092 .
The videorecording (in Czech) from the presentation is available here: https://youtu.be/WzjJWm4IyPk?si=SImb06tuXGb30BEH .
Discover top-tier mobile app development services, offering innovative solutions for iOS and Android. Enhance your business with custom, user-friendly mobile applications.
In the realm of cybersecurity, offensive security practices act as a critical shield. By simulating real-world attacks in a controlled environment, these techniques expose vulnerabilities before malicious actors can exploit them. This proactive approach allows manufacturers to identify and fix weaknesses, significantly enhancing system security.
This presentation delves into the development of a system designed to mimic Galileo's Open Service signal using software-defined radio (SDR) technology. We'll begin with a foundational overview of both Global Navigation Satellite Systems (GNSS) and the intricacies of digital signal processing.
The presentation culminates in a live demonstration. We'll showcase the manipulation of Galileo's Open Service pilot signal, simulating an attack on various software and hardware systems. This practical demonstration serves to highlight the potential consequences of unaddressed vulnerabilities, emphasizing the importance of offensive security practices in safeguarding critical infrastructure.
Fueling AI with Great Data with Airbyte WebinarZilliz
This talk will focus on how to collect data from a variety of sources, leveraging this data for RAG and other GenAI use cases, and finally charting your course to productionalization.
Digital Banking in the Cloud: How Citizens Bank Unlocked Their MainframePrecisely
Inconsistent user experience and siloed data, high costs, and changing customer expectations – Citizens Bank was experiencing these challenges while it was attempting to deliver a superior digital banking experience for its clients. Its core banking applications run on the mainframe and Citizens was using legacy utilities to get the critical mainframe data to feed customer-facing channels, like call centers, web, and mobile. Ultimately, this led to higher operating costs (MIPS), delayed response times, and longer time to market.
Ever-changing customer expectations demand more modern digital experiences, and the bank needed to find a solution that could provide real-time data to its customer channels with low latency and operating costs. Join this session to learn how Citizens is leveraging Precisely to replicate mainframe data to its customer channels and deliver on their “modern digital bank” experiences.
Ivanti’s Patch Tuesday breakdown goes beyond patching your applications and brings you the intelligence and guidance needed to prioritize where to focus your attention first. Catch early analysis on our Ivanti blog, then join industry expert Chris Goettl for the Patch Tuesday Webinar Event. There we’ll do a deep dive into each of the bulletins and give guidance on the risks associated with the newly-identified vulnerabilities.
Programming Foundation Models with DSPy - Meetup SlidesZilliz
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectorsDianaGray10
Join us to learn how UiPath Apps can directly and easily interact with prebuilt connectors via Integration Service--including Salesforce, ServiceNow, Open GenAI, and more.
The best part is you can achieve this without building a custom workflow! Say goodbye to the hassle of using separate automations to call APIs. By seamlessly integrating within App Studio, you can now easily streamline your workflow, while gaining direct access to our Connector Catalog of popular applications.
We’ll discuss and demo the benefits of UiPath Apps and connectors including:
Creating a compelling user experience for any software, without the limitations of APIs.
Accelerating the app creation process, saving time and effort
Enjoying high-performance CRUD (create, read, update, delete) operations, for
seamless data management.
Speakers:
Russell Alfeche, Technology Leader, RPA at qBotic and UiPath MVP
Charlie Greenberg, host
Conversational agents, or chatbots, are increasingly used to access all sorts of services using natural language. While open-domain chatbots - like ChatGPT - can converse on any topic, task-oriented chatbots - the focus of this paper - are designed for specific tasks, like booking a flight, obtaining customer support, or setting an appointment. Like any other software, task-oriented chatbots need to be properly tested, usually by defining and executing test scenarios (i.e., sequences of user-chatbot interactions). However, there is currently a lack of methods to quantify the completeness and strength of such test scenarios, which can lead to low-quality tests, and hence to buggy chatbots.
To fill this gap, we propose adapting mutation testing (MuT) for task-oriented chatbots. To this end, we introduce a set of mutation operators that emulate faults in chatbot designs, an architecture that enables MuT on chatbots built using heterogeneous technologies, and a practical realisation as an Eclipse plugin. Moreover, we evaluate the applicability, effectiveness and efficiency of our approach on open-source chatbots, with promising results.
Taking AI to the Next Level in Manufacturing.pdfssuserfac0301
Read Taking AI to the Next Level in Manufacturing to gain insights on AI adoption in the manufacturing industry, such as:
1. How quickly AI is being implemented in manufacturing.
2. Which barriers stand in the way of AI adoption.
3. How data quality and governance form the backbone of AI.
4. Organizational processes and structures that may inhibit effective AI adoption.
6. Ideas and approaches to help build your organization's AI strategy.
Dandelion Hashtable: beyond billion requests per second on a commodity serverAntonios Katsarakis
This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
Freshworks Rethinks NoSQL for Rapid Scaling & Cost-EfficiencyScyllaDB
Freshworks creates AI-boosted business software that helps employees work more efficiently and effectively. Managing data across multiple RDBMS and NoSQL databases was already a challenge at their current scale. To prepare for 10X growth, they knew it was time to rethink their database strategy. Learn how they architected a solution that would simplify scaling while keeping costs under control.
GraphRAG for LifeSciences Hands-On with the Clinical Knowledge Graph
Interview with Issam Lahlali, one of the CppDepend tool creators
1. Interview with Issam Lahlali, one of the
CppDepend tool creators
Author: Andrey Karpov
Date: 06.06.2010
Abstract
The article presents answers to the questions asked to Issam Lahlali that concern the developer tool
CppDepend.
Introduction
In this article, you will read an interview with one of the developers of the CppDepend tool for analyzing
software product structure.
The questions are asked by (the questions are in bold):
Andrey Nikolaevich Karpov. One of the founders of the "Program Verification Systems" company.
Participates in development of the PVS-Studio package intended for detecting defects in application
source code.
The questions are answered by:
Issam Lahlali. One of the developers of the CppDepend and VBDepend packages.
Questions and answers
Tell us more about yourself and CppDepend please. How did the product
evolve?
I'm Issam Lahlali, MCSD and MCSD.NET certified, I worked with several software editors in rance, my last
job was in Sophis as software architect. Two years ago, I had the oportunity to meet Patrick Smacchia,
the developer of NDepend, and he convinced me to work in partnership with his company to develop
CppDepend and VBDepend.
What's CppDepend?
CppDepend is a tool for C++ developers and architects. Code bases are very complex things and
CppDepend is a tool that helps get information from the source code.
For example, with CppDepend, knowing if your code base is correctly layered, knowing what has
changed since the last release or assessing the code quality represent some immediate tasks that might
take hours or days with traditional tools.
2. How would you compare CppDepend with other popular tools?
CppDepend complements other static analysis tools, it focus more on architecture and design rather
than implementation like other tools. With CppDepend, we have a deep view of coupling, cohesion,
abstractness, instability and so on.
How does one get started using CppDepend? What is the recommended
path?
First, download CppDepend and analyze your code base. Once the analysis done, the VisualCppDepend
UI displays several panels to browse analysis results.
At this point, the user needs to choose if he wants to browse dependencies, browse metrics, query the
code base with the CQL language, compare 2 analyses etc... More or less, each feature has its dedicated
panel.
There is also an embedded help section that contains some 'Getting Started' explanations. Some
screencasts are also linked. They explain how to achieve each particular task.
Finally, our website contains advanced documentation such as the complete CQL specifications.
Do you have some examples to show CppDepend in work?
You can find some useful cases studies here, and also some demo screencast showing the utility of
CppDepend features.
What do you consider to be the most powerful or best feature of
CppDepend? And why?
Personally I use the matrix every day to browse dependencies and make sure the architecture remains
clean.
I am also addict to the comparison feature. I often use it to review code that is changing. I really believe
that the devil lies in changes. CQL is also very useful to query the code base, it adds more flexibility to
CppDepend.
How does CppDepend fit in the Software Development Process? What is
CQL and how does it relate to the product?
CppDepend is all about understanding and controlling what really happens in your development shop.
The idea is to fetch relevant information from the code itself.
The tool has 2 sides: The Visual side where the VisualCppDepend UI lets you analyze live your code base,
with graph, matrix, metrics panel. These visual panels with dependency graph, matrix and metric
treemap, help a lot churning the code.
VisualCppDepend comes also with Code Query Language CQL. CQL is really at the heart of the product.
CQL is to your code what SQL is to your data.
You can ask, for example, which method has more than 30 lines of code by writing the CQL query:
3. SELECT METHODS WHERE NbLinesOfCode > 30
And if you want to be warned of such big methods, you can transform this CQL query into a CQL rule this
way:
WARN IF Count > 0 IN SELECT METHODS WHERE NbLinesOfCode > 30
CQL covers a wide range of possibilities, from 60 code metrics to dependencies, encapsulation,
mutability, code changes/diff/evolution.
For example, asking for methods that have been changed recently is as easy as writing:
SELECT METHODS WHERE CodeWasChanged
CppDepend comes with more than 100 rules by default and you can modify existing rules and add new
rules at whim to fit your needs.
The other side of CppDepend is its integration into the Continuous Integration/Build server process. The
idea is to get a daily and highly customized HTML report where you can see at a glance if some CQL rules
have been violated and to get also some metrics about quality or structuring. This is how one can master
what is really happening in one's development shop.
What technologies did you use to develop CppDepend? (Languages,
libraries, parsers)
For parser we adapt doxygen parser to our needs. doxygen is open source, so our modified parser
named CppDependency is also open source, and is available from SourceForge website. CQL engine and
UI are developed with DotNet technology.
Does CppDepend work on Linux and Mac?
We used DotNet technology, so it works only on Windows machine. We plan to adapt our software to
work with Mono. But with CppDepend we can analyze any C++ project - the drawback of analyzing C++
project existing in Linux or Mac machine is that we have to copy the source code to Windows machine.
References
1. Site CppDepend.com. http://www.cppdepend.com/
2. Blog "CppDepend Cases Studies". http://cppdepend.wordpress.com/