TDD - A Reminder of the Principles
•
2 likes•200 views
This document discusses the principles of test-driven development (TDD). It explains that TDD involves specifying an application programming interface (API) through tests before implementing it to prove correctness. The core cycle of TDD is described as red-green-refactor, where tests are written (red), made to pass (green), and code is refactored for maintainability. Common structures for unit tests, advantages of TDD, and heuristics for the process are also outlined, along with examples of coding katas and how to set up a project and run unit tests.
Report
Share
Report
Share
Download to read offline
Recommended
Continuously testing govt.nz - DevOpsDays Ignite Wellington 2018
The document discusses how the Department of Internal Affairs GIS implemented Specification by Example, BeHat, and CircleCI to enable continuous testing of govt.nz. It outlines challenges with their previous workflow including a lack of automated testing. Their new process involves specifying features using Gherkin syntax to create executable test cases. This allows for continuous integration where code commits trigger unit and behavior tests to report results.
Programming katas for Software Testers - CounterStrings
What would be suitable Code Katas for people wanting to learn how to code to support their testing?
CounterStrings
- `*3*5*7*9*12*15*`
A CounterString is a string like this `*3*5*7*9*12*15*` where the `*` represent the position in the string of the number immediately proceeding it. This is a 15 character CounterString.
These are useful because if you paste them into a field, and are truncated then it is easy to see what they were truncated to, it is as James Bach describes it, self documenting test data.
https://www.eviltester.com/blog/eviltester/2019-02-27-programming-katas-for-testers/
Test Driven Development Methodology and Philosophy
A technique for building software that guides software development by writing tests. This is the philosophy and state of mind that a developer should change and start following TDD
Test with Spock like the first officer
This document introduces Spock, a testing framework for Groovy. Spock aims to make tests read more like specifications by using a given-when-then structure. An example test written in Spock checks that a calculator adds two numbers correctly. The document suggests Spock provides tests with less boilerplate code and a more natural language style compared to other testing frameworks.
Test Driven
Want to know the case for Test-Driven Development? Want to know style tips and gotchas for Testing and TDD? Let Alex Chaffee, former Mad Scientist at Pivotal Labs, tell you everything you didn't know you didn't know about testing.
Agile testing
The document discusses principles and practices of agile testing. It outlines the roles of testers in an agile environment, including enabling communication, delivering value, and providing continuous feedback. It also describes testing activities over the course of a sprint like creating test cases during planning, performing manual and automated testing during development, and regression testing before finalizing each sprint. The document advises stopping testing when time runs out, the project becomes too buggy, or testing objectives are complete. It stresses the importance of testing before any live deployment.
Tdd in php a brief example
The document discusses Test Driven Development (TDD) in PHP. It provides an overview of TDD, the benefits it provides like high cohesion and loose coupling, and some drawbacks. It then demonstrates a live coding example of TDD in PHP by building a simple integer calculator using PHPUnit for a math tutor application. Resources for learning more about TDD, PHPUnit, and Xdebug are also included.
通往測試最高殿堂的旅程 - GTAC 2016
The Google Test Automation Conference (GTAC) is an annual test automation conference hosted by Google. 2016 is 10th GTAC. I'll share the most impressive parts of experience sharing & tool I heard in GTAC 2016 in this slide.
Recommended
Continuously testing govt.nz - DevOpsDays Ignite Wellington 2018
The document discusses how the Department of Internal Affairs GIS implemented Specification by Example, BeHat, and CircleCI to enable continuous testing of govt.nz. It outlines challenges with their previous workflow including a lack of automated testing. Their new process involves specifying features using Gherkin syntax to create executable test cases. This allows for continuous integration where code commits trigger unit and behavior tests to report results.
Programming katas for Software Testers - CounterStrings
What would be suitable Code Katas for people wanting to learn how to code to support their testing?
CounterStrings
- `*3*5*7*9*12*15*`
A CounterString is a string like this `*3*5*7*9*12*15*` where the `*` represent the position in the string of the number immediately proceeding it. This is a 15 character CounterString.
These are useful because if you paste them into a field, and are truncated then it is easy to see what they were truncated to, it is as James Bach describes it, self documenting test data.
https://www.eviltester.com/blog/eviltester/2019-02-27-programming-katas-for-testers/
Test Driven Development Methodology and Philosophy
A technique for building software that guides software development by writing tests. This is the philosophy and state of mind that a developer should change and start following TDD
Test with Spock like the first officer
This document introduces Spock, a testing framework for Groovy. Spock aims to make tests read more like specifications by using a given-when-then structure. An example test written in Spock checks that a calculator adds two numbers correctly. The document suggests Spock provides tests with less boilerplate code and a more natural language style compared to other testing frameworks.
Test Driven
Want to know the case for Test-Driven Development? Want to know style tips and gotchas for Testing and TDD? Let Alex Chaffee, former Mad Scientist at Pivotal Labs, tell you everything you didn't know you didn't know about testing.
Agile testing
The document discusses principles and practices of agile testing. It outlines the roles of testers in an agile environment, including enabling communication, delivering value, and providing continuous feedback. It also describes testing activities over the course of a sprint like creating test cases during planning, performing manual and automated testing during development, and regression testing before finalizing each sprint. The document advises stopping testing when time runs out, the project becomes too buggy, or testing objectives are complete. It stresses the importance of testing before any live deployment.
Tdd in php a brief example
The document discusses Test Driven Development (TDD) in PHP. It provides an overview of TDD, the benefits it provides like high cohesion and loose coupling, and some drawbacks. It then demonstrates a live coding example of TDD in PHP by building a simple integer calculator using PHPUnit for a math tutor application. Resources for learning more about TDD, PHPUnit, and Xdebug are also included.
通往測試最高殿堂的旅程 - GTAC 2016
The Google Test Automation Conference (GTAC) is an annual test automation conference hosted by Google. 2016 is 10th GTAC. I'll share the most impressive parts of experience sharing & tool I heard in GTAC 2016 in this slide.
Python3.6 and asynchronous programming
This document discusses asynchronous programming in Python 3.6 using async and await. It covers coroutines, event loops, asynchronous programming techniques, and libraries like asyncio and curio. The document argues that asynchronous programming produces more readable and efficient code compared to multithreading, as event loops can schedule coroutine execution in a non-predetermined order based on I/O availability.
Comparison of static code analyzers: CppCat, Cppcheck, PVS-Studio and Visual ...
We have carried out a thorough comparison of four analyzers for C/C++ code: CppCat, Cppcheck, PVS-Studio and Visual Studio's built-in analyzer. It is a serious, large investigation that we had spent about 170 man-hours on and which, in our opinion, gives a good idea of the general state of things in static analysis nowadays.
Do you have a #bug? Your unit tests are not well planned
Llevo cierto tiempo profundizando en tratar de entender por qué muchas organizaciones o equipos no consiguen sacarle partido a la automatización del testing. Todos conocemos de sobra la pirámide de tests descrita por Mike Cohn en su libro “Succeeding with Agile” en la que describe lo importante que es tener un balance adecuado entre tests end-to-end, tests de integración y tests unitarios. Existen cientos de artículos hablando sobre esto y está claro que la teoría tanto la conocemos como la compartimos pero, ¿cómo podemos llevarla a cabo? La clave está en conseguir hacer unos buenos tests unitarios.
En esta charla compartiré de forma gráfica, con ejemplos sencillos, números y referencias la manera de conseguir que tus tests unitarios no sólo te ayuden a mejorar la calidad interna del producto, sino también su calidad externa y, por lo tanto, consigas un retorno de la inversión (ROI) que lo haga sostenible.
Checking the Source SDK Project
The Source SDK is a software development kit compiled by Valve Corporation that is used to create games or mods for the Source engine. I downloaded and checked the project's source codes at the end of 2013 already and intended to write an article about it during the New Year holidays. But laziness prevailed over the craving for creativity, and I sat down to writing the article only on getting back to work. However, I doubt that the source codes have changed during this time. Now you are welcome to have a look at the suspicious code fragments found in the project code by the PVS-Studio code analyzer.
So Your OpenStack Cloud is Built...Now What?
This document discusses automating OpenStack cloud administration tasks. It begins by reviewing common cloud decisions and day-to-day operator tasks. It then discusses how OpenStack and automation work well together and considerations for automating tasks. Several examples of automating tasks like creating users/projects and health monitoring are provided. It emphasizes adopting an "Administration DevOps" approach to automate operations and make the cloud more scalable and efficient.
Ddc2011 효과적으로레거시코드다루기
The document discusses techniques for effectively working with legacy code. It recommends starting by finding small parts of legacy code that can be tested without making big changes. Then use those tests to safely extend design changes. When new features are needed, change a little code and add some tests to the affected areas. This spreads tests throughout the legacy code over time. The document also provides examples of refactoring techniques like extract method, sprout method, characterization tests, subclassing and overriding methods, and extracting method objects to untangle legacy code in a safe, test-driven way.
100 tests per second - 40 releases per week
This talk shows how the Triggerz engineering team continuously deliver new software versions to our users.
The Triggerz product is a web application built with React, Node.js and PostgreSQL. The product has been live since October 2017 with users worldwide.
We have built a simple continuous deployment pipeline, also mostly in JavaScript, that we use to validate every push to master before deploying it automatically to production.
This talk demonstrates how we write tests and how the pipeline is scripted. We discuss the thinking behind and the tools that we've used to do continuous delivery.
Testing GraphQL in Your JavaScript Application: From Zero to Hundred Percent
This document discusses strategies for testing GraphQL applications from the initial development phases through integration and end-to-end testing. Key aspects that can be tested include GraphQL schemas through importing and mocking the schema, resolvers which are pure functions that are easy to test in isolation, integration through schema mocking and resolver testing with server mocking, and client-side testing by mocking the GraphQL client. End-to-end testing involves testing against real servers, and load testing can also be done to test performance. The document emphasizes that testing GraphQL applications involves static type checking, unit tests, integration tests, end-to-end tests, and load testing.
Test Presentation
The document discusses the benefits of testing code through test-driven development and continuous integration. It explains that testing allows developers to have confidence that code will work as intended and catch any unintended behaviors. Test-driven development involves writing tests before code to validate outcomes, and continuous integration runs test suites frequently to ensure new code stays compatible. Conditionals require thorough testing of all possible code paths to ensure robust code. Shared development relies on testing to verify any new changes don't break existing features.
Come si applica l'OCP
This document summarizes a presentation on applying the Open-Closed Principle during Test Driven Development. It discusses when refactoring should occur during the TDD process, how to structure code to follow the Open-Closed Principle, and provides an example "OCP Kata" exercise to practice these concepts. Learning objectives, examples, and rules for the kata are outlined to help attendees understand and apply the Open-Closed Principle.
Python Testing Fundamentals
This document provides an overview of the Python unittest module for writing and running automated tests. It discusses how the unittest.TestCase class is used to define test classes with methods named "test_" that contain assertions. The unittest module then handles running the tests and provides features like test organization, discovery of test methods, and integration with other tools.
Test Driven iOS Development (TDD)
TDD involves first writing an automated test that fails, then writing just enough code to pass that test, and refactoring the code. The red-green-refactor process ensures code is tested and well-designed. Studies found TDD reduced pre-release defects by 40-90% and increased initial development time by 15-35%, but allowed for faster development long-term by eliminating bugs early. The document demonstrates TDD with a temperature converter in Xcode, starting with failing tests for -40C=-40F and 30C=86F then coding to pass them.
TDD Flow: The Mantra in Action
San Francisco Software Craftsmanship Meetup
Test Driven Developers Bay Area Meetup
TDD Flow: The Mantra in Action” is a talk + hands-on about the mantra of TDD and its core patterns. Here are some questions for this talk: What is TDD? How to write a good test that fails? How to write code enough to make the test pass? How to remove duplication? How to refactor code? How to create clean code? Is TDD about testing or design? How small should a test be? Should I only write unit tests? Should I estimate TDD? How to use TDD with other agile methods like Scrum, Kanban or BDD? And finally, how to flow in TDD?
Test Driven Development
Test-driven development (TDD) is an agile software development process where test cases are developed before code. The TDD process involves writing a test, watching it fail, writing code to pass the test, and refactoring code as needed. TDD encourages dividing work into small pieces and promotes high-quality code by requiring tests to pass before adding new features. While TDD requires more initial time writing tests, it can reduce debugging time and defects in the long run.
Tdd
Test-driven development (TDD) is a software development process that relies on the repetition of short development cycles called red-green-refactor cycles. In TDD, tests are written before code to define desired functionality, and then code is written to pass those tests; this is followed by refactoring. The benefits of TDD include producing code that is robust, well-designed, and with fewer bugs due to comprehensive test coverage. While TDD requires discipline, it helps ensure code works as intended and allows refactoring with confidence that changes don't break existing functionality. Some potential vulnerabilities of TDD are that it may not prevent wrong solutions if requirements are unclear, can be difficult for UI or database-dependent programs
TDD (Test Driven Design)
4 Nisan 2015 tarihinde Kadir Has Üniversitesi'nde yapılan 9. Yazılım Teknolojileri Seminer etkinliğinde Eralp Erat'ın yaptığı TDD (Test Driven Design) sunumu
Developers’ mDay u Banjoj Luci - Milan Popović, PHP Srbija – Testimony (about...
This document discusses the importance of testing software. It outlines 30 tips for writing tests, including writing tests before code, treating tests like code, minimizing asserts per test, using data providers, and allocating time for testing in estimates. Testing helps catch bugs, improve code quality, and ensure stability. The document emphasizes that automated testing is key and should test everything that could break an app.
Test-Driven Development In Action
This document provides an overview of test driven development (TDD), including what TDD is, an example unit test, the TDD process, benefits of TDD such as more maintainable code and fewer bugs, and resources for learning and practicing TDD such as books and training courses. TDD involves writing automated tests before implementation code to help ensure code quality and catch errors early. The process involves writing a test, seeing it fail, then writing just enough code to make it pass and refactoring as needed.
TDD in Javascript
Unit testing involves testing small isolated parts of code, such as functions or classes. Test-driven development (TDD) is a methodology where you write unit tests before writing the code itself to drive the development. TDD follows a cycle of red, green, refactor - writing a test that fails, making it pass, then refactoring code. TDD can improve code quality but requires understanding the technology and takes more time initially.
Bdd - L'arte di non farsi i fatti propri
Il BDD? Non ti preoccupare non é la nuova bazzword agile. Cerchiamo di capire insieme quali sono i costi e i benefici di questa metodologia. Soddisfatti o rimborsati (forse).
Non sarà il solito Workshop, ma un HandsON!Per poter partecipare attivamente è necessario portare un pc con installato Eclipse o IntelliJ IDEA, JDK e Git.
TDD reloaded - JUGTAA 24 Ottobre 2012
Seconda serata di introduzione al Test-Driven Development, tenuta in XPeppers a Trento il 24 Ottobre 2012.
Nelle slide c'è anche la descrizione del coding dojo sullo string calculator che abbiamo svolto assieme.
Test Driven Development
What is TTD?
Unit Test & Refactoring
Got Bugs?
Tenets of TTD.
Benifits of TDD.
Advantages & Disadvantages of TDD.
More Related Content
What's hot
Python3.6 and asynchronous programming
This document discusses asynchronous programming in Python 3.6 using async and await. It covers coroutines, event loops, asynchronous programming techniques, and libraries like asyncio and curio. The document argues that asynchronous programming produces more readable and efficient code compared to multithreading, as event loops can schedule coroutine execution in a non-predetermined order based on I/O availability.
Comparison of static code analyzers: CppCat, Cppcheck, PVS-Studio and Visual ...
We have carried out a thorough comparison of four analyzers for C/C++ code: CppCat, Cppcheck, PVS-Studio and Visual Studio's built-in analyzer. It is a serious, large investigation that we had spent about 170 man-hours on and which, in our opinion, gives a good idea of the general state of things in static analysis nowadays.
Do you have a #bug? Your unit tests are not well planned
Llevo cierto tiempo profundizando en tratar de entender por qué muchas organizaciones o equipos no consiguen sacarle partido a la automatización del testing. Todos conocemos de sobra la pirámide de tests descrita por Mike Cohn en su libro “Succeeding with Agile” en la que describe lo importante que es tener un balance adecuado entre tests end-to-end, tests de integración y tests unitarios. Existen cientos de artículos hablando sobre esto y está claro que la teoría tanto la conocemos como la compartimos pero, ¿cómo podemos llevarla a cabo? La clave está en conseguir hacer unos buenos tests unitarios.
En esta charla compartiré de forma gráfica, con ejemplos sencillos, números y referencias la manera de conseguir que tus tests unitarios no sólo te ayuden a mejorar la calidad interna del producto, sino también su calidad externa y, por lo tanto, consigas un retorno de la inversión (ROI) que lo haga sostenible.
Checking the Source SDK Project
The Source SDK is a software development kit compiled by Valve Corporation that is used to create games or mods for the Source engine. I downloaded and checked the project's source codes at the end of 2013 already and intended to write an article about it during the New Year holidays. But laziness prevailed over the craving for creativity, and I sat down to writing the article only on getting back to work. However, I doubt that the source codes have changed during this time. Now you are welcome to have a look at the suspicious code fragments found in the project code by the PVS-Studio code analyzer.
So Your OpenStack Cloud is Built...Now What?
This document discusses automating OpenStack cloud administration tasks. It begins by reviewing common cloud decisions and day-to-day operator tasks. It then discusses how OpenStack and automation work well together and considerations for automating tasks. Several examples of automating tasks like creating users/projects and health monitoring are provided. It emphasizes adopting an "Administration DevOps" approach to automate operations and make the cloud more scalable and efficient.
Ddc2011 효과적으로레거시코드다루기
The document discusses techniques for effectively working with legacy code. It recommends starting by finding small parts of legacy code that can be tested without making big changes. Then use those tests to safely extend design changes. When new features are needed, change a little code and add some tests to the affected areas. This spreads tests throughout the legacy code over time. The document also provides examples of refactoring techniques like extract method, sprout method, characterization tests, subclassing and overriding methods, and extracting method objects to untangle legacy code in a safe, test-driven way.
100 tests per second - 40 releases per week
This talk shows how the Triggerz engineering team continuously deliver new software versions to our users.
The Triggerz product is a web application built with React, Node.js and PostgreSQL. The product has been live since October 2017 with users worldwide.
We have built a simple continuous deployment pipeline, also mostly in JavaScript, that we use to validate every push to master before deploying it automatically to production.
This talk demonstrates how we write tests and how the pipeline is scripted. We discuss the thinking behind and the tools that we've used to do continuous delivery.
Testing GraphQL in Your JavaScript Application: From Zero to Hundred Percent
This document discusses strategies for testing GraphQL applications from the initial development phases through integration and end-to-end testing. Key aspects that can be tested include GraphQL schemas through importing and mocking the schema, resolvers which are pure functions that are easy to test in isolation, integration through schema mocking and resolver testing with server mocking, and client-side testing by mocking the GraphQL client. End-to-end testing involves testing against real servers, and load testing can also be done to test performance. The document emphasizes that testing GraphQL applications involves static type checking, unit tests, integration tests, end-to-end tests, and load testing.
Test Presentation
The document discusses the benefits of testing code through test-driven development and continuous integration. It explains that testing allows developers to have confidence that code will work as intended and catch any unintended behaviors. Test-driven development involves writing tests before code to validate outcomes, and continuous integration runs test suites frequently to ensure new code stays compatible. Conditionals require thorough testing of all possible code paths to ensure robust code. Shared development relies on testing to verify any new changes don't break existing features.
Come si applica l'OCP
This document summarizes a presentation on applying the Open-Closed Principle during Test Driven Development. It discusses when refactoring should occur during the TDD process, how to structure code to follow the Open-Closed Principle, and provides an example "OCP Kata" exercise to practice these concepts. Learning objectives, examples, and rules for the kata are outlined to help attendees understand and apply the Open-Closed Principle.
Python Testing Fundamentals
This document provides an overview of the Python unittest module for writing and running automated tests. It discusses how the unittest.TestCase class is used to define test classes with methods named "test_" that contain assertions. The unittest module then handles running the tests and provides features like test organization, discovery of test methods, and integration with other tools.
What's hot (11)
Comparison of static code analyzers: CppCat, Cppcheck, PVS-Studio and Visual ...
Comparison of static code analyzers: CppCat, Cppcheck, PVS-Studio and Visual ...
Do you have a #bug? Your unit tests are not well planned
Do you have a #bug? Your unit tests are not well planned
Testing GraphQL in Your JavaScript Application: From Zero to Hundred Percent
Testing GraphQL in Your JavaScript Application: From Zero to Hundred Percent
Similar to TDD - A Reminder of the Principles
Test Driven iOS Development (TDD)
TDD involves first writing an automated test that fails, then writing just enough code to pass that test, and refactoring the code. The red-green-refactor process ensures code is tested and well-designed. Studies found TDD reduced pre-release defects by 40-90% and increased initial development time by 15-35%, but allowed for faster development long-term by eliminating bugs early. The document demonstrates TDD with a temperature converter in Xcode, starting with failing tests for -40C=-40F and 30C=86F then coding to pass them.
TDD Flow: The Mantra in Action
San Francisco Software Craftsmanship Meetup
Test Driven Developers Bay Area Meetup
TDD Flow: The Mantra in Action” is a talk + hands-on about the mantra of TDD and its core patterns. Here are some questions for this talk: What is TDD? How to write a good test that fails? How to write code enough to make the test pass? How to remove duplication? How to refactor code? How to create clean code? Is TDD about testing or design? How small should a test be? Should I only write unit tests? Should I estimate TDD? How to use TDD with other agile methods like Scrum, Kanban or BDD? And finally, how to flow in TDD?
Test Driven Development
Test-driven development (TDD) is an agile software development process where test cases are developed before code. The TDD process involves writing a test, watching it fail, writing code to pass the test, and refactoring code as needed. TDD encourages dividing work into small pieces and promotes high-quality code by requiring tests to pass before adding new features. While TDD requires more initial time writing tests, it can reduce debugging time and defects in the long run.
Tdd
Test-driven development (TDD) is a software development process that relies on the repetition of short development cycles called red-green-refactor cycles. In TDD, tests are written before code to define desired functionality, and then code is written to pass those tests; this is followed by refactoring. The benefits of TDD include producing code that is robust, well-designed, and with fewer bugs due to comprehensive test coverage. While TDD requires discipline, it helps ensure code works as intended and allows refactoring with confidence that changes don't break existing functionality. Some potential vulnerabilities of TDD are that it may not prevent wrong solutions if requirements are unclear, can be difficult for UI or database-dependent programs
TDD (Test Driven Design)
4 Nisan 2015 tarihinde Kadir Has Üniversitesi'nde yapılan 9. Yazılım Teknolojileri Seminer etkinliğinde Eralp Erat'ın yaptığı TDD (Test Driven Design) sunumu
Developers’ mDay u Banjoj Luci - Milan Popović, PHP Srbija – Testimony (about...
This document discusses the importance of testing software. It outlines 30 tips for writing tests, including writing tests before code, treating tests like code, minimizing asserts per test, using data providers, and allocating time for testing in estimates. Testing helps catch bugs, improve code quality, and ensure stability. The document emphasizes that automated testing is key and should test everything that could break an app.
Test-Driven Development In Action
This document provides an overview of test driven development (TDD), including what TDD is, an example unit test, the TDD process, benefits of TDD such as more maintainable code and fewer bugs, and resources for learning and practicing TDD such as books and training courses. TDD involves writing automated tests before implementation code to help ensure code quality and catch errors early. The process involves writing a test, seeing it fail, then writing just enough code to make it pass and refactoring as needed.
TDD in Javascript
Unit testing involves testing small isolated parts of code, such as functions or classes. Test-driven development (TDD) is a methodology where you write unit tests before writing the code itself to drive the development. TDD follows a cycle of red, green, refactor - writing a test that fails, making it pass, then refactoring code. TDD can improve code quality but requires understanding the technology and takes more time initially.
Bdd - L'arte di non farsi i fatti propri
Il BDD? Non ti preoccupare non é la nuova bazzword agile. Cerchiamo di capire insieme quali sono i costi e i benefici di questa metodologia. Soddisfatti o rimborsati (forse).
Non sarà il solito Workshop, ma un HandsON!Per poter partecipare attivamente è necessario portare un pc con installato Eclipse o IntelliJ IDEA, JDK e Git.
TDD reloaded - JUGTAA 24 Ottobre 2012
Seconda serata di introduzione al Test-Driven Development, tenuta in XPeppers a Trento il 24 Ottobre 2012.
Nelle slide c'è anche la descrizione del coding dojo sullo string calculator che abbiamo svolto assieme.
Test Driven Development
What is TTD?
Unit Test & Refactoring
Got Bugs?
Tenets of TTD.
Benifits of TDD.
Advantages & Disadvantages of TDD.
Overview on TDD (Test Driven Development) & ATDD (Acceptance Test Driven Deve...
Overview on TDD (Test Driven Development) & ATDD (Acceptance Test Driven Deve...Zohirul Alam Tiemoon
The document discusses Test-Driven Development (TDD) and Acceptance Test-Driven Development (ATDD). It defines TDD and ATDD, provides demos of applying each approach to building a calculator and pet shop application, and discusses how they help keep design simple. Tools for TDD/ATDD and who writes unit/acceptance tests are also covered, along with why the approaches are used.TDD - Agile
This document discusses Test Driven Development (TDD). It defines TDD, outlines the TDD process which involves writing tests first and then code to pass the tests, and emphasizes refactoring. Benefits of TDD include improved code quality, reduced bugs, and serving as documentation. Key TDD terms and libraries like JUnit and Mockito are explained. Continuous Integration (CI) is also discussed as it automates testing and builds when code is committed.
Test-Driven Design - ¿Porqué?
The document discusses test-driven development (TDD) and how it can be used to reduce unnecessary complexity, also known as inventory, in software design. TDD involves writing automated tests before code to articulate requirements and ensure only needed code is written. It promotes designing simple, clear code without duplication through principles like You Aren't Gonna Need It and refactoring code in small, reversible steps. Following TDD principles is claimed to reduce inventory created by excess complexity and allow designs to evolve incrementally based on test feedback.
Test Driven Development
TDD is a software development practice where tests are written before production code to define requirements. It follows three rules: 1) Write a test that fails without production code. 2) Write just enough production code to pass the test. 3) Refactor code without changing external behavior. This ensures code is properly tested and reduces bugs through frequent integration and refactoring enabled by the test suite. TDD results in testable, loosely coupled code and faster delivery times.
Test Driven Development (TDD) - CVCC 2011
This document discusses test driven development (TDD) and its introduction. It was popularized by extreme programming (XP) as a "testing strategy" in the first edition and "test-first" in the second edition. The document discusses that TDD is not just about testing, but also helps produce unambiguous requirements, improved software design, loose coupling, and increased productivity. It reviews best practices shown in a demo, such as using NUnit assertions and the red-green-refactor process. It concludes with additional discussion points around TDD pragmatism versus religion, continuous integration, testing challenges, and recommended agile reading.
Introduction to Test Driven Development
This document provides an introduction to test-driven development (TDD), including its goals, benefits, and challenges. TDD is an iterative, test-first approach to development where functionality and behavior are defined by tests. Tests are written before code and define the desired API and design. Benefits of TDD include reduced defects, increased initial development time, and easier refactoring and collaboration. Adopting TDD requires practice and a focus on good design principles like separation of concerns.
Tdd is not about testing
Why should we use TDD to develop in Elixir? When we are applying it correctly? What are the differences that we can find in a code developed with TDD and in code not developed with it? Is it TDD about testing? Really? In this talk, I'll show what is TDD and how can be used it in functional programming like Elixir to design the small and the big parts of your system, showing what are the difference and the similarities between an OOP and FP environment. Showing what is the values of applying a technique like TDD in Elixir and what we should obtain applying it.
Tdd is not about testing (OOP)
TDD is now mainstream but a lot people don't know or don't remember what is its purpose. TDD is about software design not testing or catching bug. TDD helps developers to shape and create software with "good" design, what is a "good" design is something that we will discuss in the topic.
Code Retreat
This document describes a code retreat event where programmers gather to improve their skills through pair programming exercises. The retreat will involve two 45-minute coding sessions using constraints like immutable objects and four lines of code per method. Programmers will pair up and take turns writing tests and implementation code using ping pong pair programming. Between sessions, they will reflect on their experience and process of pairing, deleting code between rounds. The goal is to learn through constraints and continuous practice with a focus on software fundamentals.
Similar to TDD - A Reminder of the Principles (20)
Developers’ mDay u Banjoj Luci - Milan Popović, PHP Srbija – Testimony (about...
Developers’ mDay u Banjoj Luci - Milan Popović, PHP Srbija – Testimony (about...
Overview on TDD (Test Driven Development) & ATDD (Acceptance Test Driven Deve...
Overview on TDD (Test Driven Development) & ATDD (Acceptance Test Driven Deve...
More from Matthias Noback
Rector fireside chat - PHPMiNDS meetup
This document summarizes a fireside chat about the Rector tool for refactoring PHP code. It introduces Rector as a PHP command line tool that can understand code, improve entire codebases at once, and be fine-tuned or extended for specific needs. Rector can help with continuous improvement, code coaching, and the future of refactoring PHP applications without creating technical debt from migrations. The chat then transitions to a demo by Tomas and discusses a book about how to use and extend Rector.
Service abstractions - Part 1: Queries
1) The document discusses creating an abstraction for querying external systems and APIs to make the code more testable and resilient to changes.
2) It proposes defining an interface for the "question" being asked and a class for the "answer", with an implementation that handles the actual request.
3) This abstraction separates the application logic from infrastructure details, allowing the tests to focus on the domain and easing test setup by using test doubles instead of real external dependencies.
Hexagonal Symfony - SymfonyCon Amsterdam 2019
This document discusses hexagonal architecture with Symfony. It recommends separating domain logic from infrastructure code like frameworks to increase testability and allow replacing parts independently. It describes defining ports and adapters, with ports representing intentions to communicate and adapters providing implementations. For example, a "buy a ticket" port could be implemented by a HTTP adapter using a controller. The document argues this approach makes code easier to change and maintain while keeping up with framework updates.
Advanced web application architecture - PHP Barcelona
This document discusses principles of advanced web application architecture. It recommends separating applications into domain logic and infrastructure/framework-specific code by introducing layers. It also recommends defining ports and adapters using a hexagonal/ports and adapters architecture to increase testability and flexibility. This allows infrastructure/framework code to change without affecting domain logic ports, and makes it easier to keep up with changing frameworks. Sources provided discuss this architecture approach in more detail.
A testing strategy for hexagonal applications
This document discusses a testing strategy for hexagonal applications that focuses on testing units in isolation like domain logic and use cases without infrastructure dependencies. It advocates for unit tests of application services, integration tests of port adapters against real databases/services, and system tests of the full deployable application to build testing confidence from the unit to system level. The key aspects of hexagonal architecture that enable this are isolation of domain from infrastructure through ports/adapters and explicit definition of use cases as primary interaction points.
Advanced web application architecture - Talk
This document discusses web application architecture and frameworks. It argues that frameworks should not dictate project structure, and that the code should separate domain logic from infrastructure logic. This allows focusing on the core problem domain without concerning itself with technical details like databases or web requests. It also advocates splitting code into ports that define intentions like persistence, and adapters that provide framework-specific implementations, allowing for independence of the domain logic from any particular framework or technology. This architecture, known as hexagonal or ports and adapters, facilitates testing, replacement of parts, and future-proofing of the application.
DPC 2019, Amsterdam: Beyond design patterns and principles - writing good OO ...
Of course, you should read all you can about SOLID, Design patterns, Patterns of Enterprise Application Architecture, etc. Once you have a basic understanding of these topics you still have to write that code though, and write it well too! What is good code? Are there some guidelines, or rules of thumb, which you can follow while making your everyday coding decisions?
In this talk I’ll cover many of these coding guidelines, which aren’t usually covered by patterns or principles books. They should help you write better code and give you a richer vocabulary for reviewing other people’s code. Some of the subjects that we’ll discuss are: state, mutability, CQS, one-method objects, domain-first, API-driven, functional programming influences, object boundaries, (de)serialization, and many more!
Layers, ports and adapters
This workshop covers all of the three layers from what is known as a layered architecture: the domain, application and infrastructure layer.
Protecting your high quality domain model can be accomplished by applying a so-called ports & adapters or hexagonal architecture. And you'll find out how your application's design really starts to flourish when you use CQRS with Event Sourcing.
Some of the keywords for this workshop: aggregate design, domain events, application services, commands, queries and events, event sourcing, projections, eventual consistency, layered architecture, ports & adapters, hexagonal architecture.
What you'll learn from this tutorial:
* Design a clean domain model
* Model your application's use cases as application services
* Connect those well-designed layers to the world outside
Beyond design principles and patterns (muCon 2019 edition)
Of course, you should read all you can about SOLID, Design patterns, Patterns of Enterprise Application Architecture, etc. Once you have a basic understanding of these topics you still have to write that code though, and write it well too! What is good code? Are there some guidelines, or rules of thumb, which you can follow while making your everyday coding decisions?
In this talk Matthias will cover many of these coding guidelines, which aren’t usually covered by patterns or principles books. They should help you write better code and give you a richer vocabulary for reviewing other people’s code. Some of the subjects that we’ll discuss are: state, mutability, CQS, one-method objects, domain-first, API-driven, functional programming influences, object boundaries, (de)serialization, and more!
Brutal refactoring, lying code, the Churn, and other emotional stories from L...
Working effectively with legacy code isn’t all about creating test harnesses before refactoring algorithms. The “safety first” strategy doesn’t always apply. Not if the code you’re looking at is LYING IN YOUR FACE anyway.
In this talk I’ll show you what brutal refactoring is. I’ll show you the red glowy eyes of the Churn. And I’ll hold up some big warning signs that should prevent you from producing legacy code today.
Table flips allowed.
Advanced web application architecture Way2Web
How to:
- Design a clean domain model
- Model your application's use cases as application services
- Connect those well-designed layers to the world outside
Protecting your high quality domain model can be accomplished by applying a so-called ports & adapters or hexagonal architecture.
Some of the keywords for this talk: aggregate design, domain events, application services, commands, queries and events, layered architecture, ports & adapters, hexagonal architecture.
Brutal refactoring, lying code, the Churn, and other emotional stories from L...
PHP Benelux 2019 edition
Working effectively with legacy code isn’t all about creating test harnesses before refactoring algorithms. The “safety first” strategy doesn’t always apply. Not if the code you’re looking at is LYING IN YOUR FACE anyway.
In this talk I’ll show you what brutal refactoring is. I’ll show you the red glowy eyes of the Churn. And I’ll hold up some big warning signs that should prevent you from producing legacy code today.
Table flips allowed.
Beyond Design Principles and Patterns
The document discusses object-oriented design principles and patterns. It covers design patterns like abstract factory, mediator, proxy, builder, and others. It also discusses design principles like SOLID principles, package design principles, and tactical domain-driven design patterns. It emphasizes that while knowing patterns and principles is important, the key is applying them correctly. It provides guidance on writing good object-oriented code by focusing on object cohesion, encapsulation, defensive programming, and using composition over inheritance.
Building Autonomous Services
This document discusses building autonomous microservices and provides assignments to practice designing services that are autonomous and event-driven. It introduces a simplified e-commerce domain with Catalog, Purchase, Sales, and Stock services and assigns tasks to modify the services to be more autonomous by subscribing to each other's events, updating internal state, and responding without direct communication. The assignments introduce concepts like process managers, event conversion, and using the reservation pattern to avoid concurrency issues. Questions are also provided throughout to help think through architectural challenges.
Advanced Application Architecture Symfony Live Berlin 2018
This document discusses advanced application architecture, specifically layers, ports, and adapters. It introduces layered architecture as a way to define coupling and cohesion in a codebase. The layers separate domains into infrastructure, application, and domain layers with dependencies only allowed in one direction from higher to lower layers. Ports define interfaces that layers can depend on while adapters implement ports, allowing for decoupling and replacement of components. The document also discusses testing at the unit, integration, acceptance, and system levels to verify the architecture.
Designing for Autonomy
The much hyped "Microservice Architecture" tells us to design our services to be autonomous. Let's find out what this means and how we can achieve it. In this talk I will guide you through the fascinating world of asynchronous communication, event-driven systems and distributed data.
Docker workshop
Docker allows for isolation of applications into lightweight containers that can be linked together and share resources. Containers are run from images that act as templates containing the files, configuration, and dependencies for an application. Images are built from Dockerfiles that define the build process and layers, and can be pulled from or pushed to a registry for distribution. Docker uses a client-server model with daemons managing containers on each host.
Docker swarm workshop
This document introduces Docker Swarm and its key features. It discusses running Docker daemons in Swarm mode to create a cluster, using tools like docker-machine to provision nodes. It explains how Swarm provides service discovery, load balancing and networking between nodes. The document also covers best practices for building Docker images like using official base images and optimizing layers.
Docker compose workshop
Docker Compose allows defining and running multi-container Docker applications. It uses YAML files to configure the application's services and Docker to run the containers. Compose works by separating the configuration of services (what runs in containers) from the Docker daemon (what runs the containers). This allows defining and sharing common configurations and ensuring services are always deployed together.
Building autonomous services
In this workshop we'll dive into the topic of Autonomous Service development, with a sandbox project containing several interdependent services. These projects send messages to each other, and they call each other to retrieve data. In other words, they're not autonomous at all. We'll figure out some ways in which we can invert dependencies and leverage a messaging solution to achieve autonomy after all.
In a relatively short period you’ll get acquainted with the basics of asynchronous integration, CQRS, event sourcing and integrating bounded contexts.
More from Matthias Noback (20)
Advanced web application architecture - PHP Barcelona
Advanced web application architecture - PHP Barcelona
DPC 2019, Amsterdam: Beyond design patterns and principles - writing good OO ...
DPC 2019, Amsterdam: Beyond design patterns and principles - writing good OO ...
Beyond design principles and patterns (muCon 2019 edition)
Beyond design principles and patterns (muCon 2019 edition)
Brutal refactoring, lying code, the Churn, and other emotional stories from L...
Brutal refactoring, lying code, the Churn, and other emotional stories from L...
Brutal refactoring, lying code, the Churn, and other emotional stories from L...
Brutal refactoring, lying code, the Churn, and other emotional stories from L...
Advanced Application Architecture Symfony Live Berlin 2018
Advanced Application Architecture Symfony Live Berlin 2018
Recently uploaded
National Security Agency - NSA mobile device best practices
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
Full-RAG: A modern architecture for hyper-personalization
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Communications Mining Series - Zero to Hero - Session 1
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdf
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
20240609 QFM020 Irresponsible AI Reading List May 2024
Everything I found interesting about the irresponsible use of machine intelligence in May 2024
HCL Notes and Domino License Cost Reduction in the World of DLAU
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Climate Impact of Software Testing at Nordic Testing Days
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Essentials of Automations: The Art of Triggers and Actions in FME
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
Presentation of the OECD Artificial Intelligence Review of Germany
Consult the full report at https://www.oecd.org/digital/oecd-artificial-intelligence-review-of-germany-609808d6-en.htm
GraphSummit Singapore | Enhancing Changi Airport Group's Passenger Experience...
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Programming Foundation Models with DSPy - Meetup Slides
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
20240605 QFM017 Machine Intelligence Reading List May 2024
Everything I found interesting about machines behaving intelligently during May 2024
Removing Uninteresting Bytes in Software Fuzzing
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
Recently uploaded (20)
National Security Agency - NSA mobile device best practices
National Security Agency - NSA mobile device best practices
Full-RAG: A modern architecture for hyper-personalization
Full-RAG: A modern architecture for hyper-personalization
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
GraphSummit Singapore | Graphing Success: Revolutionising Organisational Stru...
Communications Mining Series - Zero to Hero - Session 1
Communications Mining Series - Zero to Hero - Session 1
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdf
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdf
20240609 QFM020 Irresponsible AI Reading List May 2024
20240609 QFM020 Irresponsible AI Reading List May 2024
HCL Notes and Domino License Cost Reduction in the World of DLAU
HCL Notes and Domino License Cost Reduction in the World of DLAU
Climate Impact of Software Testing at Nordic Testing Days
Climate Impact of Software Testing at Nordic Testing Days
Essentials of Automations: The Art of Triggers and Actions in FME
Essentials of Automations: The Art of Triggers and Actions in FME
Presentation of the OECD Artificial Intelligence Review of Germany
Presentation of the OECD Artificial Intelligence Review of Germany
GraphSummit Singapore | Enhancing Changi Airport Group's Passenger Experience...
GraphSummit Singapore | Enhancing Changi Airport Group's Passenger Experience...
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...
Programming Foundation Models with DSPy - Meetup Slides
Programming Foundation Models with DSPy - Meetup Slides
20240605 QFM017 Machine Intelligence Reading List May 2024
20240605 QFM017 Machine Intelligence Reading List May 2024
TDD - A Reminder of the Principles
- 1. TDD A reminder of the principles Matthias Noback @matthiasnoback
- 2. APPLICATION PROGRAMMING INTERFACE (API) How you can work with an object Create Modify Inspect
- 3. TEST-DRIVEN DEVELOPMENT (TDD) Specify the API (D = Design?) Implement it Prove its correctness
- 4. THE CYCLE OF TDD Red - Green - Refactor Red: create a failing test Green: make the test pass Refactor: make the code maintainable
- 5. STRUCTURE OF A UNIT TEST Arrange - Act - Assert Arrange: prepare some data Act: call some method Assert: verify the result
- 6. ADVANTAGES OF TDD The code you write is correct (provable, automated) The code you write is all the code you need You can safely refactor the code
- 7. HEURISTICS FOR TDD If you don't know what to do anymore Think of the simplest thing to test Think of the simplest way to make the test pass Think of edge cases (but not for too long) Think of how you would like to be able to use the object
- 8. KATA A short programming/TDD exercise
- 10. GO! Work together if you like Share what you've got
- 11. HOW TO SET UP A PROJECT? And run unit tests?