Over the past few years, I’ve been building all sorts of programming-related tools. Some of these tools are used to guide software development work, some are used to learn to program, and some are written purely to improve the technology. After I’ve written more and more tools and been exposed to more and more tool ideas. I wanted to write an article to document some of the changes that occurred in the process.
How to build tools?
If you have extensive knowledge of the tech stack, and relatively plenty of time, then add some passion and you can write a not-so-bad tool.
In my short ten-year programming career, I have tried different levels of technology stacks, and I have generally understood how to make various tools from the bottom to the top. Tools to connect the physical world:
- Pure embedded system programming. Just need an Arduino IDE + an Arduino development board, with a variety of input devices (such as sensors), with some outputs, this is a simple computer prototype.
- Embedded operating system programming. For complex scenarios, you also need a simple operating system to help you schedule tasks. You can simply write a task scheduler, or develop applications based on uCOS, FreeRTOS, Contiki, Zephyr, and other systems according to your capabilities.
- GNU/Linux-based embedded system programming. For most people, only a Raspberry Pi + Python can write a cost-effective machine learning-related application; or running an operating system such as OpenWRT on a router is a more cost-effective solution.
- Compile the GNU/Linux OS. If you have time, you can use tools such as Linux From Scratch to compile an operating system for your own use.
- Embedded programming in the age of IoT. I like to use the ESP32 (successor to the ESP8266) for my smart home, they come with WiFi and Bluetooth, and there are various solutions to emulate existing devices and configure HomeKit. Considering the cost, for developers without a hardware foundation, adopting Android Things or Windows IoT is an easier choice. I haven’t played Fuchsia, it might be good too, haha.
Connecting to the physical world is expensive for most developers, after all, the hardware is so expensive (consider the Raspberry Pi, which is pretty good too). So, all we can do is develop some tools behind the operating system.
- desktop application. In the past, I tried to use QT to develop some desktop applications, and then I changed to PyQT / PyGtk + Python, and now I have turned to Electron, and developing desktop applications with web technology is as simple as that.
- mobile application. Although React Native and Flutter are very good mobile application frameworks, I have also developed a series of applications with them. However, architecturally, I prefer a hybrid architecture application, Flutter + Ionic / Angular, or RN + Ionic / Angular.
- Applets. I discuss applets, they all have various censorships.
- Command Line Interface Application (CLI). For daily work, we only need a simple command line, for the front end, maybe Node.js is enough, for the back end, maybe Python is enough; however, now I prefer to use Go Develop CLI applications.
- web application. For us, considering the cross-platform features, I tend to use back-end Serverless + front-end Angular + micro front-end architecture to develop tools for web applications.
- Browser plug-in. Occasionally I also develop some browser add-ons, but when I switch to the Firefox browser, I’m thinking about how to migrate the old Chrome add-ons.
May these fancy introductions give you some ideas for your new tool. Then you can string together this knowledge to develop some interesting applications:
- Continuous integration warning light based on Arduino + Raspberry Pi.
- Simulate various hardware through ESP8266, deploy a server, and realize remote.
Now, we’ve gone far, far, back to the point.
Find an idea
With the above technology stack, you can easily develop a tool.
half of the content
Tool development mode
For development tools, there are some particularly fixed development patterns. I’ve probably gone through three stages as well, and they’re probably three different modes:
- “Do whatever you want” to build a wheel mode. That is, I do what I like to do, and what I lack, I add.
- The model of “Patterns and concepts of transformation”. I look for some principles and patterns from certain places and deposit them into the tools.
- “Standardize a specific process” mode. I turn processes, processes into tools to weaken the role of people in the process.
“Do whatever you want” to build a wheel
Nothing to say, I just do what I like. However, it has some points that you can play with:
- Accumulate technology and materials. It is not easy to build a wheel at will. You must have a strong learning ability to achieve the goal of freedom. You must be able to weld resistors and take a hammer.
- Find off-the-shelf, and learn from existing tools. You can learn some good things from them.
- Build and continuously improve commonly used tools. With continued use, you can perfect the tool until it works. Suddenly, I had an idea to write my own browser (based on Electron), lol~. If boosting technique is important to you, then this is a very good boosting point.
Then, like me, you can happily watch your bug reproduce on your own computer every day, and then think that it should be fine on other computers. I’ll fix this bug when I’m free.
Transformation principles and patterns
This is probably a big harvest from last year’s tool-making. When I was discussing building tools with my colleagues in the company, I discussed principles and patterns, and then I will use tools to carry them.
Such things as principles and models are themselves some precipitations of our daily work. Therefore, they are particularly easy to convert to tools. Dog head, we can also develop a tool that imparts numerous ideas and patterns.
Another great meaning of transformation principles and patterns is to tell you that you can build your own tools by learning from others. So, last year when I was writing Coca, I did this:
- Find various papers.
- Loads various papers.
- Read various papers.
The numerous documents were then transformed into my tool. Although most of the papers are very well written (I think after reading 100 papers, after writing a tool, I can write a paper that is better than 99%), we easily copied a few others. months of research experience.
Reading from books is also a good idea, but most technical books tend to be practical and difficult to convert.
Standardize specific processes
If the first two are to build wheels, then the standardized process is the platform. I’ve been working on various maturity models recently, and they have five stages. I prefer the definition of an open-source maturity model officially written by GitHub:
- Ad-hoc – Uncontrolled, reactive, and unpredictable processes that are generally driven by people with little coordination or communication. Individual heroism is required for success.
- Processes are managed if they are somewhat documented and have the ability to provide consistent results. Success depends on discipline.
- Processes are defined when they are recorded, standardized, and incorporated into other processes. Automation is vital to success. Measured – Quantitative process management. Measuring metrics versus corporate goals is absolutely key.
- Optimized means that the process is constantly and consistently improving via incremental and inventive adjustments. Success is dependent on lowering the risk of change.
- After abstracting this passage, we can mention the process like this:
Individual practice -> team practice process -> standardized process as a tool -> integration into other processes as part of the platform -> continuous improvement of the platform
Again the abstract is:
Practice -> Patterns -> Tools -> Processes -> Platforms
Yes, it’s that simple. Therefore, to develop a tool for this model, you only need to find the existing maturity model, and then it becomes a platform.
Without wheels, where do KPIs come from?
Without technology, where would the wheels come from?
No interest, where did the technology come from?
What are KPIs?