Development

From Things and Stuff Wiki
Revision as of 00:57, 27 August 2014 by Milk (talk | contribs) (→‎Varieties)
Jump to navigation Jump to search


Engineering

See also Organisation#Collaboration









  • 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?

Versioning

Source control

  • Gource is a software version control visualization tool.

VCS

See Git

  • Gource is a software version control visualization tool.

Debugging


DTrace

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_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_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_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/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.

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.

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.

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

Videos

Events

  • Build it, test it, release it, monitor it
  • Google: single tree, development on head, parallel build and tests, cached

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

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)
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!


IDE
Grid
Other



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.

TestLink

Fit

FitNesse

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

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.
  • 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.

Qualifications

Crowdsourced

Documentation


UI markup

UML

XUL

  • XUL (/ˈzuːl/ zool), which stands for XML User Interface Language, is a user interface markup language that is developed by the Mozilla Project. XUL is implemented as an XML dialect; it allows for graphical user interfaces to be written in a similar manner to Web pages.
Retrieved from "https://wiki.thingsandstuff.org/index.php?title=Development&oldid=25976"