🍎Our Newton's Metaphor

In this post, we dig deep into why, what and how of modelling Kloudi. The "apple that fell" moment for us to build Kloudi.

To all our early subscribers this is second post of our newsletter. In our previous edition we laid out a map to the Universe of Tools we are working with and what its elements are. But before we dig deep into interactions of these elements here is the "apple that fell" and become the reason behind our modeling for Kloudi.

To those who stumbled upon this newsletter first here is the link of our newsletter for you to catch up on our previous post and any upcoming stories from us.

Kloudi, why 🤨?

TL;DR - Building software has become very complicated & cumbersome and prone to a lot of time and productivity leak for any developer. 

Building software to productize a solution has been driving innovation in technology for a while now. In the past decade the paradigm shift from mammoth sized monolithic solutions to SaaS, where decoupling the problem and solving it on a micro level though has fastened the pace of problem to solution mapping , yet has lead to multiple bridges between tools hence a lot of leaks.

The Paradox of Choice

For people - business and/or individuals, referred to as developersmoving forward - who are building new products/solutions things are getting complicated. SaaS has caused choice overload in every vertical of every business. These choices then translate to developers spending time sniffing through information across these tools and then stitching them together. Imagine if you had multiple Facebooks/Twitter/Instagram where cognitively it's already impossible to consume all the information but you have to, since it's no longer your personal social calling but your bread and butter and to add to it for some it may even lead to life and death situations. Hence a cumbersome tale.
To elaborate further just on a workflow to workflow basis in the life of a developer, the time dissipated in the entire cycle of info gathering is 20-60 mins per bug in a debugging workflow. This is the time lost even before a developer actually gets to fixing an issue or even pinpointing a solution, which takes its own additional time. A cumulative time loss of all these workflows and seep throughs can be mapped to 17.3hrs/week per developer.

Big Bang of Technology

In this universe of choice, because of open source and a community flocking around every idea has led to rapid pace of building new solutions for every problem, new or old with enough audience for each. This means that not only the universe of choice is big but it is also ever expanding. That's the how evolution works, and that's how technology is evolving as well! As a result of the segmented solution approach and the expanding universe complexity has become norm.
To add to the complexity of choices, the staggered data, the mental models of putting this data together being limited to the mind of each individual developer, there is an added complexity of the manner in which the existing tools are built. Every tool is a complex dashboard needing time from a developer to understand how it works and how it can be customized to suit their needs. Every dashboard is complicated to the extent that the format of query in each of them differs. Data suggests that it can take up-to 3-months for any new developer in any ecosystem to be on-boarded and come up-to pace with the existing dev cycle of the company due to these complexities.

The experience of building software is poor, duplicative and individualistic because of Paradox of Choice and Big Bang of Technology. Every software project is about integrating lego blocks in the form of SaaS tools or modules with variable quality developed mostly in isolation, for a particular purpose leading to a high failure rate. 

Our goal here at Kloudi is to make the process of developing software **SIMPLE** eliminating not only the complications along the way but also making it more accessible and more productive.

But, how 🧐?

TL;DR - Unlock a developers's true potential by making accessibility and usage of dev-tools simple.

At Kloudi we want to fix the experience of building software to make it more simple and more efficient. The first step towards doing that is by rethinking how a developer or a development team uses dev-tools to build the technology. We call it project Refactor.

Refactor - Converse, Collate, Collaborate, Customize

There are 4 pillars of simplicity in Refactor

  • Connect - Since we are based on the principle of simplicity the first step is to build the one stop access for all dev-tools - Swiss Knife for dev-tools. This translates into Kloudi being the layer that connects all the tools that a developer uses in one place. We do this by a simple plugin mechanism and connecting distributed data points across your tools to make sense of and take action on.

  • Converse - Language and having conversations is that first thing anyone learns before graduating to thinking in terms of code or making data models. Every action in the mind of a developer, every mental model is driven by simple conversations or simple sentences that they plays in their heads or communicate with their teammates. We wanted to have a platform driven by exactly this intent thus Natural language search based interaction is what drives control of all tools and hence sticks to the paramount principle of simplicity.

  • Customise - Queries driving results are custom to the data an individual views. The idea of customise is to have query permutations leading to the exact result that can be actioned upon. This also means a many to one mapping of result and also code fix that can be suggested.

  • Collaborate - Queries are mental models and can be subjected to knowledge sharing across teams. One query repeatedly used can help save a team's time if exposed to the entire team. We help users do that by a simple query sharing mechanism. We are bringing word of mouth driven knowledge sharing to software development.

Cool! Tell me more about Kloudi 🤩?

TL;DR - Kloudi is IDE plugin that helps you take back control of your tools 

With the principle of Refactor as a driving force we are building Kloudi that helps developers and development teams take control of their tools. Kloudi comes currently in two form factors - an IDE plugin and a central web-app. We started with Visual Studio Code plugin since that's what most of our early users use. Moving forward we will have plugins for all the IDEs and terminals (bash environments) so that irrespective of where a developer spends their time we are able to provide an experience that helps them save time and be more productive.

We also understand that developers work with team members who do not necessarily code or work from an IDE but these people are equally important in the life cycle of innovation and solving problems. Our web-app exists for such an audience and is built to cater for their needs e.g; Engineering Manager, QA.

- Nitish and Sneh


Appendix

  • Refer these slides in case you want to understand Why Building Software is becoming difficult every day.

References

  • https://www.blissfully.com/blog/the-saas-graph/

  • https://stripe.com/en-in/reports/developer-coefficient-2018