[[Software-development::debugging]]

CMUCL false: CMUCL is a free, high performance implementation of the Common Lisp programming language which runs on most major Unix platforms. It mainly conforms to the ANSI Common Lisp standard. CMUCL provides a sophisticated native code compiler; a powerful foreign function interface; an implementation of CLOS, the Common Lisp Object System; which includes multimethods and a metaobject protocol; a source-level debugger and code profiler; and an Emacs-like editor implemented in Common Lisp.

CUnit false: CUnit is a light-weight library that allows programmers to test their C code. Test results can be browsed in multiple formats or built-in interfaces.

Check false: Check is a unit test framework for C. It features a simple interface for defining unit tests, putting little in the way of the developer. Tests are run in a separate address space, so Check can catch both assertion failures and code errors that cause segmentation faults or other signals. The output from unit tests can be used within source code editors and IDEs.

Checker false: Checker is a debugging tool suite which is used to find memory errors at runtime. 'Checker' can help find bugs that standard tools cannot always find. The best example is memory leaks. A memory leak is a zone of memory, allocated with malloc that is not used anymore. So the memory allocated is lost. This means you program needs more memory and runs slower, since your OS might have to start swapping. It detects bad memory accesses such as: reading uninitialized memory, writing in a freed zone, writing or reading outside of a memory block, and using NULL pointers. This is particularly useful for big programs with many functions. Checker maintains bitmaps to keep track of the status of each byte of memory. The status can be writable, readable, both, or none. When memory is allocated, the new memory becomes write-only: you are not allowed to read it because it has not been initialized. But when you you write to this new block, those bytes become readable and writable. When the block is freed, the bytes become unreadable and unwritable. Red zones are unreadable and unwritable memory, so that each access to a red zone produces a warning.

Clisp true: ANSI Common Lisp is a high-level, general-purpose programming language. GNU CLISP is a Common Lisp implementation by Bruno Haible of Karlsruhe University and Michael Stoll of Munich University, both in Germany. It mostly supports the Lisp described in the ANSI Common Lisp standard. It runs on most GNU and Unix systems (GNU/Linux, GNU/Hurd, FreeBSD, NetBSD, OpenBSD, Solaris, Tru64, HP-UX, BeOS, IRIX, AIX, Mac OS X and others) and on other systems and needs only 4 MB of RAM. The user interface comes in English, German, French, Spanish, Dutch, Russian and Danish, and can be changed during run time. GNU CLISP includes an interpreter, a compiler, a debugger, CLOS, MOP, a foreign language interface, a socket interface, i18n, fast bignums, arbitrary precision floats and more. An X11 interface is available through CLX, Garnet, CLUE/CLIO. GNU CLISP runs Maxima, ACL2 and many other Common Lisp packages.

Clozure Common Lisp false: Clozure Common Lisp (CCL) also known as OpenMCL, Macintosh Common Lisp (MCL), Macintosh Allegro Common Lisp (MACL), and Coral Common Lisp (CCL), features: • All major platforms • Fully compiled native code • Fast, precise, compacting, generational garbage collection • Native OS threads on all platforms • A complete mature foreign function interface • Full support for SLIME, ASDF, and QuickLisp • A native IDE on OS X with Objective C and Cocoa integration

CodeLite false: CodeLite is a cross platform IDE for the C/C++ programming languages.Particular features are its excellent code-completion and refactoring. It has generic support for compilers, with built-in support for GCC and Clang. It supports debugging with both GDB and LLDB. It comes with many plugins, including ones for Git and Subversion, qmake, CMake, cscope and Cppcheck. Since version 13.0 it also includes the RAD plugin wxCrafter.

Condenser false: Condenser is a tool for finding and removing duplicated Java code. Unlike tools that only locate duplicated code, Condenser is also able to automatically remove duplicated code where it is safe to do so.

CrocoPat false: 'CrocoPat' is a tool for querying and manipulating relations. It is easy to use because of its simple query and manipulation language based on predicate calculus and its simple file format for relations. It is efficient because it internally represents relations as binary decision diagrams, a data structure that is well-known as a compact representation of large relations. CrocoPat is general, because it manipulates not only graphs (i.e. binary relations), but n-ary relations.

Crossroads Load Balancer false: Crossroads is a load balance and failover utility for TCP-based services. It is a daemon program running in userspace and features extensive configurability, polling of backends using "wakeup calls", detailed status reporting, "hooks" for special actions when backend calls fail, and more. It is service-independent; it is usable for HTTP(S), SSH, SMTP, DNS, etc.

CxxTest false: CxxTest is a JUnit/CppUnit/xUnit-like framework for C++ that doesn't require RTTI, member template functions, exception handling, or any external libraries (including memory management, file/console I/O, or graphics libraries). It is distributed entirely as a set of header files which makes it extremely portable and usable.

DBG-Client false: 'DBG-Client' is the client for the DBG debugger and profiler for the PHP programming language.

DBG-Server false: 'DBG' is a PHP debugger and profiler. It's can backtrace errors. It shows local and global variables as well as parameters which have been passed to all nested function calls at any point of execution. It also lets you execute scripts in a step-by-step manner, set breakpoints (including conditional ones), evaluate expressions, and watch variables. The profiler lets you find bottlenecks in PHP code at the functions level, the modules level, and even the source lines level.

Dbg false: The dbg library is a set of C++ utilities to facilitate modern debugging idioms. It has been designed to support defensive programming techniques in modern C++ code. It integrates well with standard library usage and has been carefully designed to be easy to write, easy to read and very easy to use. 'dbg' provides various constraint checking utilities together with an integrated error logging facility. These utilities can be enabled and disabled at runtime, and in release builds, dbg library use can be compiled away to nothing.

Dbug false: dbug is a macro-based library to see program flow, variables, timings, errors, warnings, etc.

Ddd true: GNU DDD, the Data Display Debugger, is a graphical front-end for command-line debuggers. Many back-end debuggers are supported, notably the GNU debugger, GDB. In addition to usual debugging features such as viewing the source files, DDD has additional graphical, interactive features to aid in debugging.

Dejagnu true: DejaGnu is a framework for testing other programs with the flexibility and consistency that makes it easy to write tests for any program. It provides a layer of abstraction which makes all correctly written tests portable to any host or target where a program must be tested. DejaGnu is written in expect, which in turn uses tcl (which is how the tests themselves are usually written). The framework has two parts: the testing module and the testsuites themselves.

Diapergluforth false: 'diapergluforth' lets you access functions in shared object libraries without having to recompile against the library's header files. It also tracks buffer allocations and automatically frees them when you exit, so you can check for memory leaks immediately after calling a function. In addition, diaperglu traps various error conditions such as attempts to access memory that the process doesn't own, and reporting an error on it's error stack instead of just exiting.

Dvbsnoop false: 'dvbsnoop' is a DVB and MPEG stream analyzer program that lets you watch (live) data stream information in human readable form. It is meant for debugging, dumping, or viewing data streams (e.g. digital television, DSM-CC, MHP, or "Internet via satellite" broadcasts) sent via satellite, cable, or terrestrial lines. Streams can be SI, PES, or TS.

Dwarfdump false: Available as source code only. Prints a human readable representation of DWARF versions 2,3,4, and 5 data from an object file such as Elf,MacOS, or PE(windows). Includes libdwarf, a C library that reads the binary format and presents the data to callers via its API.

Dynamic Probes false: This is a candidate for deletion: Links broken. No links to page. No response from maintainer at given email. Poppy-one (talk) 14:14, 1 August 2018 (EDT) Dynamic Probes (Dprobes) is a generic and pervasive system debugging facility that will operate under the most extreme software conditions such as debugging a deep-rooted operating system problem in a live environment. Dprobes allows the insertion of fully automated breakpoints or probepoints anywhere in the system and user space. Each probepoint has an associated set of probe instructions that are interpreted when the probe fires. These instructions allow memory and CPU registers to be examined and altered using conditional logic. When the probe command terminates, prior to returning to the probed code, a syslog record may be optionally generated.

ELATE false: Extensible Logger and Tracer The goal of this project is to develop the OS-independent, obtrusive, customizable, extensible, generic logging and tracing software mechanism.

Ed true: Ed is a line-oriented text editor: rather than offering an overview of a document, ed performs editing one line at a time. It can be executed both interactively and via shell scripts. Its method of command input allows complex tasks to be performed in an automated way. GNU ed offers several extensions over the standard utility. The original editor for Unix was the most widely available text editor of its time. For most purposes, however, it is superseded by full-screen editors such as GNU Emacs or GNU Moe. N.B. This pacakge also contains a restricted version of ed, red, that can only edit files in the current directory and cannot execute shell commands.

Electric Fence false: This is a candidate for deletion: Links broken. No links to page. No response from maintainer at given email. Poppy-one (talk) 14:11, 1 August 2018 (EDT) Electric Fence (efence) stops your program on the exact instruction that overruns (or underruns) a malloc() memory buffer. GDB will then display the source-code line that causes the bug. It works by using the virtual-memory hardware to create a red-zone at the border of each buffer - touch that, and your program stops. Catch all of those formerly impossible-to-catch overrun bugs that have been bothering you for years.

F2w helpdesk false: f2w helpdesk is a Web-based helpdesk package. It categorises requests to an arbitrary level of detail (using an expert-system-like question and answer method) and associates advice and problem-specific information with the various request categories. The resulting knowledge base helps resolve frequently occurring problems more quickly. Users can also add their own tasks, thus using the program as a todo list or for workflow within teams. Notes can be added to each request at any time.

GNU Visual Debugger false: GPS, the GNAT Programming Studio, is a cutting-edge Free Software IDE that streamlines the interaction between developers and their software. With its intuitive interface, GPS is easy to use, simplifying source navigation and highlighting the fundamental ideas in the program.

Gcl true: GCL is a Compiler and interpreter for Common Lisp. It compiles to C and then uses the native optimizing C compiler (e.g., GCC), giving great portability. It is highly efficient: a function call is basically the same speed as a C function call, in fact identical to a C function call via a pointer. The program has a source level Lisp debugger (dbl) for interpreted code, letting you step a line at a time, while displaying your position in an Emacs window. It has pioneered conservative Garbage Collection schemes, but also has the stratified garbage collection (SGC) scheme, for only recent allocations, that is based on native page fault handling. There is also a built in interface to Tk widget system. Allows a mixture of tcl and common lisp to be used in a user interface--your choice which you use.

Gdb true, false: GDB is the GNU project's debugger and a source-level debugger for Ada, C, C++, Objective-C, Pascal and many other languages. Originally released in 1986 as part of the GNU system, it can now target more than a dozen different processor architectures and can itself run on most popular GNU/Linux variants. GDB lets you to see what is going on `inside' another program while it executes--or what another program was doing at the moment it crashed. GDB lets you start your program, specify anything that might affect its behavior, make it stop on specified conditions, examine what has happened when your program has stopped, and change things in it, so you can experiment with correcting the effects of one bug and go on to learn about another. It also brings Guile scripting support since version 7.8.

Gengetopt true: 'gengetopt' takes an easy-to-do description of options and generates a C function that uses the GNU getopt_long(3) function to parse and validate the options. gengetopt is perfect if you don't want to write all the stuff required to call GNU getopt_long(3), or if you have a program and wish it took many options. The generated code works if you use autoconf or automake.

Ggcov false: Ggcov is a GTK+ GUI for exploring test coverage data produced by C programs compiled with gcc -fprofile-arcs -ftest-coverage. It's basically a GUI replacement for the gcov program that comes with gcc.

Gnusim8085 false: GNUSim8085 is a graphical cross platform simulator plus assembler with debugger for the Intel 8085 microprocessor. The code was initially hosted on SourceForge, then moved to Launchpad in 2010. Despite its name, GNUSim8085 is not a GNU package.

Gnustep true: Provides an object oriented application development framework and tool set for use on a wide variety of platforms. It provides a generalized visual interface design and a cohesive user interface. It also uses a common imaging model called Display PostScript (based on PostScript) to do all its drawing, so the program is truly WYSIWYG. GNUstep is written in the Objective-C language, a simple yet powerful object-oriented language based on C that gives you the full power of an object-oriented language with exactly one syntax addition to C and a dozen or so additional keywords.

Gprofng-gui true: gprofng GUI is a feature rich graphical interface to operate gprofng, which is part of the GNU binutils.

Greg true: Greg is a software testing framework in which test cases can be written in Guile. Its simplicity makes it easy to write tests for any program, but it was specifically written for use with GNUstep-Guile to permit direct testing of the GNUstep libraries without the necessity to run a separate driver program. The core functionality of Greg is a Guile module which can be loaded into any software with an embedded Guile interpreter. Any program which uses Guile as it's scripting language can therefore use Greg to test itself directly. But testing external programs is also possible with the standard Guile `expect' module. Greg provides most of the functionality of DejaGnu but is rather simpler.

Guss false: GUSS the Universal System Simulator simulates hardware to test, debug and profile software. It is (or will be) capable of running an operating system without any modification to the OS itself. This package is still in a very alpha state. Goals for the stable version include speed, host-independence, and the ability to simulate multiple processors, run system-level code, support complex memory hierarchives with minimal performance loss, gather statistics, allow symboling debuggers as frontends, and extend and configure the simulator using Scheme.

HexCurse 2 false: Hexcurse is a versatile ncurses-based hex editor written in C that provides the user with many features. It currently supports searching, hex and decimal address output, jumping to specified locations in the file, an "undo" command, "bolded" modifications, and quick keyboard shortcuts to commands.

Hotspot false: GUI for both recording and viewing runs with Linux perf, providing detailed insights including flamegraphs, timeline, caller/callee and annotated source/disassembly

JDEE false: The Java Development Environment for Emacs (JDEE) is an add on software package for Emacs that assists in the development of software in the Java Programming Language. JDEE provides many Emacs commands that help with editing, compiling, running, debugging, and browsing large Java programs.

Janet false: Janet is a functional and imperative programming language. It runs on Windows, Linux, macOS, BSDs, and should run on other systems with some porting. The entire language (core library, interpreter, compiler, assembler, PEG) is less than 1MB. You can also add Janet scripting to an application by embedding a single C source file and a single header.

Javachecker false: JavaChecker does static analysis for Java source file. It checks various things in the Java source file and gives warning messages, if needed. The program warns the user if: - function name equals constructor name - default constructor is not found in the class - multiply or divide operator is used instead of shift operator for two's power - warns local variables if variables have not been used - warns function parameter variables if variables have not been used - member variables have not been used - explicit import-clauses are not used

Jf-unittest false: jf-unittest is a C++ unit test framework modeled after the way the Python unittest module is used in the Confix test suites. It was written out of frustration with the existing unittest frameworks. As such, it contains no bloat: no GUI with colorful progress bars, no dependencies on any other packages.

Jlint false: Jlint checks Java code and finds bugs, inconsistencies and synchronization problems by doing data flow analysis on the code and building the lock graph. Jlint is fast, easy to learn, and requires no changes in the class files to be checked.

KMD false: KMD is a multi-processor debugger that can debug with hardware boards over serial ports or with software emulators (ARM and MIPS emulators are included in the project). Using the pipe option you can debug over the network or another communications medium. 'KMD' loads many executable formats, and displays and follows the original source even from multiple source file programs. It supports breakpoints and watchpoints which trap on specific data. The project uses 'chump' for disassembly and line assembly. Chump also lets new architectures be added easily without recompilation. Communication with the backend is done using two pipes/fifos using a simple set of codes. Back end communication program can be created using very little memory on the target device.

Kdbg false: KDbg is a graphical user interface to gdb, the GNU debugger. It provides an intuitive interface for setting breakpoints, inspecting variables, and stepping through code.

Kodos false: 'kodos' is a regular expression designer, tester, debugger, and validator whose intuitive interface lets developers create and modify a regular expression (regex) against a test string and see the effects against that test string in real time.

Ksymoops false: The Linux kernel produces error messages that contain machine specific numbers which are meaningless for debugging. 'ksymoops' reads machine specific files and the error log and does its best to converts the code to instructions and map addresses to kernel symbols.

Lazarus false: Lazarus is a cross-platform IDE for developers of Free Pascal.

Libcsdbg false: Libcsdbg is a C++ exception stack tracer. When an exception is thrown, caught and handled, libcsdbg offers the tools to create and process the exception stack trace, the path the exception has propagated up the call stack, unwinding it, up to the section were it was handled. The traces are detailed with demangled function signatures and additional addr2line info (the source code file and line that each function was called). Libcsdbg will perform flawlessly with single and multi-threaded (or multi-process) programs, with any dynamically linked shared object (DSO - Dynamic Shared Object) and with any statically linked library. Additionally, libcsdbg helps the developer/tester create sophisticated stack traces of any thread, at any given moment during a process execution, as a snapshot of the runtime call graph. This is very useful in cases of fatal errors, reception of terminating signals or process abortion/termination (such as segmentation faults). libcsdbg can use all the well-known objective code file formats (a.out, elf, coff, ecoff, etc.) and can easily be used as the base for your own instrumentation code. libcsdbg transparently loads the symbol tables of the chosen dynamic libraries and of the executable, demangles function symbols to complete signatures, and binds function names to runtime addresses (even for the DSO symbols).

Liberty-eiffel true: Liberty Eiffel is a compiler for the Eiffel programming language. It continues the development of SmartEiffel, the GNU Eiffel Compiler. It is a complete, small and fast, Eiffel compiler, including an Eiffel to C compiler, documentation tools, a pretty printer, a debugger and various other tools. It also includes a large library of classes distributed under the terms of the MIT/X Consortium License and a comprehensive set of wrappers/bindings for widespread Free-Software libraries. Eiffel is an advanced object-oriented programming language that emphasizes the design and construction of high-quality and reusable software.

Linice false: Links broken. Maintainer email broken. Redirected homepage to archive.org. Poppy-one (talk) 19:37, 15 August 2018 (EDT) Linice is a source-level kernel debugger for x86 systems with the look and feel of SoftIce for MS Windows. It is designed for people who are already familiar with SoftIce, but anyone can quickly get used to it. It can break into a running kernel at any time using a hotkey and supports breakpoints and single step on modules, the kernel, or user programs. It supports the VGA frame buffer, the X Window System, serial connections, and monochrome adapters.

Linux-libre false, true

Linux-libre is a modified version of Linux with all of the binary blobs, obfuscated code and portions of code under proprietary licenses removed. Currently Linux-libre is maintained and published by the Free Software Foundation Latin America. This is a GNU package.

Packaging

Linux-libre is available in most of the FSF-endorsed distros on https://www.gnu.org/distros/free-distros.html and the lastest versions are packages in Guix and Parabola GNU/Linux-libre. Linux-libre can also be installed on GNU/Linux distributions that use APT from jxself's APT repository: https://jxself.org/linux-libre/

Freedo, official mascot of Linux-libre.

Log4php false: 'log4php' is a PHP port of Log4j, the most popular Java logging framework. It supports configuration through XML and properties files (with the same structure as log4j) and custom Configurators. File, RollingFile, DailyFile, Echo, Console, Mail, PEAR::Db, PHP error, Syslog or NT events, and socket appenders are supported. Simple, TTCC, Pattern, Html, and Xml Layouts are supported. It also supports Filters, custom Levels, and Loggers. Internal debugging can be switched on and off. Log4php can be used inside a class or inside a main/sub function.

Luacheck false: Luacheck is a static analyzer and also a linter for the Lua programming language. You can customize and configure the program to your likings the syntax supports Lua 5.1, Lua 5.2, Lua 5.3, Lua 5.4 and LuaJIT. The program is written in Lua too.

MemCheck Deluxe false: This is a candidate for deletion: Links broken. No archive.org entry. Email to maintainer broken. Poppy-one (talk) 13:43, 17 August 2018 (EDT) MemCheck Deluxe is a memory usage tracker and leak finder. It allows developers to find memory leaks quickly, as well as providing some memory usage information. It also tracks the largest and smallest allocations, as well as the program's maximum memory usage.

Memcheck false: 'memcheck' provides the ability to fault on pointer overrun (read or write) or freed pointer deference (read or write), logs double free and realloc of already freed pointers and memory not freed on exit, checks for pointer underrun on free and realloc, optionally reverses the behavior of overrun and underrun, "churns" reallocations to always return a different pointer, and logs pointer overruns instead of faulting. It has a very small performance impact, with the tradeoff of a large memory footprint. It includes a validation test suite to verify correctness of the library.

Memwatch false: Memwatch is a fault tolerant (can repair its own data structures) memory leak and corruption detection tool. You add a header file to your souce code files, and compile with MEMWATCH defined or not. It can detect double-frees and erroneous frees, unfreed memory, overflow and underflow to memory buffers, and wild pointer writes. It collects allocation statistics on the application, module, or line level.

Mit-scheme true: Mit-scheme is an implementation of the Scheme programming language, providing an interpreter, compiler, source-code debugger, integrated Emacs-like editor, and a large runtime library. MIT/GNU Scheme is best suited to programming large applications with a rapid development cycle.

Mpatrol false: 'mpatrol' is a link library that diagnoses run-time errors caused by the wrong use of dynamically allocated memory, including writing to free memory and memory leaks. It provides a configurable log of all dynamic memory operations (such as malloc(), operator new, etc.) that occurred during the lifetime of a program, checks to detect misuse of dynamically allocated memory, and has support for both memory allocation profiling and tracing. Users can change the library settings at run-time via an environment variable without recompiling or relinking.

Nemiver false: Nemiver is a standalone graphical debugger for the GNOME desktop. It currently features a backend which uses GDB to debug C/C++ programs.

Nim false

Nim was created to be a language as fast as C, as expressive as Python, and as extensible as Lisp. Nim is statically typed. It supports compile-time metaprogramming features such as syntactic macros and term rewriting macros. Term rewriting macros enable library implementations of common data structures, such as bignums and matrices, to be implemented efficiently, as if they were built-in language facilities. Iterators are supported and can be used as first class entities, as can functions, allowing for the use of functional programming methods. Object-oriented programming is supported by inheritance and multiple dispatch. Functions can be generic, they can be overloaded, and generics are further enhanced by Nim's support for type classes. Operator overloading is also supported. Nim includes tunable automatic garbage collection based on deferred reference counting with cycle detection, which can also be turned off altogether.

Features

Intuitive and clean syntax (inspired by Python)
JavaScript compilation
Small core with a rich prospect for extensibility
Decentralised package management with Nimble, the Nim package manager
Helpful tracebacks (inspired by Python)

OTRS false: OTRS (Open Ticket Request System) is a ticket eequest and email management system with many features to manage customer telephone calls and email. The system is built to allow your support, sales, pre-sales, billing, internal IT, helpdesk, etc. department to react quickly to inbound inquiries. It is useful for people who receive many emails and want to answer them with a team of agents.

Ostara false: Ostara is a modern tool for managing and monitoring Spring Boot applications with actuator API, similar to Spring Boot Admin. Our goal is to make the process more user-friendly and straightforward. Ostara allows you to gain insights into the performance and health of your applications by providing real-time data of metrics such as CPU and memory usage, app and system properties, beans and their dependencies, and much more. With Ostara we wanted to create a tool that just works out of the box, just connect to the Spring Boot Actuator and start working.

PMD false: 'PMD' is a Java source code analyzer. It finds unused variables, empty catch blocks, unnecessary object creation, and more. It includes CPD, a tool to detect chunks of identical code.

Pa11y-CI false: CI runs accessibility tests against multiple URLs and reports on any issues. This is best used during automated testing of your application and can act as a gatekeeper to stop a11y issues from making it to live.

Perl Critic false: Perl::Critic is an extensible framework for creating and applying coding standards to Perl source code. Essentially, it is a static source code analysis engine. Perl::Critic is distributed with a number of Perl::Critic::Policy modules that attempt to enforce various coding guidelines. Most Policy modules are based on Damian Conway's book Perl Best Practices. However, Perl::Critic is not limited to PBP and will even support Policies that contradict Conway. You can enable, disable, and customize those Polices through the Perl::Critic interface. You can also create new Policy modules that suit your own tastes.

Pngcheck false: 'Pngcheck' is the official PNG tester and debugger. It verifies the integrity of PNG, JNG and MNG files by checking the internal 32-bit CRCs or checksums, and optionally dumps almost all of the chunk-level information in the image in human-readable form. For example, it can be used to print the basic stats about an image (dimensions, bit depth, etc.); to list the color and transparency info in its palette; or to extract the embedded text annotations. Originally designed simply to test the CRCs within a PNG image file (e.g., to check for ASCII rather than binary transfer), it has since been extended to check and optionally print almost all the information about a PNG image and to verify that the image conforms to the PNG specification. The program supports all PNG and JNG chunks, plus almost all MNG chunks (everything but PAST, DISC, tERm, DROP, DBYK, and ORDR).

Pounder false: Pounder is a utility for testing Java GUIs. Developers can dynamically load components, record scripts, and then use those scripts in JUnit. The program supports custom components, drag and drop, and lets developers examine test runs in source code while maintaining a separate GUI script that can be re-recorded if necessary. The program records mouse motion, drag, click, and wheel events; window events (resize, maximize, movement, etc.); and key events.

PuDB false: PuDB is a full-screen, console-based visual debugger for Python. Its goal is to provide all the niceties of modern GUI-based debuggers in a more lightweight and keyboard-friendly package. PuDB allows you to debug code right where you write and test it--in a terminal. If you've worked with the excellent (but nowadays ancient) DOS-based Turbo Pascal or C tools, PuDB's UI might look familiar.

Pvswitch false: 'pvswitch' is a tiny program which makes it possible to use different program installations on one machine flawlessly. It is most useful for developers of interpreter based programs which are started via a hash-bang line (#!) (Perl, Tcl, etc and who need to run programs sagainst different interpreter version of those languages.

PyChecker false: PyChecker is a tool for finding common bugs in Python source code. It finds problems that are typically caught by a compiler (or lint) for less dynamic languages, like C and C++. Common errors that can be found include forgetting to import a module, misspelling a variable, passing the wrong number of parameters to a function/method, and not using a module/variable.

PyLint false: Pylint is a python tool that checks if a module satisfy a coding standard. It can be seen as another PyChecker, since nearly all tests you can do with PyChecker can also be done with Pylint, but Pylint offers some more features, like checking line-code's length, checking if variable names are well-formed according to your coding standard, or checking if declared interfaces are truly implemented.

Python false: Python is an high-level programming and scripting language. Some of its key distinguishing features include: clear, readable syntax; strong introspection capabilities; intuitive object orientation; natural expression of procedural code; full modularity, supporting hierarchical packages; exception-based error handling; and very high-level dynamic data types.

QtUnit false: QtUnit is a unit testing framework for C++ which compiles into a shared library. Tests can be compiled into modules which are automatically reloaded after modification. The text and graphical testrunners are fully localized and integrate perfectly into IDEs to show exactly where a failure has happened. The program consists of the testing framework, the test runner framework, and the GUI runner framework. Test cases can be grouped into test suites, which then can be compiled into independent modules stored in shared libraries (.so, .dll, ...). This minimizes the number of files that must be recompiled when the sources for the test definitions change. Projects can be defined in XML files (visually in the gui test runner) to group an arbitrary number of modules together. The entire framework compiles into a shared library that creates the actual implementations.

RLog false: 'RLog' is a flexible message logging facility for C++ programs and libraries. It is subscription based, meaning you can subscribe to messages of your choice in various ways: by hierarchical channel name (e.g. "debug", "debug/ special", "error", etc.), or filename, component name, etc. Log messages are individually enabled. It is meant to be fast enough for production code where it may be called many times, as both the GCC and Intel compilers reduce the logging overhead a few clock cycles if they are dormant (with no subscribers). Other add-on components extend subscriptions to external programs, so you can enable and collect debugging messages remotely.

RTFL false: RTFL, which stands for "Read The Figurative Logfile", is a both a protocol for structured debug messages, as well as a collection of programs displaying these debug messages in a semi-graphical way.

Redet false: Redet (Regular Expression Development and Execution Tool) lets users construct regular expressions and test them against input data by executing any of various search programs, editors, and programming languages that use regular expressions. Suitable regular expressions can be saved to a file. The program currently supports over 50 different programs/editors/languages. A palette showing the available regular expression syntax is available for each program; users can copy selections from the palette to the regular expression window, and add definitions to the palette via an initialization file. As long as the underlying program supports Unicode, UTF-8 Unicode is allowed in both test data and regular expressions.

Remote GUD false: Remote GUD mode for Emacs is an Emacs Lisp rsh-gud.el that lets you debug a program running on a remote host, with sources on the local host. It works via rsh.

Rpmlint false: rpmlint checks common errors on RPM packages. It's designed to work with all RPM based package management systems.

Rr (record and replay framework) false: record and replay executions of a program, providing a reproducible debugging experience and allowing full reverse-execution with GDB

Safeheap false: Run time utility to detect buffer overrun and underrun in a C/C++ programs. Aborts the program as soon as a memory corruption is detected and saves the backtrace information in a log file for later debugging. Useful tool to fix hard and frustrating memory corruption bugs.

Scmbug false: 'Scmbug' integrates software configuration management (SCM) with bug-tracking. It aims to be a universal tool that will glue any source code version control system (ie, CVS, Subversion, Arch, etc) with any bug-tracking system (ie, Bugzilla, Mantis, etc).

Sedsed false: Sedsed is a script that masters sed scripts. It generates sed debug files in sed, which lets you debug scripts with your own version of sed. It's also a script beautifier, doing indentation and spaces/comments formatting. It can convert sed scripts to colorful HTML files, and can also be used as a command analyzer.

Sipsak false: 'sipsak' is a command line tool for performing various tests on Session Initiation Protocol (SIP) applications and devices. It can make 4 different tests, send the contents of a file, and interpret and react on the responses. Features include the ability to send OPTIONS requests, send text files (which should contain SIP requests), do a traceroute, run a user location test, run a flooding test, run a random character trashed test, interpret and react on test responses, and authenticate with qop supported.

Steel Bank Common Lisp false: Steel Bank Common Lisp is a development environment for Common Lisp. It supports almost all of the ANSI standard: garbage collection, lexical closures, powerful macros, strong dynamic typing, incremental compilation, and the Common Lisp object system (multimethods and all). It also includes some extensions, such as an interface to call out to C. These are all available through an integrated native compiler, plus the usual Lispy integrated interpreter and high level debugging support.

Strace false: Strace is a system call tracer: it traces all system calls made by another process or program. Since the program to be traced does not need to be recompiled before tracing, strace is useful for programs for which the source is not readily available.

Synopsis false: Synopsis is a multi-language source code introspection tool that provides a variety of representations for the parsed code to enable further processing such as documentation extraction, reverse engineering, and source-to-source translation. It provides a framework of C++ and Python APIs to access these representations and allows Processor objects to be defined and composed into processing pipelines, making this framework very flexible and extensible.

TCLP false: TCLP is a type checker for Prolog dialects. Its goal is to statically trap programming errors like illegal arguments used in a call for a predicate or illegally built data structures with respect to a given typing for function symbols or predicates. TCLP is also capable of type inference for user predicates. It supports ISO-Prolog, GNU-Prolog, and SICStus Prolog.

Thales true

Thales provides macros for GNU Guile to conviently write and check unit-tests, very simular to Python doctest. Also, Thales has functions to check the stability of the public interface of your GNU Guile modules.

For historical reasons, two entrirely different programs exists with the name Thales.

GNU Thales - IRC to Relational Database Gateway Is not maintained, but sources can be accessed via cvs on Savannah (see resource info tab).

https://cvs.savannah.gnu.org/viewvc/thales/thales/README?view=markup

Tuareg false: Tuareg helps editing OCaml code, to highlight important parts of the code, to run an OCaml REPL, and to run the OCaml debugger within Emacs. This mode attempts to give better results than the one provided in the standard distribution of OCaml and which is available through the ocaml-mode package. Indentation rules are slightly different but closer to classical functional languages indentation. Tuareg-mode gives access to some functionalities from ocaml-mode when that package is installed.

UDS Collection false: The UDS (useful development stuff) Collection is a C++ library that provides debugging facilities such as automatic searching for memory leaks and zombie objects, an alternative set of function objects, classes for reference counting, copy-on-write and garbage collection, posix threads wrapper classes, a socket stream class, and much more.

UPnP-Inspector false: The Inspector is an UPnP Device and Service analyzer, and a debugging tool, based on the Coherence DLNA/UPnP framework. Modeled loosely after the Intel UPnP Device Spy and Device Validator.</> It is a GUI to discover and explore UPnP devices on your network. Detected devices are displayed in a tree-view, where - amongst other things - actions can be called and state-variables be queried. It will host the tests from our UPnP test-suite, to provide a central place to verify device implementations and hunt down any UPnP anomalies.

Upad false: Upad is a programmer (aka "chipflasher") and low level debugger for micro-controllers which feature a background debug mode (BDM) interface. BDM is an electronic interface enabling debugging of embedded systems. Specifically, it provides in-circuit debugging in a non-intrusive manner. The interface appears in many Freescale and NXP products, such as the S12Z, HCS08, and 68HC12. Upad may be used to upload programs to such products and to debug those programs. Its software is exclusively free software. It requires a dedicated hardware device, but this is inexpensive and can be easily constructed by a moderately skilled technician.

Valgrind false: Valgrind finds memory-management problems by checking all reads and writes of memory are checked, and intercepting all calls to malloc/new/free/delete. As a result, Valgrind can detect problems like the use of uninitialised memory, reading/writing memory after it has been free'd, reading/writing off the end of malloc'd blocks, reading/writing inappropriate areas on the stack, memory leaks, and passing of uninitialised and/or unaddressible memory to system calls. Valgrind tracks each byte of memory with nine status bits: one tracks addressibility, and the other eight validity. As a result, it can detect the use of single uninitialised bits, and does not report spurious errors on bitfield operations. Valgrind debugs almost any dynamically-linked ELF x86 executable without modification or recompilation.

VirtualBox false: Virtual Machine Software creation entity

Winpdb false: Winpdb is a platform-independent Python debugger with support for multiple threads, namespace modification, embedded debugging, and encrypted communication. It is up to 20 times faster than pdb.

Xdebug false: Xdebug is a debugging library for PHP implemented as a Zend extension. It provides stack traces, function traces, advanced variable display functions, test coverage checks, and performance-testing functions in one package. Functions can be inserted directly into PHP source code or xdebug can be controlled from Eclipse's PHP Development tools or from the Netbeans IDE. Various debugging output formats are supported, including HTML output. Both command-line and web applications can be debugged.

Xev false: XEv is a stand alone X client that prints all the events received by a window, to aid in the debugging and understanding of X11 event messages. It is useful for seeing what causes events to occur and to display the information that they contain; it is essentially a debugging and development tool, and should not be needed in normal usage. It is a part of the X.Org project.

Xpvm false: XPVM provides a graphical interface to the PVM console commands and information, along with several animated views to monitor the execution of PVM programs. These views provide information about the interactions among tasks in a parallel PVM program, to assist in debugging and performance tuning. It also provides some simple debugging assistance by listing textual details from trace events and remote task output. Each trace event corresponds to the entry or exit point of a PVM routine, and contains the calling parameters and return codes/results. The task output is automatically collected from tasks spawned.

Z80-ASM false: 'Z80-ASM' contains a compiler for the Z80 assembling language and a monitor including an interactive debugger. The compiler is a two-pass one, which knows all documented Z80 instructions. It has labels, comments and can even evaluate constant arithmetic expressions. The debugger is interactive; it shows content of all registers, memory, stack, program. You can trace programs step by step, modify registers and contents of memory, and load and save parts of memory.

Free Software Foundation!

Semantic search

Query log

Packaging

Features

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Interaction

Navigation

Creation

Print

Tools