Recall in a blog last year, I discussed the goals of what’s next for ActiveState. At that time we had recently sold the Stackato business to HP and our plan was (and is) to focus on our existing commercial language distributions and developer tools business.
While we’ve been reconnecting with the Perl, Tcl, and Python communities, one of the ideas that’s emerged during this time is that we really want to take ActiveState forward based on a unified product stack–one company with one cohesive and unified business. We don’t want to end up with two business units like we did before (Stackato and tools and languages). We want to broaden the depth and breadth of our tools and languages business, as opposed to setting up another silo-like business. The result is that over the past many months we have been exploring a number of new product ideas and initiatives that are a strategic fit with our existing product mix.
But along the way, what’s become apparent to us is that we’ve built up a lot of technical debt. Given that ActiveState has been around since 1997, it’s not surprising that over the past two decades it has crept into the process. Wikipedia defines technical debt as: “A concept in programming that reflects the extra development work that arises when code that is easy to implement in the short run is used instead of applying the best overall solution.”
Programmers refer to it as ‘design debt’ or ‘code debt,’ and it can found in the largest of companies, as well medium and small companies, who have grappled with the trade-off of taking the time to clean up legacy systems versus creating client-facing applications geared towards generating revenue. This potentially “silent killer” is certainly what any company needs to watch out for as they race to get the latest version of their product to market and chase revenue to grow their business. Each company needs to take the time to review and determine what level of debt that can (or should) be tolerated, and which system in the company can support a particular level.
More Than Just Code
All good companies come to a point in their evolution where they go after their technical debt and they tackle it in different ways. But we’re not restricting our evaluation to just code–we’re looking at the whole organization. This includes looking at various business processes, workflows, and programming/development environments, and determining what makes sense going forward.
Given our vision for a unified product stack, we’re using this opportunity now to look at the best overall solution for ActiveState and tackle both the technical and process debt that has been built up over the past two decades. We need to find the biggest areas of debt and eliminate some of those “easy, quick fixes” we implemented which were not the best overall solution for the long term. Effectively, what we’re trying to do is build a new, more solid foundation for our company that gives our customers and employees, both present and future, a better experience by creating an environment that is compelling for everyone so we can keep building products that are phenomenal.
Foundation for Growth
Companies (startups in particular) get so busy putting out the immediate business fires and fulfilling customer requirements, that they don’t have the time (or take the time?) to do things “the right way.” However, the shortcuts taken in the past eventually catch up with you. Cleaning up this debt is a prerequisite to successfully executing any growth opportunities for a company.
As ActiveState continues to innovate and explore a number of ideas and initiatives around our existing product stack we are also tackling our technical and process debt. The result will be continued happy employees, happy customers, and the platform to take ActiveState to the next level.