Adventures in Session-Based Testing
The Fire Hose
Below is a list of articles on software development, software engineering and software testing. Some of the articles are old and have historic value. The list contains classics such as No Silver Bullet by Brooks, Design and Code Inspections by Fagan or Software Engineering by Boehm. Others are new and treat topical subjects.
The list is published for a number reasons.
- All of the articles below can be found on the internet in PDF format. There are a lot of articles (and knowledge) locked behind the paid subscriptions of for example the ACM or the IEEE. The articles below are available to every software professional.
- Because they are articles they focus mainly on a single topic and can be read in a lot less time than for example a book. This makes it easier to access the knowledge contained.
- The articles offer a wide range of perspectives on software development. I did not limit myself to software testing or to a certain school of thought.
The Agile Manifesto
The Agile Methods Fray
An Analysis and Survey of the Development of Mutation Testing
Avoiding Classic Mistakes
Beyond the Productivity Paradox
Biting the Silver Bullet
Both Sides Always Lose:
Brooks’ Law Repealed
Bug Taxonomies: Use Them to Generate Better Tests
The Case against ISO 9000
The Category Partition Method for Specifying and Generating Functional Tests
Characterizing the Software Process
Classic Testing Mistakes
Climbing over the No Silver Bullet Brick Wall
Comparing the Effectiveness of Software Testing Strategies
A Complexity Measure
Continuous Care Vs. Initial Design
Continuous Care Vs. Initial Design
Cornering the Chimera
Crisis, What Crisis?
Critical-Path Planning and Scheduling
The Darker Side of Metrics
Data Structure Diagrams
Design and Code Inspections to Reduce Errors in Program Development
Efficient Testing with All-Pairs
An Engineering Context for Software Engineering
Escaping the Software Tar Pit
An Evaluation of the MOOD Set of Object-Oriented Software Metrics
Exhausting Your Test Options
Exploratory Testing Dynamics
Exploratory Testing Explained
Facing Up to Faults
The Factors of Function Testing
The Five Orders of Ignorance
Five Reasons for Scenario-Based Design
The Forgotten Phase
Four Exercises for Teaching Exploratory Testing
The Goal Question Metric Approach
The Growth of Software Testing
Handling Combinatorial Explosion in Software Testing
Heuristic Test Strategy Model
Historical Roots of Agile Methods
The histories of computing(s)
The History of Computing in the History of Technology
A History of Software Inspections
How Software Project Risk Affects Project Performance
The Ideal Collaborative Team
Industrial Software Metrics
An Introduction to Scenario Testing
The Irrational Tester
Is Software Engineering Engineering?
IT Doesn’t Matter
IT Failure Rates
Iterative and Incremental Development: A Brief History
Keep It Simple
Keeping Software Soft
Laws of Software Evolution Revisited
Lessons Learned from Modeling the Dynamics of Software Development
The Logic of Correctness in Software Engineering
Managing the Development of Large Software Systems
Measuring Application Development Productivity
A Metrics Suite for Object Oriented Design
A Model to Assess Testing Process Maturity
Modeling Software Defect Introduction and Removal
Mutation 2000
New Models for Test Development
The New New Product Development Game
No Silver Bullet
On the Criteria To Be Used in Decomposing Systems into Modules
On the Testing Maturity of Software Producing Organizations
One More Time: How Do You Motivate Employees
The Ongoing Revolution in Software Testing
A Positive View of Negative Testing
Proactive Testing
Process Evolution in a Mad World
Process Models in Software Engineering
The Productivity Paradox of Information
Technology
Program Testing
Programmer Performance and the Effects of the Workplace
Project Management Tools and Software Failures and Successes
Pulling the Plug, Software Project Management and the Problem of Project Escalation
Quantifying Soft Factors
A Rational Design Process: How and Why to Fake It
The Real Problem with Computers
Requirements Elicitation – What’s Missing?
Research in Software Engineering
Rethinking Lean Service
Rethinking Software Metrics
The Revealing Power of a Test Case
Reverse Engineering and Design Recovery
The Rise and Fall of the Chaos Report Figures
The Roots of Software Engineering
Session-Based Test Management
Short-Term and Long-Term Remedies for Runaway Projects
Soap Opera Testing
Software Aging
Software Aspects of Strategic Defense Systems
Software Defect Reduction Top 10 List
Software Economics
Software Engineering
Software Engineering
Software Engineering Economics
Software Engineering Metrics: What Do They
Measure and How Do We Know?
Software Project Management Practices: Failure Versus Success
Software Quality: the Elusive Target
Software's Chronic Crisis
Some Future Trends and
Some Future Trends and Implications for Systems and Software Engineering Processes
A Spiral Model of Software Development and Enhancement
Strategies for Managing Requirements Creep
A Taxonomy for Test Oracles
Ten Things You Might Not Know
Test Automation Snake Oil
Test Case Design Using Classification Trees
Testers and Developers Think Differently
Testing Without a Map
Things Testers Miss
Toward a Theory of Test Data Selection
Towards a Constructive Quality Model
Twelve Tough Questions
Unskilled and Unaware of It
Users We Don’t Like
Users, Roles, and Personas
Using a Defined and Measured Personal Software Process
What Do Users Want?
What Is a Good Test Case?
What Is Software Design?
What Is Software Testing? And Why Is It So Hard?
What Not to Test
What Software Reality Is Really About
What’s Wrong with Risk Matrices?
When Should a Test Be Automated?
Where in the World?
Why Software Projects Escalate