When servo system meets software architecture: A random talk about "tidy"

Imagine you have a multi-axis robotic arm in your workshop that has been in use for several years. It worked very well at first, but every time I wanted to change the action or upgrade the sensor, it was like taking apart an old-fashioned phone full of wires - if you move it one place, the whole thing will be messed up. What's even more troublesome is that there is a problem with a certain servo control module and the entire line has to stop. Does this feel familiar?

In fact, the troubles in the software world are surprisingly similar to this. A huge system where all the codes are mixed together is like that robotic arm - one hair can move the whole body. Today we will talk about two concepts that sound very technical but have very practical cores: Clean Architecture and Microservices. They're not magic, more like a smarter set of organizational ideas.

What exactly is bothering us?

Let’s start with the question: Why have modifications become so expensive and dangerous? Often it's because the dependencies are too complex. In the code, "parts" are connected messily, and business logic, database operations, and user interface are glued together. This is like welding the control of the servo motor, the power circuit and the mechanical fixing frame on one board. Do you want to change? The entire assembly had to be disassembled and rebuilt.

This "hard connection" brings several typical troubles:

• Difficult to change: Any adjustment is like a domino, triggering a series of unknown effects.
• Unable to independently test: Do you want to individually verify a core computing module? Sorry, I have to start the whole "robot" first.
• Technology stack locked: A certain underlying library or framework selected at the beginning will be imprinted on every layer of code, making it difficult to replace it in the future.

A cleaner way of thinking

Clean Architecture proposes a layering of concentric circles like an onion. The core idea is simple: keep the business rules (the problem you're really trying to solve) at the center, independent of the outside world. "External details" such as databases, web frameworks, and user interfaces are placed in the outer layer. The inner layer does not depend on the outer layer.

What benefits does this bring? Imagine designing a steering gear control system. The core is "how to accurately control angle and torque" (business logic). This itself should not care whether the signal comes from PWM, CAN bus or Ethernet (external interface), nor whether the position data is stored in a SQL database or text file (infrastructure). That is, it should be pure, testable, and stable.

In this way, when the communication protocol is upgraded from CAN to EtherCAT, you only need to change the outermost adapter, the core module will be intact, and the test will still be valid. It's like replacing the terminal blocks with new ones on a robotic arm, without requiring any changes to the precision gear set inside.

What about microservices? Is it the same thing as "tidy"?

Not exactly, but they often go hand in hand. Clean Architecture is more about how code is organized, while Microservices is about how to physically break up and deploy systems.

You can split a huge monolith application into multiple small services that are independently deployed and run independently according to the clear boundaries drawn by Clean Architecture. Each microservice can adopt a clean architecture internally and focus on a specific thing - for example, one service is only responsible for "server position calibration" and another service is dedicated to "motion trajectory planning".

This is a bit like modularizing an entire complex machine tool into several standard functional units: independent power module, control module, and sensing module. Each module can be independently upgraded, maintained and even restarted without having to bring down the entire production line.

How to get closer to this ideal in reality?

Easier said than done? Maybe start with something small:

1. Identify core: What is the business rule least likely to change in your project? Strip it out.
2. Draw clear boundaries: What are the details (such as which motor is used, which communication protocol)? Try to push them to the boundaries of the code.
3. Dependency points to: Let dependencies always point from "details" to "core", not the other way around.
4. Doesn't have to be perfect: It may not be completely possible at first, but with this direction, your code structure will naturally become more flexible.

Of course, splitting microservices requires caution. It is not a panacea and will bring new challenges such as inter-service communication and data consistency. It's like in mechanical design, modularity adds interfaces and connectors. If it is broken down too much, the management complexity will increase. Therefore, it is more suitable for medium and large systems with a certain scale and clear boundaries.

Talk about feelings

We talk about architecture, ultimately in response to change. The market will change, technology will iterate, and demand will drift. A good architecture should be like a well-designed modular mechanical platform that allows you to respond to these changes at lower costs and with less risk.

It doesn't happen automatically, it requires thought and design. But when you see a new feature being added quickly and stably because of a clear architecture; when you need to replace a key library, but the core business code remains unscathed, that sense of smoothness may be like hearing a machine built bykpowerThe equipment driven by the precision servo system makes a smooth and reliable operation sound - everything is so orderly, each performing its duties, and taking it easy.

This may be the simplest pursuit behind "tidyness" and "service-oriented".

Established in 2005,kpowerhas been dedicated to a professional compact motion unit manufacturer, headquartered in Dongguan, Guangdong Province, China. Leveraging innovations in modular drive technology,kpowerintegrates high-performance motors, precision reducers, and multi-protocol control systems to provide efficient and customized smart drive system solutions. Kpower has delivered professional drive system solutions to over 500 enterprise clients globally with products covering various fields such as Smart Home Systems, Automatic Electronics, Robotics, Precision Agriculture, Drones, and Industrial Automation.