In everything we do, whether writing tests, writing production code, or refactoring, we keep the system executing at all times.

TDD
Test-driven development (TDD) (Beck 2003; Astels 2003), is an evolutionary approach to development which combines test-first development where you write a test before you write just enough production code to fulfill that test and refactoring. What is the primary goal of TDD? One view is the goal of TDD is specification and not validation (Martin, Newkirk, and Kess 2003). In other words, it’s one way to think through your requirements or design before your write your functional code (implying that TDD is both an important agile requirements and agile design technique). Another view is that TDD is a programming technique. As Ron Jeffries likes to say, the goal of TDD is to write clean code that works. I think that there is merit in both arguments, although I lean towards the specification view, but I leave it for you to decide. -
See more at: http://www.agiledata.org/essays/tdd.html#sthash.pBl2wdQN.dpuf

The Three Laws of Test Driven Development (TDD)
===============================================
By now everyone knows that TDD asks us to write unit tests first,before we write production code. But that rule is just the tip of the iceberg. Consider the following three laws:
First Law: You may not write production code until
you have written a *failing* unit test.
Second Law: You may not write more of a unit test than is
sufficient to fail, and not compiling is failing.
Third Law: You may not write more production code than
is sufficient to pass the current failing test.


-----------------------------------------------------------------------------------------
Well, what I meant by "mission critical" is that a bug in the software would result in the loss of primary mission functionality. We used several daemons written in Perl, running onboard the instrument in flight, to control data acquisition and instrument configuration.
by Dr. Zowie on Aug 26, 2010 at 15:31 UTC
http://www.perlmonks.org/?node_id=857358
--------------------------------------------------------------------------------------
Why code review beats testing: evidence from decades of programming research
“If you want to ship high quality code, you should invest in more than one of formal code review, design inspection, testing, and quality assurance. Testing catches fewer bugs per hour than human inspection of code, but it might be catching different types of bugs.”

No one approach to bug detection is adequate. Capers Jones – the researcher behind two of the papers McConnell cites – divides bug detection into four categories: formal design inspection, formal code inspection, formal quality assurance, and formal testing. The best bug detection rate, if you are only using one of the above four categories, is 68%. The average detection rate if you are using all four is 99%.

------------------------------------------------------------------------------------------------
Disciplined Agile Delivery - DAD
------------------------------------------------------------------------------------------------
The DAD process framework adopts strategies from the following methods:

1. Scrum:
The focus of Scrum is on project leadership and some aspects of requirements management. DAD adopts and tailors many ideas from Scrum, such as working from a stack of work items in priority order, having a product owner responsible for representing stakeholders, and producing a potentially consumable solution from each iteration. However, DAD abandoned most of Scrum’s terminology—nobody sprints
through a race, people get hurt in rugby scrums, and don’t get us going on the term “master”—with the exception of the term product owner.

2. Extreme programming (XP):
XP is an important source of development practices for DAD, including but not limited
to continuous integration (CI), refactoring, test-driven development (TDD), collective ownership, and many more.

3. Agile Modeling (AM):
As the name implies, AM is the source for DAD’s modeling and documentation practices.
This includes requirements envisioning, architecture envisioning, iteration modeling, continuous documentation, and just-in-time (JIT) model storming.

4. Unified Process (UP):
DAD adopts many of its governance strategies from agile instantiations of the UP, including OpenUP and Agile Unified Process (AUP). In particular, this includes strategies such as having light-weight milestones and explicit phases. We also draw from the Unified Process’ focus on the importance of proving out the architecture in the early
iterations and reducing all types of risk early in the life cycle.

5. Agile Data (AD):
As the name implies AD is a source of agile database practices, such as database refactoring, database testing, and agile data modeling. It is also an important source of
agile enterprise strategies, such as how agile teams can work effectively with enterprise architects and enterprise data administrators.

6. Kanban:
DAD adopts two critical concepts—limiting work in progress and visualizing work—from Kanban, which is a lean framework. These concepts are in addition to the seven prin-
ciples of lean software development (eliminate waste, build in quality, create knowledge, defer commitment, deliver quickly, respect people, and optimize the whole).

------------------------------------------------------------------------------------------
Data First
------------------------------------------------------------------------------------------
Quality data sources. Your production data sources, including files, databases, and data feeds, should be high quality assets that are easy to work with. When it comes to data sources of record it is particularly important for them to be of high quality so that they are easy to work with and evolve. Unfortunately this is often little more than fanciful thinking in many organizations. With a Disciplined DevOps mindset teams realize that they should be very careful about increasing the technical debt within their data sources, and more importantly invest in the effort to pay down any technical debt that they find.

----------------------------------------
Data related Functional Requirements
----------------------------------------
Are all the inputs to the system specified, including their source, accuracy, range of values, and frequency?
Are all the outputs from the system specified, including their destination, accuracy, range of values, frequency, and format?
Are all output formats specified for logs, Web pages, reports, and so on?
Are all data interfaces specified?
Are all the external communication interfaces specified, including handshaking, error-checking, and communication protocols?
Are all the tasks the user wants to perform specified?
Is the data used in each task and the data resulting from each task specified?
Are all constrained data properties well specified?
Are all system and subsystem dependencies well specified?

-----------------------------
DATA AT THE BEGINNING
-----------------------------
At the beginning it is good to be focused on DATA, all files in the system: structured and non structured data, input data, output data, error logs, configuration files, etc. A database as a collection of related information and their data records structure.
And what must be done in order to process input files into desired output behaviour and data. What are the test scenarios, and if the customer has provided production-quality test data together with requirements? Is it possible to provide realistic production data sets upfront for the future system?
---------------------------------------
• Create the user manual upfront
---------------------------------------
Some organizations have had good success creating their user manuals as a substitute for or supplement to a traditional requirements specification. End users and customers, seem to be better able to understand the contents of a user manual than a traditional requirements specification, and requirements elicitation goes then more smoothly.