The importance of a well–structured and understandable code base with a low amount of errors is of the utmost importance for our ability to deliver and maintain software. This video focuses on how Static Code Analysis helps achieve this. Read more
This video explains the need for software audits and proposes five code reviews that every developer should use: Numerical Literal, String Literal, god Method, Shotgun Surgery and Duplicate Code. Static code analysis is performed without actually executing programs built from that software.
Python’s implementation is slow, but you can often write fast Python if you know how to profile your code effectively. This presentation will show you how to use the built-in cProfile module to capture profile data, both in simple scripts and more complex GUI environments. We’ll look at how to interpret the profile/cProfile reports as well as a few external tools to make the reports easier to understand. We’ll discuss how to make profiling an effective tool for you and some common “hot spots” you’ll discover in Python code.
In this episode we are going to take a quick look at how to setup and use the NCover code coverage and analysis tool. Having the knowledge of the state of your code, is key to understanding the potential success and failures in your code. If having this knowledge is key to you, NCover is a great tool to help you better gain this knowledge.
This episode we are we are going to take a look at the NDepend static analysis tool. When taking a look at NDepend we are going first to do a simple fly-by of how to setup and run NDepend. Once we have our simple project up and running we are going to turn our focus at takig a look at how to run NDepend from our NAnt scripts. Running NDepend as part of our builds will allow us to have a clear picture of the state of our code with each build.
To take full advantage of the latest multi-core hardware, developers must utilize multiple threads in their applications. Mutli-threaded applications introduce an entirely new class of hard-to-find software failures, commonly known as concurrency defects. To date, testing for Concurrency defects such as Race Conditions, Thread Blocks, Atomicity and Deadlocks have been extremely difficult due to the complexity inherent in multi-threaded run-time environments. In this session, Ben Chelf, CTO of Coverity will explain how developers can find and eliminate concurrency defects early in the development cycle to avoid lengthy QA cycles or costly field bugs. In addition to an overview of the challenges between single-threaded and multi-threaded development styles, Chelf will also provide specific examples of how the use of combined static and dynamic code analysis can pinpoint the most dangerous Concurrency defects.
This talk will describe the current status of JSR-305, Java annotations for software defect detection. This JSR will define several standard Java annotations for properties such as @Nonnegative and @Nonnull that can be used to document your design intentions in a way that be interpreted by multiple software tools (such as FindBugs and IntelliJ). In addition, the talk (and JSR) will discuss the need for inherited and default JSR-305 annotations and propose a way to provide them.keep looking »