happy-ferret / development

The development roadmap

Development

This is the Micro development roadmap.

Overview

Micro is the simplest way to build microservices. Our goal is to continue on this mission in an open and collaborative way with the community. Up until now most of our ideas and development have revolved around discussions in Slack. This useful for realtime collaboration so we can move quickly but often means not everyone gets to contribute or we don't have a history for others to go back and look at to understand how we got to where we are.

This repo serves as an open forum for long term design ideas, collaboration and ultimately the roadmap for Micro.

Roadmap

This is a rough plan but we'll provide something more detailed soon

• consolidate all libraries into go-micro
• gRPC integration and interop
• gRPC API for the micro proxy
• go, java, typescript, ruby, python client libraries
• better documentation and end to end tutorials
• simpler kubernetes integration by default
• pluggable wrappers for go-micro itself
• more flexible options dynamically defined as flags and env vars
• improved micro api configuration
• graphql handler for api
• standalone micro server
• quic as a default transport
• nats as a default broker
• define the mucp protocol
• define the mu definition
• reusable foundation services

Philosophy

Micro is the simplest way to build microservices. We have a developer first focus. Our goal is to make developers incredibly productive, to remove friction from their workflow and abstract away the complexities of distributed systems and cloud-native technology.

Our approach to this is very clear. Any new project or any change that we make must come from a developer's perspective.

Here's how we approach taking on new problems.

1. Engage the community about the problem and how we need to solve it.
   • Discussions lead to clarity in thinking
   • We can work through ideas before actually spending significant time writing code
   • We can understand if we're even solving a problem
2. Define the overall scope of the project and name it.
   • e.g Auth, Config, Debug. This is the domain boundary
   • Go Micro deals with inter-service communication
   • Go Config deals with dynamic configuration
   • Micro API is an API gateway for HTTP requests
3. Start with a Go library, this is always our starting point, we want to solve for the developer in Go first.
   • Define separate packages in the Go library for sub-scopes of the domain
   • Start with the interfaces that can then be implemented and be made pluggable
4. Ship quickly and iterate, test the ideas with the community.
   • Go Micro was being used 2 weeks after the first line of code was written. It was called something else back then.
5. Encapsulate as a command/service in the Micro toolkit so that it solves the problem across all languages
   • Go Micro is at the core of all the toolkit components for discovery and inter-service communication
   • Go API is the basis for the Micro api
   • Go Config will be turned into a dynamic config server with a gRPC or HTTP api
6. Everything that we do focuses on simplifying the experience for the developer
   • Provide a zero dependency default experience while being pluggable
   • Abstract away cloud-native and distributed systems. Operations is a separate concern
7. Build on our own foundations rather than those of others.
   • CNCF projects are complex, fast moving, breaking and we have no control over their long term goals
   • We want to own the foundations so we can build on them and focus on making developers productive
   • Where other tools solve complex problems we offload with plugins or abstract them away

Contributing

• Open an Issue to start a discussion with the community
• Open a Pull Request to add a design doc where you've already got strong ideas
• Help shape the roadmap for Micro and be a part of the microservice movement
• Take any real time conversations to the #development channel on Slack