- ✓Professional software development is characterised by discipline and rigour as much as by creativity: following consistent practices for code organisation, testing and documentation makes the difference between a prototype and a production-ready application.
- ✓Unit testing, which tests individual components of an application in isolation, provides fast feedback about the correctness of individual functions and is foundational to the practice of test-driven development (TDD).
- ✓Integration testing verifies that different components of an application work correctly together, catching the class of bugs that arise from incorrect assumptions about how components interact.
- ✓Continuous integration (CI) is the practice of automatically building and testing an application every time a change is committed to the shared codebase, enabling rapid detection and correction of integration problems.
- ✓The process of turning a working development build into a production-ready release, including environment configuration, dependency management, security hardening and deployment automation, is a significant engineering discipline in its own right.
Listen to the full episode inside the course. Enrol to access all 80 episodes, plus assignments, tutor support and Student Finance funding.
Start learning →Alex: Welcome back. Today we're looking at the implementation and testing phase of application development, which is where the planning and design work becomes working software. Sam, what distinguishes professional-quality application development from code that just happens to work?
Sam: The discipline and the rigour. Code that works on the developer's machine in a controlled scenario is very different from code that works reliably in production, with real users, real data volumes, unexpected inputs and concurrent access. Getting from one to the other requires deliberate attention to a range of quality factors that go well beyond making the basic functionality work.
Alex: Let's talk about version control first, because it's such a fundamental professional practice.
Sam: Git has become the standard version control system, and for any professional development work it's non-negotiable. Version control gives you a complete history of every change made to the codebase, the ability to branch off to develop new features without disrupting the main codebase, the ability to merge contributions from multiple developers systematically and the ability to revert to any previous state if something goes wrong. Working without version control in a professional context is genuinely dangerous: it's how code gets lost, how conflicting changes get silently overwritten and how debugging becomes enormously harder than it needs to be.
Alex: And the testing disciplines that apply during implementation?
Sam: Unit testing, which tests individual functions or classes in isolation, should be a companion to writing production code rather than something you do afterwards. The practice of test-driven development takes this further: you write the test first, watch it fail because the code doesn't exist yet, then write the minimum code to make it pass. This approach tends to produce more focused, better-designed code as well as a comprehensive test suite. Integration testing verifies that the components of the application work correctly together. And end-to-end testing simulates real user journeys through the complete application, catching the kind of bugs that only manifest when all the components are working together in a realistic scenario.
Alex: Continuous integration is the practice that makes all of this sustainable, isn't it?
Sam: Yes. CI is the practice of automatically building and running all the tests every time a change is committed to the shared codebase. When CI is working well, every developer gets rapid feedback about whether their changes work in combination with everyone else's. Broken builds become visible immediately rather than after days of divergent development. And the discipline of keeping the build green, making sure all tests pass before committing, becomes a shared team commitment.
Alex: What about deployment? How does code actually get from a developer's machine to production?
Sam: Modern deployment pipelines automate most of the steps: building the code, running tests, creating a deployable artefact like a Docker container, deploying to a staging environment for final verification, and then promoting to production. The principle of infrastructure as code, where the deployment environment is defined in version-controlled configuration files rather than manual steps, makes deployments reproducible and reliable. Feature flags allow code to be deployed to production but only activated for certain users, enabling gradual rollouts and instant rollback if problems are detected.
Alex: Really professional-grade knowledge. Thanks, Sam.