#Testing
33 notas · última:
Build Confidence in Your Strategy with Small Tests
The page argues that strategy should be tested before implementation, using small, creative, evidence-gathering experiments to reduce uncertainty and build confidence in choices.
Testing is software engineering
The page argues that testing is part of engineering, not an afterthought. It says tests improve design, make changes safer, surface hidden requirements, and help teams collaborate.
4 tools to supercharge your Jest Testing and increase your productivity while testing
The page recommends four Jest additions to speed up feedback, narrow test runs, improve assertions, and keep console output clean during development.
Your job is to deliver code you have proven to work
Simon Willison argues that AI-assisted development still requires proving changes work through manual testing and automated tests, with humans accountable for the result and coding agents helping only if they can verify their own output.
Elixir Makes You Make Good Decisions
The author argues that Elixir, Phoenix, Ecto, and the BEAM helped screen.garden make cleaner architecture, easier authorization, faster file sync, and tests that are pleasant to write.
Night Shift Agentic Workflow
Jamon Holmgren describes a day-shift/night-shift setup where he prepares specs during the day and lets AI agents work overnight with strict tests, docs, and review loops.
More Testing Tips With C#
The post shares testing tips for C#: generating fake data with Faker.NET or Bogus.NET, using seeds to reproduce randomized tests, comparing output against reference files, and finding free ports or loopback IPs for integration tests.
The obligation of a software developer
The text argues that software quality depends on technical choices and attitude: seeking the best solution, testing the code, knowing how to say no, respecting the team, doing constructive code review, and mentoring colleagues.
Clean Code: 7 tips to write clean functions
The post argues that clean functions are small, easy to understand, well named, limited in parameters, free of nested conditionals and booleans, and preferably pure.
The Mundanity of Excellence, Small Wins, and Why You Should Fix Bugs Before Writing New Features
The post argues that good software comes from many small, consistent improvements, so bug fixes and broken details should be prioritized before new features. Excellence erodes when those small wins are left to break.
AI-assisted development needs automated tests
Simon Willison argues that comprehensive test coverage is what makes LLM-assisted coding trustworthy: tests let you prove convoluted AI-written code actually works.
How To Implement a TypeScript Web App With Clean Architecture
The article explains how to structure a TypeScript web app with core, data, presentation, and DI layers so logic stays independent of frameworks, storage, and other details.
Code Review Best Practices
The article argues that code reviews work best when they are fast, focused on readability and breaking changes, supported by automation, and preceded by a clear, small, and tested pull request.
How to write unit tests
The article explains what unit tests are, how they help with validation, refactoring, modularity, and speed, and suggests starting with scaffolding, mocking, structure, and test-driven development.
How to write unit tests
The page defines unit tests as automatic checks against expectations, explains their value for safety, modularity, and speed, and outlines scaffolding, mocking, structure, and TDD.
A ‘wise’ guy tactic for effective code review practice? Use checklist templates!
The article argues that code review works better with short checklist templates. It covers automated checks, merge conflicts, commit messages, PR size, requirements, readability, coding standards, libraries, duplication, tests, and documentation.
Introduction to Unit Testing With NUnit in C#
The article explains unit testing in C# with NUnit, covering the AAA structure, naming conventions, test project setup, parameterized tests, setup and teardown, and metadata attributes.
Package by component and architecturally-aligned testing
Simon Brown proposes package by component as a hybrid between layer and feature, with public component interfaces, package-protected internals, and tests aligned to architectural boundaries.
Dependency Injection in Elixir
The post compares two ways to apply dependency injection in Elixir: through application config with Application.get_env/3, or by passing collaborators as function parameters, with trade-offs in visibility and flexibility.
7 practices to follow for a successful code handover
The note lists seven handover practices: keep everything in version control, secure management support, have new developers write documentation, use tests to learn the system, and avoid goal-less refactoring.
Keeping your Ruby on Rails app easy to update
The post argues that updating Rails helps with security, bug fixes, and features, and says upgrade work stays smaller when dependencies are kept selective, monkey patches are avoided, and tests stay strong.
How to contribute to Elixir
The page explains how to build, test, and verify Elixir changes locally, from running make compile and make test to targeting single packages, using a custom build in an app, and cleaning bad builds.
Giving better code reviews
The article argues that code reviews should go beyond a quick approval. Reviewers need a light pass and a deeper contextual pass, keep diffs small, and ask questions that improve code quality and team understanding.
Mocks and explicit contracts
The post argues that mocks are useful, but only when they replace a real dependency through an explicit contract. That keeps tests isolated, makes boundaries visible, and avoids coupling to implementation details.
How to Test Multithreaded Code
Mike Perham says multithreaded code is hard to write and harder to test, and recommends separating threading from work and using callbacks to make threaded APIs testable without sleep calls.
A Couple of Callback Gotchas (and a Rails 5 Fix)
The post explains why `after_save` can trigger background jobs before other processes can see the record, why `after_commit` avoids that race, and why test suites need a separate fix until Rails 5.
Build and test a blazing fast JSON API with Phoenix, an Elixir framework
The article shows how to build a Phoenix JSON API for contacts, starting with a test, then adding an Ecto model, migration, route, controller, and view until the test passes.
Three Reasons Why Your Software Is So Far Behind Schedule
The article says delayed software projects often share three signs of technical debt: new developers take too long to onboard, test suites grow unwieldy or break down, and teams keep running their own servers instead of moving to the cloud.
Using Services to Keep Your Rails Controllers Clean and DRY
The article argues for moving controller-adjacent work into service objects, keeping Rails controllers thin while models stay focused on business objects and external integrations stay isolated.
The Top 10 Mistakes AngularJS Developers Make
The article lists common AngularJS pitfalls around app structure, dependency injection, controllers, watchers, scope, testing, and jQuery, with practical guidance for scaling apps.
6 Practical Agile Techniques You Can Start Using Today
The article argues for small Agile changes that improve speed, quality, and communication: deliver more often, involve testers in requirements, write user stories, use prototypes, and think about testing early.
Dependency injection is not a virtue in Ruby
DHH argues that dependency injection is a Java habit that can be overvalued in Ruby. He says Ruby lets hard-coded references stay simple while still being easy to test, so language shape matters more than cross-language best practices.
Part 6 - Testing and App Store Approvals | xamarin
The page says testing should cover multiple platforms, devices, edge cases, and beta feedback, because store approval processes often reject apps for crashes, slow startup, bad metadata, or guideline violations.