Testable requirements is a new paradigm for measuring of the size of a system. One way to illustrate the differences between lines of code, function points and testable requirements is to look at how each would compare a system developed using a character-based user interface (e.g., DOS, 3270 mainframe), and the equivalent system developed using a graphical user interface (e.g., Windows).
LOC perspective: It would be very hard to make a comparison using LOC because of the differences in the way the interfaces are developed. Since the "language" used to code screen or window functionality is not procedural, it is very difficult to measure LOC, let alone make valid comparisons between two different technical platforms.
Function Point Perspective: Function points would consider them equivalent since they are providing the same functionality to the user (e.g., the same number of logical inputs and outputs). The value adjustment factor could be used to make the GUI a higher function point count. (The value adjustment factor is essentially a complexity factor used to adjust a raw function point count because of factors related to the complexity of the system.)
Testable Requirements Perspective: Testable requirements would give a much higher count to a graphical user interface (GUI) than its character-based equivalent. There are simply more conditions (i.e., testable requirements) that are supported by a GUI than are supported by a character-based interface. For example, there is usually only one way to enter a command in a character-based interface - through the menu. In the equivalent GUI, there are usually at least three - the menu, the keyboard, and the icon.
Testable requirements can also be used to measure and analyze a system in ways that are not possible with other measures. Because testable requirements can measure external user requirements as well as internal technical requirements, it is possible not only to size the user requirements, but also to quantify their impact on the technical design. Performance requirements, for example, may contribute relatively few testable requirements when viewed from an end user perspective. The performance requirements may, however, require a complex real time technical design to meet the requirements and therefore require many testable requirements when viewed from a technical perspective.
Similarly, some types of systems such as process control and scientific systems may have relatively few external requirements, but have a very complicated internal technical design. The testable requirements paradigm does not require a complexity factor to account for this. Rather the complexity will manifest itself in the size of the design or the size of individual programs. Complexity, in essence, means that there are more testable requirements somewhere.