Technical articles are an effective way to enhance expression skills and carry out technical accumulation. Unlike simple technical notes, I believe a technical article should be a solution to real problems or new technical ideas, rather than a mere assemblage of technical points.
Regarding how to write a qualified technical article, I have been contemplating this recently. This article will explore some of my thoughts and steps when writing articles, as well as tool recommendations and the implementation of CI/CD automation publishing.
Topic Selection
I don’t have a clear objective for selecting topics for technical articles; I mainly discover new technologies or optimization ideas from my accumulated technical notes and further research and expand them into an article. The main ideas come from the following three aspects:
- Accumulation of technical notes
- Some technical ideas that come to mind
- Introduction and implementation of open-source projects
Accumulation of Technical Notes
Although technical notes usually comprise individual technical points, during the accumulation process, one can discover combinations of various technical points, leading to useful ideas. Moreover, new accumulated technical points can be combined with existing implementations, making existing technical solutions more convenient and user-friendly.
Daily technical accumulation is very important, not just for writing articles but also for organizing and reviewing the content encountered. The process of organizing will deepen understanding, and recording makes it easier to refer back when needed. Technology tends to decline if not used; if not engaged with specific content for a long time, it’s easy to forget it. However, if it’s recorded in a timely manner, one can quickly get back up to speed when needed, avoiding the cost of repetitive research.
Accumulation of Technical Ideas
In addition to accumulating from technical notes, I also record various other technologies or optimization ideas that occasionally come to mind as backup topics. These are usually simple descriptions consisting of one or two sentences, for example:
From time to time, I delve into these topics further and implement them in engineering, summarizing them into a technical article.
Introduction and Implementation of Open-source Projects
Some articles in the blog introduce my open-source projects and their implementations. Open-source projects are also a type of technical product, and technical articles serve as the product documentation.
This approach of treating projects and articles as products fosters a mindset of considering things from the user’s perspective. The content should cover the following points:
- Applicable scenarios
- Usage process
- Parameter introduction
- Update logs
Maintaining documentation for open-source projects is a considerable workload. While technical implementations will change, it is often challenging to update documentation content in a timely manner, which reflects personal limitations of energy and should leverage community power for co-construction.
Pre-research and Implementation
After determining the topic for the technical article, I establish a concrete implementation goal, verify feasibility, and validate the entire technical approach. Usually, this step encounters no issues because the accumulated technical points are ready to use in an appropriate form.
Taking UE technical articles as an example, when selecting topics, the first step in pre-research is to determine the following questions:
- Is it technically feasible?
- Can it solve some actual pain points in projects?
- Are there similar articles or solutions available? If so, what are the advantages of the new solution?
- What is the integration cost? Is it a complete Plugin or does it require changes to the engine?
Technology should possess universality, striving to implement solutions in a way that minimizes integration costs. Some implementations may require modifications to the engine, which should be avoided whenever possible, using some Hack techniques for alternative implementations. Because making changes to the engine is a heavy activity that cannot support precompiled engines in the Epic Launcher, the integration cost is high, and different engines may require separate adaptations, making it impossible to achieve universality in technology. During implementation, one should avoid making changes to the engine and consider cross-engine version implementations.
Regarding the technical details described in articles, the content has the following requirements:
- Screenshots of the call stack for key code
- For engineering-related content, testing cases must be provided
- All code must undergo personal debugging and validation
- Citations of technical descriptions should be accurately documented
Technical articles are, after all, public content, which may serve as guidance for developers with similar needs. If the author is vague, it may mislead others. Therefore, striving for accuracy in expression is vital when writing technical articles.
Article Structure
I generally follow a five-paragraph structure for technical articles:
- Current needs and pain points, inadequacies of existing solutions
- New technical approach
- Implementation issues and corresponding technical analyses
- Presentation of results
- Conclusion and summary of references
Clearly convey the background, implementation methods, dependent technical points, and ultimate results, including data, performance comparisons, subsequent optimization ideas, and reference materials, in this article.
Iteration
The content of technical articles is limited by the level of technology and the technological environment at the time. If better implementation methods or updates to engine versions arise in the future, previous content may become obsolete and require revisions of past articles.
This is also a process of reorganizing past technical content; textual content can easily iterate, while video content cannot do the same. I have previously recorded technical videos, but the content has become outdated with updates to technology and engine versions, and cannot be modified. This is one of the reasons I don’t enjoy recording videos.
The iteration of content in technical articles can be summarized in the following aspects:
- Optimizations in implementation and ideas
- Adaptation of new technologies
- Expansion of original content
- Supplementing related technical knowledge
For example, in my blog series of articles about resource checking solutions:
- UE Resource Compliance Checking Tool ResScannerUE
- Customization of Property Panels in Unreal Engine
- Automation Practices for Resource Checking Based on ResScannerUE
- Multi-Stage Automation Resource Checking Solutions in UE
Arranged in order of publication, the trend shows “first an implementation solution” followed by continuous optimization and enhancement of the implementation based on daily technical accumulation. In this process, new technical content is discovered, forming a positive loop of technical output and input, further building up technical notes, and repeating the cycle.
Publishing
I have built a complete CI/CD publishing system based on the Hexo blog system. From creating, editing, publishing, to updating, it can be implemented in a one-click manner.
CI/CD is a workflow of Continuous Integration and Continuous Deployment, perfectly suitable for the publishing process of blog content, implemented via push hooks based on Github Actions. Applying technical thinking to daily life can significantly enhance efficiency.
Locally, you only need to manage all the original markdown files, and the entire publishing process is automated. Additionally, I have written a quick publishing option based on iOS shortcuts, allowing for one-click automatic publishing of new blog content after editing.
You can even say hey siri, update my blog, and it will accomplish the update, filled with a sense of whimsy.
Tools
To do a good job, one must first sharpen their tools. While the content is the most important aspect of writing articles, having the right tools can greatly enhance the creative process. Here are some tools I use daily:
- Blog generation: Hexo
- Deployment: Github Actions
- MD editor: Typora
- Knowledge management: Obsidian
- Image hosting: PicGo/Tencent Cloud OSS
- Note-taking: Lepton
- Diagramming: draw.io
- Screenshots: Snipaste
- Synchronization: Dropbox
Tools are merely aids; it’s crucial to persist in producing content and not become a slave to the tools, wasting time on environment setups.
Conclusion
This article documents my thoughts and creative processes in writing technical articles, the implementation of applying CI/CD technology in article publishing, and recommendations for tools I use daily.
Writing articles is an activity that brings me joy, allowing for technical accumulation and value output. As described on this site, each article is a growth process.
