Galaxy Talks: Feature Flags in Your Daily Workflows

Welcome to our ongoing series spotlighting different talks from our interactive user conference, Galaxy, which was held in April. 

Part of consistently delivering quality software faster is staying on task. Getting knocked off course via an interruption or context switch can take a heavy toll on productivity over time, resulting in missed deadlines and opportunities.

This isn't to say planned work breaks throughout the day aren't important; in fact, they're essential to your creativity and overall mental health. When you're concentrating on solving a complex problem, however, and you inadvertently get thrown off course, it can be tough to get back into the zone.

In this talk, LaunchDarkly senior solutions engineer, Dan O'Brien, talks about the perils of losing focus, and how our platform and its array of integrations can help minimize your distractions.

Transcript:

Hi. I'm Dan O'Brien, a senior solutions engineer at LaunchDarkly. I'd like to focus on developer productivity, as there's only so many hours in a day, and in my opinion, if you can make each person's day just a little bit better, it adds up to major gains to the team overall. Being able to make small, consistent, incremental improvements over time is a recipe for success. An important aspect for both working individually and as part of a team is context.

Context has multiple parts to it. The first part of it is your individual focus of staying on task and having all relevant information at your fingertips while you're working through an issue. Another aspect is shared understanding when you're communicating with your teammates. This makes talking about complex ideas easier, by knowing you're all looking at an idea and using the same concepts and wording to describe it.

Developers already deal with an ever-increasing number of tools and distractions, and a lot of times, you don't wanna add yet another tool. What you see on this screen is overwhelming, and while you won't use all of your tools in these, in the day-to-day, it goes to show the immense size of the landscape.

Let's take, for example, observability. There's a good chance you're using at least one tool from each of these categories: monitoring, logging, and tracing. If not more than one, depending on the size of your team. Every application team I've been a part of has used feature flags to some extent, even if we didn't call it that at the time. We used a field in a database or config file property without being able to easily surface the context information when and where it was needed.

What makes me really excited at being a part of LaunchDarkly is the concept of it being a platform. A platform to me means you're getting not only the functionality you want, in our case the runtime control of your application. Just as importantly, you get a public REST API that provides contracts and enables scaffolding for additional functionality that can be built on top of it and extended. And that's what we'll be looking at today. Specifically, where LaunchDarkly fits in with tools I see developers use daily, code editors, task management, and chat apps.

Let's take a look at a normal day in the life of a developer. Your day may start out as a variation of this, different responsibilities and priorities all fighting for your attention. You may need to catch up on emails that were sent off-hours. Escalations getting moved to the top of the pile. Maybe an alert has gone off that's been snoozed and now needs to be dealt with. You might've also been lucky if it was only a single alert. And just clearing out your email and dealing with these escalations and alerts, it can involve at least a half-dozen tools and systems to collaborate with all of the stakeholders and gather the relevant information to deal with those issues. That's a lot of context that you need to manage.

While this cartoon is a funny take on the situation, it does make an important point. Staying in the flow is productive. It takes effort to build up a mental model of a problem or a solution, and then walk through extending, refactoring, or modifying it. 

Small interruptions, like someone stopping by your desk, when that was a thing, or forgetting to set "do not disturb" and having desktop notifications pop up in the middle of you working, can cause big temporary drops in productivity. There's an often cited study that it can take up to 23 minutes to get back into the flow after an interruption or a context switch. So the ideal workflow is for those interruptions to not happen.

Now for the ideal day. I like to start my day with a cup of coffee, preferably a cold brew depending on the time of year and if I remembered to make it the night before. From there, I enjoy some quiet time in the morning to get ready for the day. Once I'm online, I find it valuable to review and prioritize a task schedule for that day, including any last-minute changes, the most important ones moving to the top of the pile, followed by the nice-to-haves depending on how the day goes. From there, I settle down for some uninterrupted time in my code editor to really focus on crossing those items off the task list. Once it's been completed, because it's behind a feature flag, I can safely deploy this out into a dev or production environment. From there, I like to repeat this cycle for the day.

At LaunchDarkly, we take staying in the flow seriously, and it's part of what drives our API-first ideals. Let's see how LaunchDarkly fits into this flow.

We'll start with planning. Let's dive in and see a quick example of what this planning can look like. Context begins in your tasks. Here's an example of surfacing LaunchDarkly flag data in Trello. We also have a similar integration with Jira. You don't need to switch between your browser tabs to know what a, to know what feature flag this Trello card is associated with.

Task management integrations also opens up the opportunities to delegate. You no longer need to context switch from project-based work just to enable a feature. Now your product managers and other team members can be empowered to make these changes while you're keeping your focus.

After our planning and task management, it's time to get to the fun of actually implementing. Here, we're gonna be taking a look at adding in a new dark mode feature flag. As we can add it in, you can see the editor is providing additional context such as auto-completing the flag key, and now, on line 62, it's showing that this is a LaunchDarkly feature flag. Once it's added in, we can test to make sure the base state of the application is still operating as expected. Let's give it a run.

So we can see that things are still working, and from here, we can go back into our code editor and enable the feature right from VSCode. This isn't just limited to VSCode, either. We have a plugin in beta for IntelliJ-based editors also. Now that the feature's been turned on, we can toggle from light mode to dark mode and give it another run.

We verified everything's still working as expected, so let's go ahead and copy the feature flag URL to our clipboard for later. We're now gonna switch over to Datadog and set up a flag trigger so that, when this does make it out into production, if there's any issues that happen, Datadog can automatically turn this feature off, enabling me to stay focused on my product, on my project work.

Now that we've done that, we wanna jump into Slack to let the rest of our team know about this. Chat apps is an important part of context, and as we paste this flag into Slack, Slack will automatically unfurl that URL to give our team members additional context about what this flag is for.

In today's day and age, the developer-first approach is an important consideration. We've taken a look at how LaunchDarkly complements your current tooling, such as code editors, task management, chat apps, and application performance monitoring.

One thing I would want you to walk away with is, it's not just about the technical considerations of a certain piece of software and what it does. It's about how that software fits into your team's overall workflows. And much like this turtle finding their moment of zen, developers should have tooling that enables their deep work. Thank you.

From launching LaunchDarkly at large organizations to supercharging your release pipeline, check out the rest of the talks from Galaxy.