Development

From Things and Stuff Wiki
Revision as of 19:27, 19 November 2018 by Milk (talk | contribs) (→‎Build)
Jump to navigation Jump to search


See also Organisation#Collaboration, Process

what a mess

Engineering

See Computing, Computer



Development

See Organisation



  • https://en.wikipedia.org/wiki/Functional_specification - (also, functional spec, specs, functional specifications document (FSD), functional requirements specification, or Program specification) in systems engineering and software development is the documentation that describes the requested behavior of an engineering system. The documentation typically describes what is needed by the system user as well as requested properties of inputs and outputs (e.g. of the software system). A functional specification is the more technical response onto a matching requirements document, e.g. the Product Requirement Document "PRD". Thus it picks up the results of the requirements analysis stage. On more complex systems multiple levels of functional specifications will typically nest to each other, e.g. on the system level, on the module level and on the level of technical details.



Tools

See also Typography#Monospace, WebDev#Authoring, Vim, Git, JS tools, *nix, etc.


Diff and Patches


  • patch(1) - apply a diff file to an original



IDE


  • Lamdu - aims to create a next-generation live programming environment that radically improves the programming experience.






  • KDevelop - A cross-platform IDE for C, C++, Python, QML/JavaScript and PHP


  • CodeLite - an open source, free, cross platform IDE specialized in C, C++, PHP and JavaScript (mainly for backend developers using Node.js) programming languages which runs best on all major Platforms ( OSX, Windows and Linux )

CTags

to sort





  • Formal Methods of Software Design - using mathematics to write error-free programs. The mathematics needed is not complicated; it's just boolean algebra. The word "formal" means the use of a formal language, so that the program logic can be machine checked. Our compilers already tell us if we make a syntax error, or a type error, and they tell us what and where the error is. Formal methods take the next step, telling us if we make a logic error, and they tell us what and where the error is. And they tell us this as we make the error, not after the program is finished. It is good to get any program correct while writing it, rather than waiting for bug reports from users. It is absolutely essential for programs that lives will depend on.



  1. Do you use source control?
  2. Can you make a build in one step?
  3. Do you make daily builds?
  4. Do you have a bug database?
  5. Do you fix bugs before writing new code?
  6. Do you have an up-to-date schedule?
  7. Do you have a spec?
  8. Do programmers have quiet working conditions?
  9. Do you use the best tools money can buy?
  10. Do you have testers?
  11. Do new candidates write code during their interview?
  12. Do you do hallway usability testing?

tef:

  1. "Programmers who know they will make mistakes
  2. "Programmers who think they will not make mistakes"


  • Methods & Tools - Software development magazine: software testing, project management, Agile, Scrum, UML, programming, requirements



  • https://en.wikipedia.org/wiki/Build_automation - the act of scripting or automating a wide variety of tasks that software developers do in their day-to-day activities including things like: compiling computer source code into binary code, packaging binary code, running tests

deploying to production systems, creating documentation and/or release notes




  • Sourcetrail - A cross-platform source explorer for C/C++ and Java. Get productive on unfamiliar source code.

Notebooks

to sort with Maths#Software


  • https://en.wikipedia.org/wiki/Notebook_interface - also called a computational notebook or data science notebook) is a virtual notebook environment used for literate programming. It pairs the functionality of word processing software with both the shell and kernel of that notebook's programming language.

IPython / Jupyter



  • nbviewer - A simple way to share Jupyter Notebooks


  • BeakerX - a collection of kernels and extensions to the Jupyter interactive computing environment. It provides JVM support, interactive plots, tables, forms, publishing, and more.


R Notebook

SageMath

  • SageMath is a free open-source mathematics software system licensed under the GPL. It builds on top of many existing open-source packages: NumPy, SciPy, matplotlib, Sympy, Maxima, GAP, FLINT, R and many more. Access their combined power through a common, Python-based language or directly via interfaces or wrappers.

Mission: Creating a viable free open source alternative to Magma, Maple, Mathematica and Matlab.


People

Methodologies

See also UI, Organisation



FLOSS

See also Free/open


  • https://en.wikipedia.org/wiki/Open-source_software_development - the process by which open-source software, or similar software whose source code is publicly available, is developed. These are software products available with its source code under an open-source license to study, change, and improve its design. Examples of some popular open-source software products are Mozilla Firefox, Google Chromium, Android, LibreOffice and the VLC media player. Open-source software development has been a large part of the creation of the World Wide Web as we know it, with Tim Berners-Lee contributing his HTML code development as the original platform upon which the internet is now built.


  • https://en.wikipedia.org/wiki/Open-source_model - a decentralized software-development model that encourages open collaboration. A main principle of open-source software development is peer production, with products such as source code, blueprints, and documentation freely available to the public. The open-source movement in software began as a response to the limitations of proprietary code. The model is used for projects such as in open-source appropriate technology, and open-source drug discovery.

Open source promotes universal access via an open-source or free license to a product's design or blueprint, and universal redistribution of that design or blueprint. Before the phrase open source became widely adopted, developers and producers used a variety of other terms. Open source gained hold with the rise of the Internet. The open-source software movement arose to clarify copyright, licensing, domain, and consumer issues.

Generally, open source refers to a computer program in which the source code is available to the general public for use or modification from its original design. Open-source code is meant to be a collaborative effort, where programmers improve upon the source code and share the changes within the community. Code is released under the terms of a software license. Depending on the license terms, others may then download, modify, and publish their version (fork) back to the community.





States of growth

  • https://en.wikipedia.org/wiki/Stages_of_growth_model - a theoretical model for the growth of information technology (IT) in a business or similar organization. It was developed by Richard L. Nolan during the 1970s, and described by him in the Harvard Business Review.
  • Initiation
  • Contagion
  • Control
  • Integration
  • Data administration
  • Maturity

QMMG

  • https://en.wikipedia.org/wiki/Quality_Management_Maturity_Grid - an organizational maturity matrix conceived by Philip B. Crosby first published in his book Quality is Free in 1979. The QMMG is used by a business or organization as a benchmark of how mature their processes are, and how well they are embedded in their culture, with respect to service or product quality management. The QMMG is credited with being the precursor maturity model for the Capability Maturity Model (CMM) created a decade later that also has five levels of maturity.

The Quality Management Maturity Grid describes 5 maturity levels through which an organization or business will go through:

  • Uncertainty
  • Awakening
  • Enlightenment
  • Wisdom
  • Certainty


OODA loop

  • https://en.wikipedia.org/wiki/OODA_loop - refers to the decision cycle of observe, orient, decide, and act, developed by military strategist and USAF Colonel John Boyd. Boyd applied the concept to the combat operations process, often at the strategic level in military operations. It is now also often applied to understand commercial operations and learning processes. 1976



CMM




- https://en.wikipedia.org/wiki/CMMI_Version_1.3 - 2010, supports agile


V-Model


Extreme programming (XP)



  • https://en.wikipedia.org/wiki/Sprint_(software_development) - Sprints are organized around the ideas of the Extreme Programming discipline of software development. The sprint is directed by the coach, who suggests tasks, tracks their progress and makes sure that no one is stuck. Most of the development happens in pairs. A large open space is often chosen as a venue for efficient communication. Sprints can vary in focus. During some sprints people new to the project are welcomed and get an intensive hands-on introduction pairing with an experienced project member. The first part of such sprints is usually spent getting ready, presenting the tutorials, getting the network setup and ensuring that configuration/source control software and processes are installed and followed. A significant benefit of sprinting is that the project members meet in person, socialize, and start to communicate more effectively than when working together remotely.


UP / RUP / AUP

  • https://en.wikipedia.org/wiki/Unified_Process - or Unified Software Development Process, is a popular iterative and incremental software development process framework. The best-known and extensively documented refinement of the Unified Process is the Rational Unified Process (RUP). Other examples are OpenUP and Agile Unified Process.


  • https://en.wikipedia.org/wiki/Rational_Unified_Process - an iterative software development process framework created by the Rational Software Corporation, a division of IBM since 2003. RUP is not a single concrete prescriptive process, but rather an adaptable process framework, intended to be tailored by the development organizations and software project teams that will select the elements of the process that are appropriate for their needs. RUP is a specific implementation of the Unified Process.


Agile

"We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:

  • Individuals and interactions over processes and tools
  • Working software over comprehensive documentation
  • Customer collaboration over contract negotiation
  • Responding to change over following a plan

That is, while there is value in the items on the right, we value the items on the left more."






Services;


Scrum



  • Taiga.io - a project management platform for agile developers & designers and project managers who want a beautiful tool that makes work truly enjoyable.

DSDM


DevOps


TDD

BDD

  • Behavior Driven Development - BDD evolved by incorporating what works from Test Driven Development, Agile User Stories, Domain Driven Design and XP with an emphasis on product behavior testing over unit testing. Project stakeholders and team members focus on the problem domain and develop a common language for expressing a product's desired behavior as stories and acceptance test criteria. Developers can then map the stories and criteria on their test code to verify application behavior and report results in the same common language.
  • easyb is a behavior driven development framework for the Java platform. By using a specification based Domain Specific Language, easyb aims to enable executable, yet readable documentation.

DDD

ACC

  • Test Analytics is a Google web application that allows rapid generation of a project's ACC model -- an alterative to a test plan that is faster to create and of more practical value. This decomposition of the product allows a easy way to visualize project risk across project capabilities. In addition, Test Analytics supports importing quality signals -- tests, code changes, and bugs -- to quantify risk and map it across your project's model. This gives a bird's eye view of the risk associated with all areas of your project, and a way to assess what portions of your project need additional testing.

ACC consists of three different parts that define your system under test: Attributes, Components, and Capabilities. An easy way to think of each of these elements is by relating them to a part of speech relating to your project.

  • Attributes (adjectives of the system) are qualities and characteristics that promote the product and distinguish it from the competition; examples are "Fast", "Secure", "Stable", and "Elegant". A product manager could have a hand in narrowing down the list of Attributes for the system.
  • Components (nouns of the system) are building blocks that together constitute the system in question. Some examples of Components are "Firmware", "Printing", and "File System" for an operating system project, or "Database", "Cart", and "Product Browser" for an online shopping site.
  • Capabilities (verbs of the system) describe the abilities of a particular Component in order to satisfy the Attributes of the system. An example Capability for a shopping site could be "Processes monetary transactions using HTTPS". You can see that this could be a Capability of the "Cart" component when trying to meet the "Secure" Attribute. The most important aspect of Capabilities is that they are testable.

Further


  • https://en.wikipedia.org/wiki/Acceptance_test-driven_development - a development methodology based on communication between the business customers, the developers, and the testers. ATDD encompasses many of the same practices as Specification by Example, Behavior Driven Development (BDD), Example-Driven Development (EDD), and Story Test-Driven Development (SDD). All these processes aid developers and testers in understanding the customer’s needs prior to implementation and allow customers to be able to converse in their own domain language. ATDD is closely related to Test-Driven Development. It differs by the emphasis on developer-tester-business customer collaboration. ATDD encompasses acceptance testing, but highlights writing acceptance tests before developers begin coding.


to sort

See also UI

  • https://en.wikipedia.org/wiki/Activity-centered_design - an extension of the Human-centered design paradigm in interaction design. ACD features heavier emphasis on the activities that a user would perform with a given piece of technology. ACD has its theoretical underpinnings in activity theory, from which activities can be defined as actions taken by a user to achieve a goal.

When working with activity-centered design, the designers use research to get insights of the users. Observations and interviews are typical approaches to learn more about the users' behavior. By mapping users' activities and tasks, the designer may notice missing tasks for the activity to become more easy to perform, and thus design solutions to accomplish those tasks.



Creative process - what when one participant doesn't want to use the the same creative process assisting tool workflow, i.e., does not want to use a long term backlog (icebox) for ideas, seeing that as stress inducing? Hiding the backlog is one half-answer, but then they would have to view the backlog to check that their new idea hasn't already been started on by others.


Modelling

  • https://en.wikipedia.org/wiki/Modeling_language - any artificial language that can be used to express information or knowledge or systems in a structure that is defined by a consistent set of rules. The rules are used for interpretation of the meaning of components in the structure.


  • https://en.wikipedia.org/wiki/Object-oriented_modeling - an approach to modeling an application that is used at the beginning of the software life cycle when using an object-oriented approach to software development. The software life cycle is typically divided up into stages going from abstract descriptions of the problem to designs then to code and testing and finally to deployment. Modeling is done at the beginning of the process.
  • https://en.wikipedia.org/wiki/Object-oriented_analysis_and_design - a popular technical approach for analyzing and designing an application, system, or business by applying object-oriented programming, as well as using visual modeling throughout the development life cycles to foster better stakeholder communication and product quality. According to the popular guide Unified Process, OOAD in modern software engineering is best conducted in an iterative and incremental way. Iteration by iteration, the outputs of OOAD activities, analysis models for OOA and design models for OOD respectively, will be refined and evolve continuously driven by key factors like risks and business value.

In 1994, the Three Amigos of Rational Software started working together to develop the Unified Modeling Language (UML). Later, together with Philippe Kruchten and Walker Royce (eldest son of Winston Royce), they have led a successful mission to merge their own methodologies, OMT, OOSE and Booch method, with various insights and experiences from other industry leaders into the Rational Unified Process (RUP), a comprehensive iterative and incremental process guide and framework for learning industry best practices of software development and project management. Since then, the Unified Process family has become probably the most popular methodology and reference model for object-oriented analysis and design.


  • https://en.wikipedia.org/wiki/User_interface_modeling - a development technique used by computer application programmers. Today's user interfaces (UIs) are complex software components, which play an essential role in the usability of an application. The development of UIs requires therefore, not only guidelines and best practice reports, but also a development process including the elaboration of visual models and a standardized notation for this visualization.

USL

  • https://en.wikipedia.org/wiki/Universal_Systems_Language - a modeling language and formal method for the specification and design of software and other complex systems. It was designed by Margaret Hamilton based on her experiences writing flight software for the Apollo program. The language is implemented through the 001 Tool Suite software by Hamilton Technologies, Inc. USL evolved from 001AXES which in turn evolved from AXES all of which are based on Hamilton's axioms of control. The 001 Tool Suite uses the preventative concept of Development Before the Fact (DBTF) for its life-cycle development process. DBTF eliminates errors as early as possible during the development process removing the need to look for errors after-the-fact.

UML

  • https://en.wikipedia.org/wiki/Unified_Modeling_Language - a general-purpose, developmental, modeling language in the field of software engineering, that is intended to provide a standard way to visualize the design of a system. The creation of UML was originally motivated by the desire to standardize the disparate notational systems and approaches to software design. It was developed by Grady Booch, Ivar Jacobson and James Rumbaugh at Rational Software in 1994–1995, with further development led by them through 1996. In 1997 UML was adopted as a standard by the Object Management Group (OMG), and has been managed by this organization ever since. In 2005 UML was also published by the International Organization for Standardization (ISO) as an approved ISO standard. Since then the standard has been periodically revised to cover the latest revision of UML.




UMLet / UMLetino

  • UMLet - a free, open-source UML tool with a simple user interface: draw UML diagrams fast, build sequence and activity diagrams from plain text, export diagrams to eps, pdf, jpg, svg, and clipboard, share diagrams using Eclipse, and create new, custom UML elements. UMLet runs stand-alone or as Eclipse plug-in on Windows, OS X and Linux.
  • UMLetino - a free online UML tool for fast UML diagrams. It runs in your browser, and does not require any installs. It is based on UMLet (which is available as stand-alone tool or Eclipse plugin), and shares its fast, text-based way of drawing UML sketches. Main features: install-free web app; save diagrams in browser storage; support for many UML diagram types; simple, markup-based UML element modifications; png export.


PlantUML

BOUML

  • BOUML - a free UML tool box - a free UML 2 tool box including a modeler allowing you to specify and generate code in C++, Java, Idl, Php, Python and MySQL. Since the release 7.0 BOUML is again a free software. BOUML runs under Windows, Linux and MacOS X. BOUML is very fast and doesn't require much memory to manage several thousands of classes, see benchmark. BOUML is extensible, and the external tools named plug-outs can be written in C++ or Java, using BOUML for their definition as any other program. The code generators, reverses and roundtrips are ones of the pre-defined plug-outs included in the BOUML distribution.

Umbrello

  • Umbrello - a Unified Modelling Language (UML) diagram program based on KDE Technology. UML allows you to create diagrams of software and other systems in a standard format to document or design the structure of your programs.

ArgoUML

  • ArgoUML - the leading open source UML modeling tool and includes support for all standard UML 1.4 diagrams. It runs on any Java platform and is available in ten languages.

Violet

  • Violet - a UML editor with these benefits: Very easy to learn and use. Draws nice-looking diagrams. Completely free. Cross-platform. Violet is intended for developers, students, teachers, and authors who need to produce simple UML diagrams quickly

gaphor


IDEF

  • https://en.wikipedia.org/wiki/IDEF - initially abbreviation of ICAM Definition, renamed in 1999 as Integration DEFinition, refers to a family of modeling languages in the field of systems and software engineering. They cover a wide range of uses, from functional modeling to data, simulation, object-oriented analysis/design and knowledge acquisition. These "definition languages" were developed under funding from U.S. Air Force and although still most commonly used by them, as well as other military and United States Department of Defense (DoD) agencies, are in the public domain. The most-widely recognized and used components of the IDEF family are IDEF0, a functional modeling language building on SADT, and IDEF1X, which addresses information models and database design issues.

Misc. software

UML, BPMN, MDA, SysML, ...


Web


Debugging

To merge with *nix#Debugging / move to Computing







  • https://en.wikipedia.org/wiki/stabs - a debugging data format for storing information about computer programs for use by symbolic and source-level debuggers. (The information is stored in symbol table entries; hence the name "stabs".) It "was apparently invented by Peter Kessler at the University of California, Berkeley" for use with a Pascal compiler. When stabs was created in the 1980s, the dominant object file format was a.out, which (unlike more recent formats such as ELF) makes no provision for storing debugging information. Stabs works around this problem by encoding the information using special entries in the symbol table. At one stage stabs was widely used on Unix systems, but the newer DWARF format has largely supplanted it.
  • https://en.wikipedia.org/wiki/DWARF - a widely used, standardized debugging data format. DWARF was originally designed along with Executable and Linkable Format (ELF), although it is independent of object file formats. The name is a medieval fantasy complement to "ELF" that has no official meaning, although the backronym 'Debugging With Attributed Record Formats' was later proposed.


truss

  • https://en.wikipedia.org/wiki/truss_(Unix) - system tool available on some Unix-like operating systems. When invoked with an additional executable command-line argument, truss makes it possible to print out the system calls made by and the signals received by this executable command-line argument. As of version IEEE Std 1003.1-2008, truss is not part of the Single UNIX Specification (POSIX). The truss command was originally developed by Roger Faulkner and Ron Gomes as part of the development of Procfs for System V Release 4. While several names were considered, “truss” was chosen for being non-ambiguous and easily pronounceable, with multiple meanings, including as an abbreviation for TRace Unix Syscalls and Signals or in the sense of “If your program doesn’t work, put it in a truss.”


gdb



Valgrind

  • Valgrind - an instrumentation framework for building dynamic analysis tools. There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. You can also use Valgrind to build new tools.
    • https://en.wikipedia.org/wiki/Valgrind - a programming tool for memory debugging, memory leak detection, and profiling. Valgrind was originally designed to be a free memory debugging tool for Linux on x86, but has since evolved to become a generic framework for creating dynamic analysis tools such as checkers and profilers.



  • Callgrind / KCachegrind - profiling tool and the profile data visualization Both are licensed under GPL V2. Callgrind uses runtime instrumentation via the Valgrind framework for its cache simulation and call-graph generation. This way, even shared libraries and dynamically opened plugins can be profiled. The data files generated by Callgrind can be loaded into KCachegrind for browsing the performance results. But there is also a command line tool in the package to get ASCII reports from data files without the need to use KCachegrind. The format of Callgrind output is documented here. With conversion scripts, KCachegrind is able to visualize output of other profilers like OProfile, a system-wide profiler for Linux using statistical sampling with hardware performance counters. There also exist converters for profiling output of Python, PHP and PERL.

rr

  • rr - aspires to be your primary C/C++ debugging tool for Linux, replacing — well, enhancing — gdb. You record a failure once, then debug the recording, deterministically, as many times as you want. The same execution is replayed every time. rr also provides efficient reverse execution under gdb. Set breakpoints and data watchpoints and quickly reverse-execute to where they were hit.

QIRA

radare2

  • https://github.com/radare/radare2 - Radare project started as a forensics tool, a scriptable commandline hexadecimal editor able to open disk files, but later support for analyzing binaries, disassembling code, debugging programs, attaching to remote gdb servers, .. r2 is a rewrite from scratch of radare in order to provide a set of libraries and tools to work with binary files.

voltron

  • https://github.com/snare/voltron - an extensible debugger UI toolkit written in Python. It aims to improve the user experience of various debuggers (LLDB, GDB, VDB and WinDbg) by enabling the attachment of utility views that can retrieve and display data from the debugger host. By running these views in other TTYs, you can build a customised debugger user interface to suit your needs. [35]


ftrace

  • Ftrace - an internal tracer designed to help out developers and designers of systems to find what is going on inside the kernel. It can be used for debugging or analyzing latencies and performance issues that take place outside of user-space. Although ftrace is typically considered the function tracer, it is really a frame work of several assorted tracing utilities. There's latency tracing to examine what occurs between interrupts disabled and enabled, as well as for preemption and from a time a task is woken to the task is actually scheduled in.


DTrace

  • https://en.wikipedia.org/wiki/DTrace - a comprehensive dynamic tracing framework created by Sun Microsystems for troubleshooting kernel and application problems on production systems in real time. Originally developed for Solaris, it has since been released under the free Common Development and Distribution License (CDDL) and has been ported to several other Unix-like systems. In December 2012, Oracle announced the general availability of DTrace for Oracle Linux.


strace

ltrace

ktrace

  • https://en.wikipedia.org/wiki/ktrace - a utility included with certain versions of BSD Unix and Mac OS X that traces kernel interaction with a program and dumps it to disk for the purposes of debugging and analysis. Traced kernel operations include system calls, namei translations, signal processing, and I/O. ktrace is somewhat similar to Linux's strace, except for being much faster – with strace, every system call executed by the traced program requires context switch to the tracing program and back, while the tracing with ktrace is actually performed by the kernel, so no additional context switches are required.


KProbes


eBPF / BCC

  • BCC - a toolkit for creating efficient kernel tracing and manipulation programs, and includes several useful tools and examples. It makes use of eBPF (Extended Berkeley Packet Filters), a new feature that was first added to Linux 3.15. Much of what BCC uses requires Linux 4.1 and above. [37]


SystemTap

  • SystemTap - provides free software (GPL) infrastructure to simplify the gathering of information about the running Linux system. This assists diagnosis of a performance or functional problem. SystemTap eliminates the need for the developer to go through the tedious and disruptive instrument, recompile, install, and reboot sequence that may be otherwise required to collect data. SystemTap provides a simple command line interface and scripting language for writing instrumentation for a live running kernel plus user-space applications. We are publishing samples, as well as enlarging the internal "tapset" script library to aid reuse and abstraction. Among other tracing/probing tools, SystemTap is the tool of choice for complex tasks that may require live analysis, programmable on-line response, and whole-system symbolic access. SystemTap can also handle simple tracing jobs.


LTT / LTTng

  • https://en.wikipedia.org/wiki/Linux_Trace_Toolkit - a set of tools that is designed to log program execution details from a patched Linux kernel and then perform various analyses on them, using console-based and graphical tools. LTT has been mostly superseded by its successor LTTng (Linux Trace Toolkit Next Generation).
  • LTTng - an open source tracing framework for Linux.



Apport

  • https://wiki.ubuntu.com/Apport - Apport is a system which: intercepts crashes right when they happen the first time, gathers potentially useful information about the crash and the OS environment, can be automatically invoked for unhandled exceptions in other programming languages (e. g. in Ubuntu this is done for Python), can be automatically invoked for other problems that can be automatically detected (e. g. Ubuntu automatically detects and reports package installation/upgrade failures from update-manager), presents a UI that informs the user about the crash and instructs them on how to proceed, and is able to file non-crash bug reports about software, so that developers still get information about package versions, OS version etc.


coala

  • coala - provides a unified interface for linting and fixing code with a single configuration file, regardless of the programming languages used. You can use coala from within your favorite editor, integrate it with your CI, get the results as JSON, or customize it to your needs with its flexible configuration syntax. [39]


SystemTap

  • SystemTap - provides free software (GPL) infrastructure to simplify the gathering of information about the running Linux system. This assists diagnosis of a performance or functional problem. SystemTap eliminates the need for the developer to go through the tedious and disruptive instrument, recompile, install, and reboot sequence that may be otherwise required to collect data.
    • https://en.wikipedia.org/wiki/SystemTap - a scripting language and tool for dynamically instrumenting running production Linux kernel-based operating systems. System administrators can use SystemTap to extract, filter and summarize data in order to enable diagnosis of complex performance or functional problems.


Senseye

  • https://github.com/letoram/senseye - Dynamic Visual Debugging / Reverse Engineering Toolsuite. a set of data providers, parsers that work with the Arcan display servers IPC subsystem, and as a set of extension script for the Durden desktop environment/window management scheme.


to sort



  • Flame - graphs are a visualization of profiled software, allowing the most frequent code-paths to be identified quickly and accurately. They can be generated using my open source programs on github.com/brendangregg/FlameGraph, which create interactive SVGs. See the Updates section for other implementations.


  • jtool - a command meant to meet and exceed the functionality to XCode's otool(1), picking up along the way additional Mach-O commands such as atos(1), dyldinfo(1), nm(1), segedit(1), pagestuff(1), strings(1) , and even codesign(1) and the informal ldid. jtool also provides novel features, such in-binary search functionality, symbol injection and a disassembler functionality with (limited but constantly improving) emulation capabilities. It also provides color output. Most importantly, it can be run on a variety of platforms - OS X, iOS, and even Linux. It is ENTIRELY FREE for use of any type, and the latest version




  • Forkstat - a program that logs process fork(), exec() and exit() activity. It is useful for monitoring system behaviour and to track down rogue processes that are spawning off processes and potentially abusing the system.




  • https://en.wikipedia.org/wiki/Ptrace - system call found in several Unix and Unix-like operating systems. By using ptrace (the name is an abbreviation of "process trace") one process can control another, enabling the controller to inspect and manipulate the internal state of its target. ptrace is used by debuggers and other code-analysis tools, mostly as aids to software development.








  • Dwarf Home - a debugging file format used by many compilers and debuggers to support source level debugging. It addresses the requirements of a number of procedural languages, such as C, C++, and Fortran, and is designed to be extensible to other languages. DWARF is architecture independent and applicable to any processor or operating system. It is widely used on Unix, Linux and other operating systems, as well as in stand-alone environments.

ProcDump-for-Linux

  • https://github.com/Microsoft/ProcDump-for-Linux - a Linux reimagining of the classic ProcDump tool from the Sysinternals suite of tools for Windows. ProcDump provides a convenient way for Linux developers to create core dumps of their application based on performance triggers. [43]

Version control

  • https://en.wikipedia.org/wiki/Version_control - A component of software configuration management, version control, also known as revision control or source control, is the management of changes to documents, computer programs, large web sites, and other collections of information. Changes are usually identified by a number or letter code, termed the "revision number", "revision level", or simply "revision". For example, an initial set of files is "revision 1". When the first change is made, the resulting set is "revision 2", and so on. Each revision is associated with a timestamp and the person making the change. Revisions can be compared, restored, and with some types of files, merged.

The need for a logical way to organize and control revisions has existed for almost as long as writing has existed, but revision control became much more important, and complicated, when the era of computing began. The numbering of book editions and of specification revisions are examples that date back to the print-only era. Today, the most capable (as well as complex) revision control systems are those used in software development, where a team of people may change the same files.

Version control systems (VCS) most commonly run as stand-alone applications, but revision control is also embedded in various types of software such as word processors and spreadsheets, e.g., Google Docs and Sheets and in various content management systems, e.g., Wikipedia's Page history. Revision control allows for the ability to revert a document to a previous revision, which is critical for allowing editors to track each other's edits, correct mistakes, and defend against vandalism and spamming. Software tools for revision control are essential for the organization of multi-developer projects.



  • https://gitlab.com/esr/reposurgeon - A tool for editing version-control repositories and translating among different systems. Supports git, bzr, Subversion, darcs, and fossil directly, also hg, CVS, and RCS through plugins.


Local file system

old

SCCS / CSSC

  • http://www.gnu.org/software/cssc/ - CSSC is the GNU Project's replacement for SCCS. SCCS is a proprietary suite of tools which is provided with most commercial versions of Unix. The purpose behind CSSC is to provide a work-alike for SCCS which can be used on the various Free versions of Unix.

SCCS was the only major form of source code control on Unix platforms for many years, until RCS came along. SCCS was an effective method for small projects, but these days is less popular, particularly for projects involving large numbers of files. A fair amount of old software is still in SCCS form, and CSSC is designed to retrieve that software. Once retrieved, it is highly recommended to bring the source under the control of more modern source code control systems, such as git or Apache Subversion.

RCS

  • GNU RCS - The Revision Control System (RCS) manages multiple revisions of files. RCS automates the storing, retrieval, logging, identification, and merging of revisions. RCS is useful for text that is revised frequently, including source code, programs, documentation, graphics, papers, and form letters.

RCS design is an improvement from its predecessor Source Code Control System (SCCS) (see GNU CSSC). The improvements include an easier user interface and improved storage of versions for faster retrieval. RCS improves performance by storing an entire copy of the most recent version and then stores reverse differences (called "deltas"). RCS uses GNU Diffutils to find the differences between versions.

Client-server

CVS

SVN

Bazaar

Distributed

BitKeeper

1998 / 2000

Mercurial

2005


Git

2005

See Git

Fossil

2006

Utils

  • webcheckout - check out repositories referenced on a web page
  • Gource is a software version control visualization tool.

Management

  • Kallithea - project of Software Freedom Conservancy, is a GPLv3'd, Free Software source code management system that supports two leading version control systems, Mercurial and Git, and has a web interface that is easy to use for users and admins. You can install Kallithea on your own server and host repositories for the version control system of your choice. [45]
  • Gerrit - provides web based code review and repository management for the Git version control system.


GitHub

  • opml-gen - Generate an OPML file for your starred repositories on GitHub

Build



  • Start-up Tools - Start-ups are always short on time: here are some tools that can save you time and avoid reinventing the wheel. This list is focused on technical tools to save development time.

GNU toolchain




  • Jobserver Implementation - describes the GNU make “jobserver” implementation: it is meant mainly for people who want to understand the GNU make jobserver, but also for those interesting in a traditionally hairy problem in UNIX programming: how to wait for two different types of events (signals and file descriptors) at the same time. [46]


  • Why Not Make? - "Make is a conceptually simple build-system, and it is packaged with major Linux distributions. However, Make should rarely be your build-system of choice when starting a new C++ project.That’s a bold claim, so here’s why…" [47]



Waf

  • https://waf.io - The Waf framework is somewhat different from traditional build systems in the sense that it does not provide support for a specific language. Rather, the focus is to support the major usecases encountered when working on a software project. As such, it is essentially a library of components that are suitable for use in a build system, with an emphasis on extensibility. Although the default distribution contains various plugins for several programming languages and different tools (c, d, ocaml, java, etc), it is by no means a frozen product. Creating new extensions is both a standard and a recommended practice.

xmake

redo

  • Introduction - the _redo_ build system - a competitor to the long-lived, but sadly imperfect, make program. There are many such competitors, because many people over the years have been dissatisfied with make's limitations. However, of all the replacements I've seen, only redo captures the essential simplicity and flexibility of make, while avoiding its flaws. To my great surprise, it manages to do this while being simultaneously simpler than make, more flexible than make, and more powerful than make.

Translation

  • https://en.wikipedia.org/wiki/Internationalization_and_localization - are means of adapting computer software to different languages, regional differences and technical requirements of a target locale. Internationalization is the process of designing a software application so that it can be adapted to various languages and regions without engineering changes. Localization is the process of adapting internationalized software for a specific region or language by adding locale-specific components and translating text. Localization (which is potentially performed multiple times, for different locales) uses the infrastructure or flexibility provided by internationalization (which is ideally performed only once, or as an integral part of ongoing development).


  • Weblate - a free web-based translation tool with tight version control integration. It features simple and clean user interface, propagation of translations across components, quality checks and automatic linking to source files.

Release and deployment





  • Software Package Data Exchange (SPDX)
    • https://en.wikipedia.org/wiki/Software_Package_Data_Exchange - file format used to document information on the software licenses under which a given piece of computer software is distributed. SPDX is authored by the SPDX Working Group, which represents more than twenty different organizations, under the auspices of the Linux Foundation.SPDX attempts to standardize the way in which organizations publish their metadata on software licenses and components in bills of material.


Continuous process

  • https://en.wikipedia.org/wiki/Continuous_design - a software development practice of creating and modifying the design of a system as it is developed, rather than specifying the system completely before development starts, (as in the waterfall model) or in bursts at the beginning of each iteration (as in the iterative model). Also called "evolutionary design" or "incremental design", continuous design was popularized by extreme programming. Continuous design also uses test driven development and refactoring.
  • https://en.wikipedia.org/wiki/Continuous_integration - the practice, in software engineering, of merging all developer working copies with a shared mainline several times a day. It was first named and proposed by Grady Booch in his method, who did not advocate integrating several times a day however. It was adopted as part of extreme programming (XP), which did advocate multiple integrations a day, perhaps as many as tens a day. The main aim of CI is to prevent integration problems, referred to as "integration hell" in early descriptions of XP. CI isn't universally accepted as an improvement over frequent integration, so it is important to distinguish between the two as there is disagreement about the virtues of each

"Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly."


  • https://en.wikipedia.org/wiki/Continuous_delivery - a design practice used in software development to automate and improve the process of software delivery. Techniques such as automated testing, continuous integration and continuous deployment allow software to be developed to a high standard and easily packaged and deployed to test environments, resulting in the ability to rapidly, reliably and repeatedly push out enhancements and bug fixes to customers at low risk and with minimal manual overhead. The technique was one of the assumptions of extreme programming but at an enterprise level has developed into a discipline of its own, with job descriptions for roles such as "buildmaster" calling for CD skills as mandatory.


Jenkins

StriderCD

  • Strider is an Open Source Continuous Deployment / Continuous Integration platform. It is written in Node.JS / JavaScript and uses MongoDB as a backing store. BSD license. A focus on Continuous Deployment rather than just Continuous Integration: Designed to be easy to install & setup. Deployable & usable on Heroku free plan. Intended for deployment on private infrastructure. An emphasis on extensibility. Plugins are powerful, easy to write and simple to install. Out-of-the-box support for projects written in Node.JS, Python (generic and Django/Pyramid) and Selenium/Sauce Labs tests. Commercial support, consulting & hosting available

Git based

Services

  • https://travis-ci.org/ a hosted, distributed continuous integration service used to build and test projects hosted at GitHub. The software is also available as an open source download on GitHub, although its developers do not currently recommend it for on-premise use for closed projects

Testing

  • Errbit - The open source, self-hosted error catcher

Quality



Testing



People

Articles

Books

Information

  • Association for Software Testing - an international non-profit professional association with members in over 50 countries. AST is dedicated and strives to build a testing community that views the role of testing as skilled, relevant, and essential to the production of faster, better, and less expensive software products. We value a scientific approach to developing and evaluating techniques, processes, and tools. We believe that a self-aware, self-critical attitude is essential to understanding and assessing the impact of new ideas on the practice of testing.

Concepts

  • https://en.wikipedia.org/wiki/Test_strategy - an outline that describes the testing approach of the software development cycle. It is created to inform project managers, testers, and developers about some key issues of the testing process. This includes the testing objective, methods of testing new functions, total time and resources required for the project, and the testing environment.

Test strategies describe how the product risks of the stakeholders are mitigated at the test-level, which types of test are to be performed, and which entry and exit criteria apply. They are created based on development design documents. System design documents are primarily used and occasionally, conceptual design documents may be referred to. Design documents describe the functionality of the software to be enabled in the upcoming release. For every stage of development design, a corresponding test strategy should be created to test the new feature sets.

  • https://en.wikipedia.org/wiki/Test_plan - a document detailing a systematic approach to testing a system such as a machine or software. The plan typically contains a detailed understanding of the eventual workflow.
  • https://en.wikipedia.org/wiki/Test_suite - less commonly known as a validation suite, is a collection of test cases that are intended to be used to test a software program to show that it has some specified set of behaviours. A test suite often contains detailed instructions or goals for each collection of test cases and information on the system configuration to be used during testing. A group of test cases may also contain prerequisite states or steps, and descriptions of the following tests.
  • https://en.wikipedia.org/wiki/Test_case - a set of conditions or variables under which a tester will determine whether an application, software system or one of its features is working as it was originally established for it to do. The mechanism for determining whether a software program or system has passed or failed such a test is known as a test oracle. In some settings, an oracle could be a requirement or use case, while in others it could be a heuristic. It may take many test cases to determine that a software program or system is considered sufficiently scrutinized to be released. Test cases are often referred to as test scripts, particularly when written - when they are usually collected into test suites.
  • https://en.wikipedia.org/wiki/Test_harness - or automated test framework is a collection of software and test data configured to test a program unit by running it under varying conditions and monitoring its behavior and outputs. It has two main parts: the test execution engine and the test script repository. Test harnesses allow for the automation of tests. They can call functions with supplied parameters and print out and compare the results to the desired value. The test harness is a hook to the developed code, which can be tested using an automation framework.
  • https://stackoverflow.com/questions/11625351/what-is-test-harness


Varieties

  • https://en.wikipedia.org/wiki/Static_testing - a form of software testing where the software isn't actually used. checks mainly for the sanity of the code, algorithm, or document. It is primarily checking of the code and/or manually reviewing the code or document to find errors. This type of testing can be used by the developer who wrote the code, in isolation. Code reviews, inspections and Software walkthroughs are also used.
  • https://en.wikipedia.org/wiki/Black-box_testing - examines the functionality of an application (e.g. what the software does) without peering into its internal structures or workings. This method of test can be applied to virtually every level of software testing: unit, integration, system and acceptance. It typically comprises most if not all higher level testing, but can also dominate unit testing as well.


  • https://en.wikipedia.org/wiki/Dynamic_testing - dynamic analysis refers to the examination of the physical response from the system to variables that are not constant and change with time. In dynamic testing the software must actually be compiled and run. It involves working with the software, giving input values and checking if the output is as expected by executing specific test cases which can be done manually or with the use of an automated process. This is in contrast to static testing. Unit tests, integration tests, system tests and acceptance tests utilize dynamic testing.










  • https://en.wikipedia.org/wiki/Fuzz_testing - involves providing invalid, unexpected, or random data to the inputs of a computer program. The program is then monitored for exceptions such as crashes, or failing built-in code assertions or for finding potential memory leaks. Fuzzing is commonly used to test for security problems in software or computer systems. It is a form of random testing which has been used for testing hardware or software.





  • https://en.wikipedia.org/wiki/Exploratory_testing - an approach to software testing that is concisely described as simultaneous learning, test design and test execution. Cem Kaner, who coined the term in 1983, now defines exploratory testing as "a style of software testing that emphasizes the personal freedom and responsibility of the individual tester to continually optimize the quality of his/her work by treating test-related learning, test design, test execution, and test result interpretation as mutually supportive activities that run in parallel throughout the project."

While the software is being tested, the tester learns things that together with experience and creativity generates new good tests to run. Exploratory testing is often thought of as a black box testing technique. Instead, those who have studied it consider it a test approach that can be applied to any test technique, at any stage in the development process. The key is not the test technique nor the item being tested or reviewed; the key is the cognitive engagement of the tester, and the tester's responsibility for managing his or her time.

  • https://en.wikipedia.org/wiki/Session-based_testing - a software test method that aims to combine accountability and exploratory testing to provide rapid defect discovery, creative on-the-fly test design, management control and metrics reporting. The method can also be used in conjunction with scenario testing. Session-based testing was developed in 2000 by Jonathan and James Bach. Session-based testing can be used to introduce measurement and control to an immature test process and can form a foundation for significant improvements in productivity and error detection. Session-based testing can offer benefits when formal requirements are not present, incomplete, or changing rapidly.
  • https://en.wikipedia.org/wiki/Error_guessing - a test method in which test cases used to find bugs in programs are established based on experience in prior testing. The scope of test cases usually rely on the software tester involved, who uses past experience and intuition to determine what situations commonly cause software failure, or may cause errors to appear.
  • https://en.wikipedia.org/wiki/Scenario_testing - a software testing activity that uses scenarios: hypothetical stories to help the tester work through a complex problem or test system. The ideal scenario test is a credible, complex, compelling or motivating story the outcome of which is easy to evaluate. These tests are usually different from test cases in that test cases are single steps whereas scenarios cover a number of steps. Kaner coined the phrase scenario test by October 2003. He commented that one of the most difficult aspects of testing was maintaining step-by-step test cases along with their expected results. His paper attempted to find a way to reduce the re-work of complicated written tests and incorporate the ease of use cases.
  • https://en.wikipedia.org/wiki/Scenario_(computing)
  • https://en.wikipedia.org/wiki/Functional_testing - a quality assurance (QA) process and a type of black box testing that bases its test cases on the specifications of the software component under test. Functions are tested by feeding them input and examining the output, and internal program structure is rarely considered (not like in white-box testing). Functional testing differs from system testing in that functional testing "verifies a program by checking it against ... design document(s) or specification(s)", while system testing "validate[s] a program by checking it against the published user or system requirements"
  • https://en.wikipedia.org/wiki/Non-functional_testing - testing of a software application for its non-functional requirements. The names of many non-functional tests are often used interchangeably because of the overlap in scope between various non-functional requirements. For example, software performance is a broad term that includes many specific requirements like reliability and scalability.

Agile;

Unit testing

  • https://en.wikipedia.org/wiki/Unit_testing - testing method by which individual units of source code, sets of one or more computer program modules together with associated control data, usage procedures, and operating procedures are tested to determine if they are fit for use. Intuitively, one can view a unit as the smallest testable part of an application. In procedural programming, a unit could be an entire module, but it is more commonly an individual function or procedure. In object-oriented programming, a unit is often an entire interface, such as a class, but could be an individual method. Unit tests are short code fragments created by programmers or occasionally by white box testers during the development process. Ideally, each test case is independent from the others. Substitutes such as method stubs, mock objects, fakes, and test harnesses can be used to assist testing a module in isolation. Unit tests are typically written and run by software developers to ensure that code meets its design and behaves as intended.
  • http://c2.com/cgi/wiki?UnitTest

Videos

Basics;

RBCS INC;

to check later;

Events

Software

See also WebDev#Testing

xUnit

  • https://en.wikipedia.org/wiki/xUnit - the collective name for several unit testing frameworks that derive their structure and functionality from Smalltalk's SUnit. SUnit, designed by Kent Beck in 1998, was written in a highly-structured object-oriented style, which lent easily to contemporary languages such as Java and C#. Following its introduction in Smalltalk the framework was ported to Java by Beck and Erich Gamma and gained wide popularity, eventually gaining ground in the majority of programming languages in current use.
  • JUnit is a simple framework to write repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks.
  • TestDox creates simple documentation from the method names in JUnit test cases.

TestNG

Fit

FitNesse

JSUnit

  • JsUnit is a Unit Testing framework for client-side (in-browser) JavaScript. It is essentially a port of JUnit to JavaScript. Also included is a platform for automating the execution of tests on multiple browsers and mutiple machines running different OSs. Its development began in January 2001, not actively developed or supported.

Waitr

  • Watir - pronounced water, is an open-source (BSD) family of Ruby libraries for automating web browsers. It allows you to write tests that are easy to read and maintain. It is simple and flexible. Watir drives browsers the same way people do. It clicks links, fills in forms, presses buttons. Watir also checks results, such as whether expected text appears on the page. Watir is a family of Ruby libraries but it supports your app no matter what technology it is developed in. Whilst Watir supports only Internet Explorer on Windows, Watir-WebDriver supports Chrome, Firefox, Internet Explorer, Opera and also running in headless mode (HTMLUnit). Like other programming languages, Ruby gives you the power to connect to databases, read data files and spreadsheets, export XML, and structure your code as reusable libraries.
  • WatiN - Web Application Testing In .Net. Inspired by Watir development of WatiN started in December 2005 to make a similar kind of Web Application Testing possible for the .Net languages

Selenium

  • Selenium is a portable software testing framework for web applications. Selenium provides a record/playback tool for authoring tests without learning a test scripting language (Selenium IDE). It also provides a test domain-specific language (Selenese) to write tests in a number of popular programming languages, including C#, Java, Groovy, Perl, PHP, Python and Ruby. The tests can then be run against most modern web browsers.
Videos
Selenium 1 (Remote Control)
  • Bromine is an open source QA tool that uses selenium RC as its testing engine.
Selenium 2 (WebDriver)
  • http://webdriver.io/ WebdriverJS is an open source testing utility for nodejs. It makes it possible to write super easy selenium tests with Javascript in your favorite BDD or TDD test framework. Even Cucumber tests are supported. It basically sends requests to a Selenium server via the WebDriver Wire Protocol and handles with its response. These requests are wraped in useful commands, which provides callbacks to test several aspects of your site in an automated way.
  • Selendroid is a test automation framework which drives off the UI of Android native and hybrid applications (apps) and the mobile web. Tests are written using the Selenium 2 client API - that's it!


Grid
IDE
Builder
Mobile
  • Selendroid is a test automation framework which drives off the UI of Android native and hybrid applications (apps) and the mobile web. Tests are written using the Selenium 2 client API - that's it!
  • ios-driver - Test any IOS native, hybrid, or mobile web application using Selenium / WebDriver.
Other
  • Galen is a test framework originally designed for testing layout of web applications but is also a great tool for functional testing. When it comes to testing a responsive layout it works in a following way: Open a page in browser, Resize it to specified size, Test the layout according to user-defined specs. It uses Selenium for interacting with elements on page and getting their locations and dimensions.
Services

Cucumber

  • Cucumber lets software development teams describe how software should behave in plain text. The text is written in a business-readable domain-specific language and serves as documentation, automated tests and development-aid - all rolled into one format. Cucumber works with Ruby, Java, .NET, Flex or web applications written in any language. Cucumber also supports more succinct tests in tables - similar to what FIT does. Dig around in the examples and documentation to learn more about Cucumber tables. Cucumber is the RSpec Story Runner done right.

Jasmine

  • Jasmine is a Behavior Driven Development testing framework for JavaScript. It does not rely on browsers, DOM, or any JavaScript framework. Thus it's suited for websites, Node.js projects, or anywhere that JavaScript can run.

TestLink

Other

  • Concordion - an open source tool for writing automated acceptance tests in Java (and .NET, Python, Scala, and Ruby).
  • Test Recorder - The purpose of the application is to generate code compatible with several applications, including WatiN (Web Application Testing In .NET), Celerity, and WatiR.
  • Window Licker - A framework for the test-driven development of Java systems through the GUI.
  • RSpec is testing tool for the Ruby programming language. Born under the banner of Behaviour-Driven Development, it is designed to make Test-Driven Development a productive and enjoyable experience
  • HtmlUnit is a "GUI-Less browser for Java programs". It models HTML documents and provides an API that allows you to invoke pages, fill out forms, click links, etc... just like you do in your "normal" browser. HtmlUnit is not a generic unit testing framework. It is specifically a way to simulate a browser for testing purposes and is intended to be used within another testing framework such as JUnit or TestNG.
  • JWebUnit is a Java-based testing framework for web applications. It wraps existing testing frameworks such as HtmlUnit and Selenium with a unified, simple testing interface to allow you to quickly test the correctness of your web applications.
  • Webrat lets you quickly write expressive and robust acceptance tests for a Ruby web application.
  • Windmill is a web testing tool designed to let you painlessly automate and debug your web application.

Originating at the Open Source Applications Foundation Windmill was built to help QA keep up with the rapid release cycles of the Chandler Server Web UI (Cosmo) project.

  • CubicTest is a graphical Eclipse plug-in for writing Selenium and Watir tests. It makes tests faster and easier to write, and provides abstractions to make tests more robust and reusable. CubicTest's test editor is centered around pages/states and transitions between these pages/states. The model is intuitive for both Ajax and traditional web applications and supports most user interaction types.
  • Robot Framework is a generic test automation framework for acceptance testing and acceptance test-driven development (ATDD). It has easy-to-use tabular test data syntax and it utilizes the keyword-driven testing approach. Its testing capabilities can be extended by test libraries implemented either with Python or Java, and users can create new higher-level keywords from existing ones using the same syntax that is used for creating test cases.


  • Marionette is an automation driver. It can remotely drive either the UI or the internal JavaScript of a program built on the Gecko platform, such as Firefox or Firefox OS. Marionette runs as a server on your test machine, allowing you to connect to that server and remotely drive tests and send commands. Its goal is to replicate what Selenium does for the browser: to enable the tester to have the ability to send commands to a remote test machine. Marionette shares much of the same API as Selenium/WebDriver, and makes writing tests easy. You have the API to drive user actions like page navigation and element clicking, but also the ability to execute arbitrary JavaScript scripts, allowing for a greater variety of tests.




  • TUT is a small and portable unit test framework for C++.
  • UnitTest++ is a lightweight unit testing framework for C++.
  • Bandit is a framework for C++11 that wants to make working with unit tests a pleasant experience.
  • Snowhouse is a stand alone assertion framework for C++. It was originally developed as part of Igloo and has been extracted to be usable in other contexts.
  • cute - C++ unit test executor
  • Catch - A modern, C++-native, header-only, framework for unit-tests, TDD and BDD [53]






Qualifications

Crowdsourced

Documentation



  • Read the Docs - hosts documentation for the open source community. We support Sphinx docs written with reStructuredText and CommonMark. We pull your code from your Subversion, Bazaar, Git, and Mercurial repositories. Then we build documentation and host it for you. Think of it as Continuous Documentation.


Retrieved from "https://wiki.thingsandstuff.org/index.php?title=Development&oldid=48318"