How a Go product line grew

In 2019 the studio made Go its long-term technical bet and opened an independent product line: not just learning syntax, but shipping real deliverables in the language. For a student team this meant giving up chasing whatever was hot and compounding in one direction instead.

Li Ruiyang from software class 1901 was one of the first Go learners. He worked through the language specification and the concurrency model from scratch and turned what he learned into reusable examples for the studio. He has since graduated and works at Huawei Xi’an, while the product line still runs on the foundation laid back then — the earliest members became the starting point of this timeline.

A Go study group was formed that year, joined by Zhang Yihe, Peng Bo and Liu Haoyu. Studying changed from reading books alone to reading code together and reviewing each other: whoever wrote questionable concurrency logic had to explain it at the weekly meeting. Most of the team’s technical consensus grew out of those arguments.

In April the group released a Go interface code generator — repetitive interface boilerplate is generated by the tool, so developers only deal with business logic. It was the first time a daily annoyance was packaged into something others could use. In the same year Liu Haoyu applied for a Go innovation programme, which brought a stable research cycle and funding; the loop of “build a project, ship results, invest again” took shape.

Zhang Yihe built an open source blog publishing system in Go on top of IPFS. Articles become content-addressed blocks, so publishing and reading no longer depend on a central server, which makes a serverless, decentralised publishing and management setup possible.

For the team the value went beyond a blog engine. Making “no central server” actually work forced them to rethink how data is located, how nodes synchronise and how to recover after a node disappears. Those ideas about light dependencies and self-contained deployments stayed in the team’s architectural preferences.

In June 2023 Cheng Kai (software class 2001), the studio lead, recommended a student from a non-computer-science major to the supervising teacher Mr. Xiong, who was interested in joining. Mr. Xiong hesitated because the student came from another major, so Cheng Kai suggested looking at the work and code the student had already produced before deciding.

The next day the student presented his Jingyi education application assistant, a commercial product that had been profitable for a long time and proved both interest and ability. He also showed an open source C backend framework for handling web requests. After reading the code, Mr. Xiong saw genuine potential in C programming and agreed to take him in. That student is Peng Zechen, the main founder of Fast-Https.

At the end of June 2023 the team reviewed the C web request framework Peng Zechen had open sourced. The conclusion: the foundation was solid — request intake, parsing and forwarding worked, and the performance orientation was clear — what was missing was everything a product needs: a configuration system, certificate handling and operations experience. The ground was ready, a building could go on top.

With that judgement the team fixed its direction: not another practice project, but an open source web server in the spirit of Nginx, evolving on the same technical base. That decision shaped the July kickoff — when expired SSL certificates caused trouble again, the team did not start from scratch, but attached “make HTTPS work out of the box” to the same product line.

In early July 2023 the iDeal studio again found several deployed web apps unreachable, and the root cause was once more an expired SSL certificate. The same failure kept coming back, which proved that relying on people to remember renewals does not work, so the studio decided to build an HTTPS proxy tool that configures certificates automatically. Led by Mr. Xiong, Peng Zechen and Zhang Yihe ran a feasibility study and wrote a small prototype in Go.

Once the prototype worked, the discussion moved from fixing one incident to whether to start an open source web server project. Mr. Xiong argued that the studio had mostly built enterprise and internet applications, and that a lower-level open source project was needed to spark interest, put computer science fundamentals to work and grow people; and that a web server should preferably be written in Go for development speed.

He also set a hard requirement: the server had to be genuinely used by the studio’s enterprise projects instead of staying a demo. He named the project Fast-Https himself — fast for speed, https for native HTTPS and SSL support. Fast-Https was officially started.

At the end of July 2023 the project gained new members: Dou Xingwang and Wang Yujie from computing class 2102 joined the studio. Together with Zhang Yihe, Liu Haoyu, Peng Bo and Cheng Kai, the founding team of Fast-Https was complete.

For a project that had just started, people were scarcer than code. Members had different strengths — some closer to request handling and low-level implementation, some more familiar with business scenarios and deployment — and only with that mix could the work be split. The roster mattered because from then on new modules, tests, multi-platform packaging and releases had stable owners.

In August 2023 the project added the config and cmd modules and assigned them to the newly joined Dou Xingwang and Wang Yujie. config is where configuration enters, cmd carries the command line and the start-up flow; together they are the foundation every later feature hangs from — fix these two first and other modules have somewhere to sit.

It was also the first time the team worked by “module plus owner”: clear boundaries, interfaces first, and progress running in parallel. For a project group one month old, that way of splitting work shaped the pace more than the number of lines written.

In September 2023 the team decided to build a Windows version with a tray control program living in the notification area — start, stop and check status all from the tray. Zhang Yihe was put in charge of the implementation.

On 5 September the team analysed user needs in detail and formally confirmed the Windows desktop application, both to make deployment quick for users and to make testing easier. The significance was a shift from “a tool for developers” to “software for users”: the target audience no longer needs to understand configuration files or a command line.

On 13 September, after the requirements analysis and a survey of existing tooling, the project adopted goreleaser for multi-platform packaging. Before that every platform required the whole build process to be repeated manually, and version drift caused mistakes; with the tool one configuration produces executables for every platform, and releases became reproducible.

Around the platform differences the team also improved logging, background execution and the interface: logs had to be persisted and searchable, background runs had to stay quiet, and the UI had to match each platform’s habits. These changes are invisible, yet they decide how the program feels on first launch.

On 24 September Zhang Yihe finished the desktop version and its testing, and Fast-Https for Windows was released. From that day on users no longer needed a Go toolchain or command-line arguments — download, install, click a few times in the tray and an HTTPS-capable server is running.

For a project only two months old it was a complete loop: requirements, technology selection, development, testing, packaging and release, every step actually walked through. Every later release has followed roughly the same process.

In October 2023 the project added the safe, cache and auth modules, owned by Dou Xingwang, Wang Yujie, Peng Bo and Liu Haoyu. safe covers security policy, cache handles caching and auth takes care of authentication — three basic capabilities no web server can skip, and the step from “it runs” to “it holds”.

The modules were built in parallel by different members, interfaces first and implementations after. That let each person own a complete feature instead of stepping on each other in one large file, and forced the team to think boundaries through — groundwork for the modularisation that followed.

On 22 October, to make later maintenance and extension work easier, the team started modularising the code. They studied several Go modularisation approaches — caddy, plugin and pingo among others — compared how they extend and how tightly they couple, and settled on a module design for the project.

On top of that the team borrowed the request-context pattern from gin-gonic and defined a single workflow: a request enters and moves through a fixed sequence of stages, each business module only caring about its own part. Boundaries survived and execution became regular — new capabilities have a place to plug in, and troubleshooting has a path to follow.

In November 2023 Fast-Https started serving the studio’s own development and test environments. Real usage is nothing like a demo: wrong paths, occupied ports, broken certificate chains — small problems surfaced all at once and the team fixed them one by one. Those failures later became part of the product.

Around the same time some students began using it for coursework such as Software Testing and the Software Engineering course project. Classrooms are harsher on usability — nobody wants to read a full manual for an assignment — which pushed improvements to the install flow and the interface hints.

In December 2023 Zhang Jiayue from software class 2101 joined Fast-Https and took charge of server testing. The team then ran static analysis, unit tests and performance tests across Windows and Linux: static checks kept the codebase consistent, unit tests locked existing behaviour, and performance tests answered the most direct question — is it fast?

Two capabilities were added in the same period: on Linux the server could run as a service, starting on boot and restarting after an unexpected exit; and security work covering response headers and request limits. The first keeps it resident on a server, the second makes it safe to expose to the internet.

By then Windows and Linux were both mature and the modules had stabilised: how to write configuration, how to read logs, how to renew certificates, how to supervise the service — every question had a settled answer. Before the release the team walked each path again to confirm behaviour stayed the same on another machine and for another user.

The meaning of 1.0.0 is a promise: interfaces and usage will not change drastically in the short term, so users can depend on it as infrastructure instead of re-adapting every few months. For a student-maintained project that stability is harder to achieve than new features, and more valuable.

In May 2024 Fast-Https entered the 2023–2024 undergraduate innovation and entrepreneurship programme of North China Electric Power University and, after the mid-term review, was rated national-level excellent.

For the team it was more than a medal. The programme demanded clear goals, progress, ownership and staged results, which forced the team to turn “what we did” into material an outsider could verify — material later reused for competition entries and community outreach.

In May 2024 Fast-Https entered the 2024 Challenge Cup capital university entrepreneurship plan competition, made it through the university round and won third prize in Beijing.

Entrepreneurship competitions care less about code quality than about whose problem it solves, how large the market is, and why others cannot build it. Answering those questions forced the team to re-examine positioning and differentiation — that narrative later became the standard introduction to Fast-Https.

On 25 May 2024 Fast-Https passed the review of Huawei’s openEuler technical committee and officially joined the openEuler community. The record appears in the openEuler community operations report for May 2024.

Joining placed the project inside the domestic operating system ecosystem: code has to survive reading by outside developers, contributions have to follow the community’s process, and questions have to be answered promptly. For a student team it marked the turn from “we build it, we use it” to “others can use it and will have opinions”.

In May 2024 Fast-Https was competing in the China International College Students’ Innovation Competition 2024 (formerly “Internet+”), one of the largest student innovation events in the country. Judges look at technical depth, and at whether the project can keep running.

Preparing was a systematic review in itself: compressing more than two years of development into a few pages, and explaining why it was built, what was built and why it should continue. Every question that could not be answered pointed at a gap the product had to close next.

In June 2024 Fast-Https took part in the national college information security competition. Unlike entrepreneurship events, this one is about the technology itself: protocol details, certificate handling, shrinking the attack surface — everything has to survive questioning.

For a project positioned as an HTTPS server, that kind of scrutiny is exactly right. The team brought the analysis back into development and revisited certificate loading, request validation and security trade-offs in the default configuration — changes that add no features but make the product more trustworthy.

Beyond competitions, iteration is the main line. Fast-Https keeps serving the studio’s enterprise projects and course practice, and feedback from real traffic is more direct than any test case: a path difference on one platform, a broken certificate chain, state left behind after an abnormal exit — each is fixed and folded back into the code.

Collaboration in the open source community has become routine too: issues, pull requests and releases set a steady rhythm. For a project that is still growing, the version number will stop at some figure; the iteration will not.