Forem: Toma Puljak

Meeting Developers Where They Are

Toma Puljak — Mon, 22 Jan 2024 00:00:00 +0000

Innovation is rapid, with new tools and frameworks emerging constantly. As a result, developers today have more choices than ever in how they build applications. This fragmentation presents opportunities and challenges for companies building developer tools and platforms. To be successful, you must meet your users where they are rather than requiring them to conform to your ideals.

It's worth considering integrating your product's core functionality into the tools developers commonly use, such as their IDE or the terminal for compiling code and executing commands. Consider the tools and applications developers frequently use; a significant portion of their time—around 80%—is spent within an Integrated Development Environment (IDE). This is why companies should consider porting functionality into CLI binaries or extensions for VS Code, JetBrains, etc.

TL;DR

Meet developers where they are by integrating into existing tools like IDEs, not requiring them to adopt new ones.
Leverage standards like OpenAPI to create clear APIs that enable ecosystem contributions.
Embed functionality directly in UIs developers spend time in to reduce context switching.
API-first thinking reduces friction, future-proofs for new platforms, and promotes customization and community loyalty.

Leveraging Standards for Innovation

The prevalence of APIs has opened up possibilities for integrating with the environments and workflows developers already use. Rather than solely providing your own bespoke interface, you can embed functionality in the IDEs, browsers, terminals and other interfaces developers spend most of their time in. For example, Atlassian's Jira offers a complex web UI for issue tracking. But to reduce context switching, Jira also provides a Visual Studio Code extension so developers can access issues without leaving their editor.

At Daytona, we've embraced this by carefully considering the developer workflow and all the touchpoints with our product. We are working on a CLI binary and a VS Code extension that allows users to manage workspaces and perform all the actions available in the web UI, as well as integration with the JetBrains ecosystem through their JetBrains Gateway tool.

These supporting tools align with the principle of meeting developers where they are, as they spend most of their time coding in their IDE. Integrating tools into the IDE reduces friction and enhances developer velocity and satisfaction. It can be frustrating to switch between the IDE and the browser, especially when managing multiple profiles and trying to open links from different sources. Extensions like Daytona's in VS Code simplify this process by keeping everything within the primary tool and minimizing distractions.

For instance, with Daytona's tools, you can manage workspaces, switch teams, and profiles, which is particularly useful if you have multiple Daytona installations. This approach not only reduces friction but also caters to developers' preferences.

The OpenAPI Specification: A Standard for Innovation

At Daytona, we use the OpenAPI specification to create a clear, standardized API that developers can easily interact with, generating API clients in the appropriate language for different tools. This standardization is not only efficient but also enables new features such as AI interactions, where AI agents using OpenAPI spec can easily understand and interact with your API.

This approach also ties into open-source initiatives, allowing any developer to create supporting tools. For example, someone could integrate Daytona with other platforms or create a Raycast extension for macOS without Daytona having to develop it in-house. By publishing the OpenAPI spec, you empower developers to create tools that suit their needs.

But also it is important to consider the complexities that come with opening up platforms for external contributions. While it adds work, it's an investment that pays off by enabling innovation and collaboration.

The Rise of Intelligent Development Environments

The integration of artificial intelligence (AI) into IDEs is transforming them into Intelligent Development Environments, as forecasted by Manjunath Bhat from Gartner. Local Language Models (LLMs) serve as co-pilots today, but the future may see them become commoditized pilots, integral to the development process. This transition is a testament to the industry's dynamic nature, with IDEs like Cursor and extensions like CodeGPT leading the charge in creating new development workflows.

This constant evolution of developer workflows underscores the importance of creating standardized, extensible infrastructure. Companies that build open and flexible platforms will be best positioned to anticipate and adapt to future changes in the developer experience. Modular architecture based on common standards allows new capabilities like AI to be smoothly integrated over time. The pace of innovation will only accelerate, so developer tools must be designed for interoperability and evolution from the start. Standardization and extensibility will future-proof products as developer needs and environments continue rapidly transforming.

The Compounding Benefits of API-First Thinking

For example, at Daytona we are working on native integrations with VS Code, JetBrains IDEs, our CLI and more. When new platforms gain traction, the community can build clients using well-documented APIs and SDKs. We don't have to build every integration ourselves.

An API-first approach has compounding benefits:

Reduce friction by meeting developers where they already are
Enable community contributions to clients and integrations
Future proof for new platforms by letting the community build for emerging tools

Opening up your platform does require giving up some control. You need processes to curate community integrations before they are published to marketplaces. But done thoughtfully, an API-first approach unlocks contributions and creativity from your user community. Developers want to customize their environment in ways that may not occur to you.

The market will only continue fragmenting as developers gravitate to specialized tools for different tasks. Companies that embrace this reality will thrive. Meet your users where they are now, not where you want them to be. Building in the open creates feedback loops and community ownership that strengthens your product. API-first thinking future proofs you for the next wave of innovation across the incredibly diverse software development landscape.

Key Takeaways

Rapid innovation leads to fragmentation in developer tools
Reduce friction by integrating into environments where users already spend time
Well-documented APIs and SDKs enable ecosystem integrations
Give up some control, but gain creativity from the user community
Meet developers where they are, not where you want them to be
API-first thinking future proofs you for ongoing waves of innovation

The integration ecosystem around developer tools will only grow more complex. Companies that provide the components for others to build on top of will thrive. This means investing in developer experience and documentation for your APIs. When you empower others to extend your platform, it becomes stronger and more adaptable to future needs.

Relying solely on your bespoke interfaces and portals locks users into your narrow worldview. Exposing capabilities through integrations and APIs shares ownership with your community. Developers will reward companies who understand their desire for customization and meet them where they are.

The True Cost of Developer Tools

Toma Puljak — Mon, 15 Jan 2024 00:00:00 +0000

The premise that "all good software engineers are free" encapsulates a common view - that developers inherently create value for a company beyond their salary cost. This seems logical when requesting a raise or evaluating engineering investments. However, does this perspective fully apply when assessing developer tools?

On the surface, the costs of developer tools can appear high, especially for early-stage startups with tight budgets. However, focusing solely on upfront expenses misses the bigger picture.

Quantifying Productivity Gains

The key is weighing the long-term value delivered against short-term expenses. Developer tools aim to substantially boost productivity and velocity. If a tool helps engineers deliver more business value, then it pays for itself many times over.

As engineering teams scale over time, productivity savings and gains from tools like Daytona compound. Within a few years, that investment could be generating millions in added productivity.

Factoring in Developer Satisfaction

Hard metrics only reveal part of the value equation. Developer tools also provide crucial "intangible" benefits by reducing frustrations and stress.

Setting up consistent and optimized development environments relieves engineers from wasting time debugging tooling issues. Automating rote tasks allows developers to focus on high-value programming.

Happier and more engaged developers deliver higher-quality work. Companies can survey engineers before and after deploying new tools to quantify these morale improvements through metrics like:

Reduced setup time for new projects
Fewer context switches between tasks
Increased pride and ownership in work

These gains enhance performance and reduce attrition. In developer surveys, tools like Daytona consistently score highly as drivers of engineer satisfaction.

Driving Recruitment and Retention

Providing a world-class developer experience also pays dividends in attracting and retaining top talent. In today's competitive hiring market, developers have options and care deeply about their tooling and workflows.

Investing in productivity-boosting tools like Daytona signals that a company values and enables engineering excellence. Developers want to work where they can focus on programming rather than operational tasks.

Once hired, developers that are satisfied and productive are much more likely to stick around. When the development environment maximizes their potential, engineers are engaged in their work and invested in the company's success.

The Competitive Imperative

Ultimately, for every company, staying on the cutting edge of developer productivity is not just about costs. It's about competitiveness.

Companies must optimize developer efficiency to survive in an environment of fierce competition for engineering talent and rapid software release cadences. The world's most disruptive and successful tech giants - from Airbnb to Uber - are embracing developer tools as a key strategic advantage.

The cost of not investing in developer productivity can include falling behind rivals, struggles with recruiting, and inability to deliver innovation quickly. For most organizations, particularly scaling startups, the existential question is not whether they can afford new tools - it's whether they can afford not to have them.

Conclusion

When deciding on developer tool budgets, developer satisfaction, recruitment, and retention, forward-looking technology leaders must consider total productivity gains and cost savings at scale.

While dev tool fees can sometimes appear high, when evaluated holistically, investments in developer productivity provide exponential value. They pay dividends across the business - from developers to customers. With developer experience now a competitive battlefield, investing in engineers is not just smart budgeting - it's survival.

Onboarding Lessons from Uber and Stripe

Toma Puljak — Thu, 24 Aug 2023 00:00:00 +0000

As a developer, I understand the frustration of spending valuable time onboarding to a new project or company. Setting up the necessary environment and tools can be time-consuming and inefficient, hindering productivity and slowing development velocity.

During my talk at Infobip Shift 2023 in Miami, I discussed the onboarding challenges and how companies like Stripe and Uber address them with Standardized Development Environments (SDEs). In this article, we will explore the key insights from the talk and delve into how SDEs are transforming the onboarding process and the overall development pipeline. No time to read; you can watch the video recording of the talk at the bottom of this article.

Discover the power of SDEs in boosting developer velocity and creating a more efficient and enjoyable onboarding experience for all.

The Current Onboarding Reality

Traditionally, dev onboarding involves checking out a branch or cloning a repository, setting up the required environment by downloading tools and dependencies, and waiting for builds and tests to complete.

This tedious process can take hours or even days , especially for new hires or when working on multiple projects with different configurations. The inefficiencies of this approach not only impact individual developers but also hinder overall team productivity.

Uber's DevPods: Coding at the Speed of Light

Uber faced a significant challenge maintaining their complex service architecture spread across thousands of repositories and programming languages. They realized developers needed a faster way to start coding and introduced DevPods, an internal development tool. DevPods allows developers to provision a default instance with all the necessary artifacts, cloned source code, and pre-loaded IDE cache. With just a click, developers can start coding instantly, eliminating the frustrating waiting time associated with environment setup.

Uber's DevPods are container-based and leverage Kubernetes as the underlying orchestration platform. Using the production image as the base for DevPods, they achieve a unified runtime from development to production. Additionally, Uber offers different "flavors" of DevPods tailored to specific development needs, such as Go, ML, or web development. This approach ensures that every developer, regardless of experience or project requirements, can start coding with minimal setup time.

Stripe's DevBoxes: Empowering Collaboration and Previewing

Stripe initially struggled with their complex service mesh, making it challenging for developers to test their code locally. They implemented their internal solution, which they have named DevBox, which were long-lived EC2 instances pre-configured with the entire service mesh. Developers could SSH into these instances and test their code on beefy machines. While this approach worked for a small team, Stripe realized the need for a more scalable solution.

Stripe's DevBoxes evolved into Preview DevBoxes , providing instant previews of running code. This feature significantly improved collaboration and streamlined the review process. Developers could now jump into a DevBox without disrupting their current workflow, review code changes instantly, and seamlessly return to their tasks. Preview DevBoxes also allowed non-technical team members, such as project managers or designers, to preview changes early in the development process, providing valuable feedback without the need to push code to staging environments.

The Power of Standardized Development Environments (SDEs)

Both Uber and Stripe understood the importance of standardized development environments (SDEs) in optimizing the entire DevOps lifecycle. SDEs ensure a seamless experience from coding to testing, deploying, and releasing. By eliminating configuration drift and local versus production bugs, SDEs boost developer velocity and eliminate onboarding headaches.

SDEs can be implemented using various tools and approaches. Uber chose Docker as the base for their SDE flavors, while Stripe incorporated opinionated environments with pre-configured service meshes. What makes SDEs truly powerful is the ability to include in-repo configurations, where the environment setup is part of the source code. This means that developers can check out any commit in the project's history and have an environment ready to code, regardless of the specific requirements or legacy configurations.

Dev Containers: The Future of SDEs

One of the most promising standards for SDEs is Dev Containers from Microsoft. Dev Containers allow developers to define runtime, database, and service requirements directly in the repository. Additionally, Dev Containers support IDE specifications, ensuring that developers have the necessary extensions and configurations for efficient coding. This approach eliminates the need for developers to search for configuration files or extension recommendations, making onboarding smoother and more consistent across the team.

SDEs are already available through SaaS platforms like GitHub Codespaces and Gitpod, enabling developers to spin up environments in the cloud with configurations tied to the source code. However, self-hosted solutions like Daytona provide the flexibility to run SDEs within a company's infrastructure, maintaining data security and control.

Bridging the Gap Between Local and Production Environments

One of the significant advantages of SDEs is the ability to bridge the gap between local and production environments. By using the same runtime and configurations throughout the DevOps lifecycle, developers gain confidence that their code will work in production as it did during development. This alignment improves code quality and reduces the time wasted debugging environment-specific issues.

Conclusion: Boosting Developer Velocity Through Streamlined Onboarding

Onboarding developers doesn't have to be a time-consuming and frustrating process. By taking inspiration from Uber and Stripe, companies can simplify and streamline the onboarding experience, leading to increased developer velocity and improved collaboration.

The key takeaways from Uber and Stripe's approaches include:

Introducing DevPods or DevBoxes to provide developers with pre-configured environments and minimize setup time.
Leveraging standardized development environments (SDEs) to ensure consistency across the DevOps lifecycle.
Implementing in-repo configurations and Dev Containers to simplify onboarding and maintain consistency across the team.
Bridging the gap between local and production environments to eliminate environment-specific bugs.

By embracing the practices inspired by Uber and Stripe, companies can significantly improve their onboarding process and boost developer velocity. However, many companies, especially those with limited engineering resources or non-tech backgrounds, may struggle to implement these solutions on their own. That's where Daytona comes in.

Daytona offers an off-the-shelf solution that saves companies the time, effort, and expertise required to build their own streamlined onboarding platform. With Daytona, companies can leverage the power of standardized development environments, seamless collaboration, and bridging the gap between local and production environments. Our comprehensive Dev Environment Orchestration & Management platform automates and standardizes workflows, enabling effective collaboration, secure communication, and efficient delivery of high-quality code.