Bitloops, because we are believers.
The founding team at Bitloops has been obsessing over developer productivity for a few years. We constantly say to each other: “how cool would it be if software was built in such a way that there was no technical debt, where developing a feature for a complex and mature product was as easy as developing a feature for a new (greenfield) application? Why can’t we achieve this?”
This may seem like an impossible vision, but history has shown us that transformative ideas are necessary and possible. We had the printing press, the steam engine, radio and tv, as well as the computer in the last 200 years that radically changed the world for better and provided the impetus for exponential growth.
Software development specifically has gone through rapid changes as well, starting off with assembly language, low-level programming languages, compilers until we reach modern day software programming that uses high level and object oriented programming languages. But what’s next? How can software development take the next leap?
In order to answer this question, it's necessary to think about how software is managed, deployed and executed, and build a developer platform that takes advantage of all the best existing tools, frameworks and infrastructure. We need to think about software development from a first principles perspective, taking into account current possibilities and limitations such as cloud & distributed computing, interoperability, network and latency, artificial intelligence and machine learning.
So, what do we know?
We know software development is increasingly frustrating - ask any software engineer. And there are multiple reasons for this:
- Inappropriate and inflexible architecture
- Poorly maintained structures for data storage
- Badly expressed code without regard to established patterns like object-oriented design and dependency injection
- Low cohesion when building microservices
- High, and ill-conceived, coupling between microservices
- Unreadable code, even by experienced developers
Essentially, this boils down to technical debt, and it's the cumulative cost of every poor decision by every engineer over time. Technical debt inevitably becomes a bottleneck for product development and features that might have taken days or weeks to roll out when the company was younger now require months of development time.
At the core, the issue is complexity and how to manage it. Complexity is the greatest obstacle of growth for any software company. Time to market and development costs increase exponentially as code base complexity increases, as more developers are required to extend and maintain the application, which further exacerbates the problem because there are even more developers that can increase the complexity of the application.
Even the best and most experienced software engineers struggle to add new code on complex and complicated source code. It becomes almost impossible to debug and engineers will simply resign, which further exacerbates the problem as knowledge of how the software works is lost. It’s a death spiral many companies have experienced over the years, but it doesn’t have to be this way - there is a better way to develop and manage software.
And, what do we believe?
We believe the software revolution is just beginning and will be the main driver of change in the next 20 years. We also believe that speed and simplicity can go hand in hand, and that investing in simplicity will greatly increase speed. In fact, software development is much more than coding, it's about coordination, communication, analysis, design, testing, project management, and domain expertise.
We believe that:
- Less code is more (and better) code
- Software must solve a problem, transforming ideas into applications that deliver value
- Abstraction, automation and agnostic platforms (interoperability) are essential principles in modern-day programming
- Event-based architectures are necessary for maximum interoperability and flexibility
- Designing and planning first is the route to programming efficiency
- Building software should be about enabling people and organizations to focus on what really matters – identifying and solving problems to better serve their users
- A visual language that can be shared by domain experts and developers will greatly improve output and reduce complexity
- Multi-developer and synchronous collaboration
- Governance, protocols and controls are essential and necessary to avoid unnecessary complexity (and simplifying the necessary complexity)
- Built in version control and code review systems
- Tests should be considered 1st class citizens in all development steps
Oh yes, we are big believers, and that’s why we are building Bitloops, a developer platform that will allow developers to build software using best practices and methodologies, creating systems that are testable, maintainable and extendable, 10x faster and better than current options.
At its core, Bitloops has the Open Source Bitloops Language, which is a 4th generation, high productivity programming language that guides teams to write code following the agreed industry best design practices such as DDD, Clean Architecture, SOLID and Clean Code.
Because we are believers, we want to push the boundaries of backend development to a whole new level, where developers and domain experts once again spend most of their time thinking, designing and solving problems in the best possible way.