Skip to main content

Feature Toggles

I'm a fan of regular releasing. My background and experience leads me to release as regularly as possible. There are numerous benefits to regular releases; limited risk, slicker release processes and the ability to change as requirements evolve.

The problem with this concept is how can you release when features are not functionally complete?


If there is still work in progress, one solution to allow frequent releases is to use feature toggles. Feature toggles are simple conditional statements that are either enabled or disabled based on some condition.

This simple example shows a feature toggle for an "Edit User" feature. If the boolean condition is false, then we only show the "New User" feature and the "Admin" feature. This boolean value will be provided by various means, usually a configuration file. This means at certain points we can change this value in order to demonstrate the "Edit User" functionality. Our demo environment could have this enabled, while the live system would be disabled until the feature is fully complete.

If the feature to edit users took more than an ideal release cycle the code could still be released. As long as all the tests and other release checks pass there is no reason to defer this task. This is after all one of the benefits of continuous integration. Any consumer of this code base would always be working with up to date code, merge conflicts would be next to non existent. Our new code would be integrated regularly.

Ideally feature toggles live as high as possible in the dependency graph of your application. In most cases this would be the composition root of the application or within UI/presentation logic. This simplifies the addition of toggles, but you need to be careful that just because the UI hides a feature it is not truly disabled. In scenarios where security is a concern the feature toggles may need to live further down the stack.

It's best to remove feature toggles once the feature is complete otherwise they can become a maintenance burden. Is this feature enabled or disabled? Can we delete this code? These sort of questions can cause legacy code to live unquestioned. One way to aid in their removal is to add assertions to fail the build at a certain point in the future or include a toggle with built in date/time logic.

Feature Toggles help with demonstrating features, but they can be more complex. For risky features you may want to slowly ramp up the number of users who are exposed to the feature. In this case the actual toggle may perform some basic logic such as "one out of ten requests" enable the new feature. Overtime this ratio can be increased until the feature is fully enabled and proven.

Another technique to allow fast, regular releases is to rely on Branch by Abstraction. This works great when the toggles live in the composition root or the team have the ability to split work around features.


Popular posts from this blog

Constant Object Anti Pattern

Most constants are used to remove magic numbers or variables that lack context. A classic example would be code littered with the number 7. What does this refer to exactly? If this was replaced with DaysInWeek or similar, much clarity is provided. You can determine that code performing offsets would be adding days, rather than a mysterious number seven.Sadly a common pattern which uses constants is the use of a single constant file or object. The beauty of constants is clarity, and the obvious fact such variables are fixed. When a constant container is used, constants are simply lumped together. These can grow in size and often become a dumping ground for all values within the application.A disadvantage of this pattern is the actual value is hidden. While a friendly variable name is great, there will come a time where you will want to know the actual value. This forces you to navigate, if only to peek at the value within the constant object. A solution is to simple perform a refactor …

Three Steps to Code Quality via TDD

Common complaints and problems that I've both encountered and hear other developers raise when it comes to the practice of Test Driven Development are: Impossible to refactor without all the tests breakingMinor changes require hours of changes to test codeTest setup is huge, slow to write and difficult to understandThe use of test doubles (mocks, stubs and fakes is confusing)Over the next three posts I will demonstrate three easy steps that can resolve the problems above. In turn this will allow developers to gain one of the benefits that TDD promises - the ability to refactor your code mercifully in order to improve code quality.StepsStop Making Everything PublicLimit the Amount of Dependencies you Use A Unit is Not Always a Method or ClassCode quality is a tricky subject and highly subjective, however if you follow the three guidelines above you should have the ability to radically change implementation details and therefore improve code quality when needed.

DRY vs DAMP in Tests

In the previous post I mentioned that duplication in tests is not always bad. Sometimes duplication becomes a problem. Tests can become large or virtually identically excluding a few lines. Changes to these tests can take a while and increase the maintenance overhead. At this point, DRY violations need to be resolved.SolutionsTest HelpersA common solution is to extract common functionality into setup methods or other helper utilities. While this will remove and reduce duplication this can make tests a bit harder to read as the test is now split amongst unrelated components. There is a limit to how useful such extractions can help as each test may need to do something slightly differently.DAMP - Descriptive and Meaningful PhrasesDescriptive and Meaningful Phrases is the alter ego of DRY. DAMP tests often use the builder pattern to construct the System Under Test. This allows calls to be chained in a fluent API style, similar to the Page Object Pattern. Internally the implementation wil…