Conclusion How to Take Your Go Development Journey Further

Conclusion How to Take Your Go Development Journey Further #

Hello, I am Kong Lingfei. Unknowingly, our journey of learning Go is coming to an end.

First of all, congratulations on patiently reading the entire column. I believe you have learned a lot. I would also like to express my special thanks to those students who have provided feedback and suggestions for improvement. Because of you, this course can become more and more perfect, and our communication has also benefited me greatly.

Let me first share with you some of my “journey of the heart” in creating this course. Over the past 5 years, I have been constantly learning, gradually moving from a novice to an experienced Go developer. During the learning process, I encountered many difficulties and gained some insights. As someone who loves to share, I particularly wanted to share these solutions to difficult problems and the knowledge I have accumulated with more people, which is why I created this course.

As the saying goes, one is never too old to learn. In the road of Go development, I am still a student just like you. As a student, there are knowledge blind spots. In the process of writing this column, I was afraid of misleading everyone due to my own lack of expertise. Therefore, I did thorough research in the early stages, thoroughly studying the industry implementations of every major knowledge block in the column, in order to build a professional knowledge system. The final quality of this course is basically in line with the initial expectations, and it can be considered as not disappointing the nights I spent and the countless hairs I lost.

Let’s summarize this one-year process with a picture:

Image

I hope these specific data presented to you can give you more confidence in the professionalism of the knowledge you have learned.

It has been my honor to accompany you on this journey of learning Go. Although this course is ending, your learning and growth have just begun. So, how can you go further on the road of Go development?

In my opinion, a complete career of a Go developer will go through the stages of a developer, an architect, and an entrepreneur:

Image

In these three different stages, the role you play will also be different.

  1. Developer Stage: At this stage, you can use Go to complete various development tasks assigned by product managers and leaders, with some architectural design work mixed in. However, these architectural designs are usually limited to the scope related to development tasks.
  2. Architect Stage: At this stage, you are already proficient or master the basic syntax of Go, and you can easily develop a large-scale application using Go. In addition, you can also design the entire system architecture from the perspective of system resources, application layers, and application lifecycle management, ultimately building a high-performance, highly reliable, maintainable, and scalable application that meets product requirements.
  3. Entrepreneur Stage: In the developer stage and architect stage, you are essentially a technology-oriented practitioner. But in the entrepreneur stage, your focus has shifted from technology to products, becoming responsible for the entire business line. This is not because technology is not important, but because you have accumulated deep technical expertise. At this point, technology becomes more of a tool for creating excellent products.

In fact, in the developer stage and architect stage, our ultimate goal is to develop a product, but the emphasis is slightly different from the entrepreneur stage. In the developer stage, our main task is to complete the tasks assigned by technical leaders; in the architect stage, we play more of a role as a technical leader, with greater authority and responsibility in terms of underlying technology. In these two stages, we should also continuously learn and complete our understanding of the Go technical ecosystem, and ultimately try to comprehend the various aspects of the Go technical ecosystem.

To complete the transition from developer to architect to entrepreneur, you need to continuously learn, think, and practice in your daily work. And learning is the most basic and important part of this process. Since this course is a technical column, we will now focus on the first two stages in the next discussions, and talk about how to learn in order to become an excellent developer and successfully advance to become an outstanding architect.

Developer Stage #

As a Go developer, the first stage you will enter is the developer stage. In this stage, we can become an excellent Go developer through three steps. It should be noted that although these three steps are progressive, they can be done in parallel. You don’t have to learn all the basic syntax before studying excellent projects or getting hands-on experience. You can mix and match as needed.

Step 1: Learn Basic Syntax #

We can read one or two classic Go language tutorials in depth. Here I recommend two books: The Go Programming Language and Go Programming.

If you have time and energy, you can also read two books on scenario-based programming: Concurrency in Go: Tools and Techniques for Developers and Go Web Programming.

Image

You can start by reading the book “The Go Programming Language” to master the basic syntax of Go. During the learning process, you may encounter some points that you don’t quite understand or forget after reading them. That’s okay, keep learning. If you still have the energy, you can choose to continue reading the book “Go Programming”. By digesting these two books, you will have sufficient foundation in Go’s basic syntax and lay a solid foundation for the next step of studying excellent projects.

Step 2: Study an Excellent Project #

After having a certain foundation in Go’s basic syntax, it’s time to study an excellent project carefully. Not only do you need to learn the knowledge contained in the project, but also its construction ideas. Let’s take a look at the relationship between years of experience and development capabilities:

Image

As shown in the figure above, there is a parabolic relationship between years of experience and development capabilities: at the beginning, with the increase of years of experience, development capabilities improve quickly; however, when the years of experience reach a certain level, the growth of development capabilities slows down. This is because, after reaching a certain number of years of experience, we spend more time repeatedly using existing knowledge and accumulated experience, so the improvement of development capabilities is limited.

So how can we increase the ceiling of development capabilities? In my opinion, at this point, we should seriously study how to build an excellent project to expand our knowledge and experience. One learning opportunity can benefit your entire development career. “Go Language Project Development in Action” is a course that will guide you in studying excellent projects. As long as you fully digest and absorb the knowledge from this course, I believe your Go project development capabilities will be greatly improved.

Step 3: Project Practice #

After studying excellent projects to a certain extent, you should practice and deepen your understanding and mastery of Go’s basic syntax through practical application driven by requirements.

In the process of practice, using requirements as a driving force for learning is not only the most efficient, but also the process of work output. It can be said to be a win-win situation. However, there are three questions:

  • Where do requirements come from?
  • How to find excellent open source projects?
  • How to conduct secondary development?

Next, let’s look at these three questions separately.

Question 1: Where do requirements come from? #

In my opinion, requirements come from work. These requirements can be specific product requirements assigned by product managers, tools that can help the team improve work efficiency, or tools that can improve personal work efficiency.

In short, if there are clear work requirements, it’s best. If there are no clear requirements, we need to create them. We can think about the pain points and difficulties in our work and turn them into requirements. For example, when the team releases a new version, it is always done manually by logging into different servers and deploying different components and configurations. This not only has low efficiency but also can easily cause production failures due to human errors. At this time, you can convert these pain points into a requirement: develop a version release system.

With the requirements in hand, the next step is to complete them, which means entering the implementation phase. So how to implement it? In my opinion, the essence lies in two words: “copy” and “modify”.

Above, we abstracted a requirement: develop a version release system. If you develop a version release system from scratch, the workload is undoubtedly huge. Moreover, at our current level, even if you spend a lot of time developing a version release system, it will still be inferior in functionality and code quality compared to some excellent open source version release systems.

Therefore, the best approach is to find an excellent version release system on GitHub and conduct secondary development based on that system. This way, you can not only learn the design and implementation of an excellent open source project but also complete the development of the version release system at the fastest speed.

Question 2: How to find excellent open source projects? #

Now we come to the second question we just mentioned: how to find excellent open source projects? Specifically, how to find an excellent version release system on GitHub.

Next, I will share my own method with you. I mainly use 5 steps to search, as shown in the image below:

Image

Here, I will explain these 5 steps in detail based on the image.

  1. Search by language in the GitHub search bar: In the example language:go 版本发布, language:go indicates that we are searching for projects written in the Go language; 版本发布 is the keyword we use to search for projects. This keyword has a significant impact on the search results, so you need to fill it in appropriately. Here’s a tip: if searching for 版本发布 returns very few projects, you can reduce the keyword and search again, for example, search for 发布.

  2. Select Most stars in the Sort options of the GitHub search page: Because there are many GitHub projects, it is impossible for us to go through all the search results. So here, we need to selectively view them. You can sort by Most stars. Generally, the more stars a project has, the more popular it is, and the popularity is likely due to the project’s excellence among similar projects. Based on my previous search experience, some projects with fewer stars may also be excellent. In the end, it still depends on your personal judgment.

  3. Read the description: Since there are many projects, it is not possible to thoroughly study each one. Therefore, it is important to quickly understand the project, and the simplest way to do this is by reading the project description. If the description meets expectations, the project can be opened in a new browser tab or the project link can be saved. After initially filtering through all the projects, the project’s README and code can be examined in detail.

  4. Consider the project name: Some excellent projects may not have a description, so the project name can be used as a judging criterion.

  5. Filter based on the code: If the project being searched is relatively niche and the GitHub search results are few, and the projects listed may not be what is expected, then code can be used as a filter.

By following these 5 steps, we can filter out initial project matches. Next, we need to filter the open-source projects page by page, starting from page 1 and continuing until page 100. By default, GitHub displays 10 open-source projects per page. So, using this method, you may need to research 10 * 100 = 1000 open-source projects. Of course, you don’t always have to go through every single project from page 1 to page 100. If the projects listed after a certain point are clearly not what is expected, there is no need to continue further.

After researching open-source projects on GitHub, I also recommend using libs.garden to find additional open-source projects. libs.garden is a ratings website for libraries and applications, which rates them based on different dimensions, such as growth rate (sorted by the number of new stars), popularity (sorted by the number of stars), activity, etc.

libs.garden includes ratings for many programming languages, including Go. The Go language ratings can be found at https://libs.garden/go. You can follow these 3 steps to find the desired open-source project:

  1. Open https://libs.garden/go.
  2. Determine the category based on the desired functionality. All Go categories can be found in this link. For example, parsing configuration files should fall under the Config category.
  3. Open the relevant category and sort by Popular, as shown in the following image:

Image

After completing these three steps, we start from the first row in the image above and judge whether the current repository is likely to be the package we are looking for based on its description. If it is a potential match, we open the repository and read its README.md to further evaluate. If it is determined to be a possible match and everything looks good, we clone it, write code based on the documentation in its README.md, and test its functionality.

After researching the previous repository, we continue to research the second repository based on the sorting method, and so on, until we find a satisfactory package or the GitHub star count is less than a certain expected value. Using this method, we should be able to find excellent open-source packages that meet our requirements, and these packages are likely to be the “best” packages.

In addition, the awesome-go project on GitHub also lists many packages and tools by category. You can also find resources there. My suggestion is to prioritize searching on GitHub, then libs.garden, and finally refer to the awesome-go project.

By now, we have conducted our own research and found a bunch of open-source projects on GitHub. Why do we need to find so many open-source projects? There are two main reasons:

  • Ensuring that we are building on top of the best open-source project to start from a high point.
  • Filling our own mental image of the Go ecosystem. However, these open source projects are just preliminarily selected, and many of them may not meet our requirements, or even be completely inconsistent with our needs. Therefore, we need to conduct a second round of screening, which can be done by carefully reading the README of the open source projects. If necessary, and if the project is easy to deploy, you can also deploy the open source project and try it out yourself.

After the second round of screening, we have selected some excellent open source projects that meet our requirements. At this point, we still need to do another round of comparison. In this round of screening, we need to compare these open source projects from various aspects and choose the most suitable one for further development. You can confidently tell your boss that this open source project is the optimal solution.

Question 3: How to conduct secondary development? #

Next, you can proceed with secondary development based on the selected project and successfully meet the set requirements. So how do you conduct secondary development on the selected project? I have summarized 5 steps:

  1. Manually compile and deploy the open source project.
  2. Read the project’s README document and follow the instructions to use the open source project, at least run the core functionality once.
  3. Read the source code of the core logic. If there are any unclear parts, you can add some fmt.Printf functions to help you understand the code.
  4. After you understand the core logic or architecture of the project, you can try to add/modify some features that match your project requirements, and then compile, deploy, and debug.
  5. After secondary development, you need to consider whether to synchronize the code with the community, and if necessary, how to do it.

After completing the requirements through “copying” and “modifying,” remember to write documentation and find a suitable time to share your findings and achievements with your team. This is very important as it can turn your learning input into work output.

At this point, you may be wondering: Is it worth it to spend so much time researching and developing a project? I believe it is worth it because this learning approach brings several benefits:

  • Optimal solution: You can confidently tell your boss that this solution is the industry’s No.1 in its category.
  • Efficiency: Based on an existing project for secondary development can improve development and learning efficiency.
  • Output: You can have output during the learning process. Personal growth and work contributions can be obtained together.
  • Knowledge accumulation: Accumulate project libraries and code libraries for your future development career. GitHub is a huge code repository that includes almost all the technical implementations you need in the development process. What you need to do is to find the best implementation and upgrade it to your own. This is a process of quantitative change to qualitative change. Eventually, your development mode will become Ctrl + C + Ctrl + V. This means that your development work will become easier and easier. In addition, what you Ctrl + C is an excellent open source project or code, and what you Ctrl + V is the code improved by you. This means that the implementation after your secondary development based on this open source project or code is definitely the best one in the (you, GitHub's optimal solution) tuple.

In conclusion, I have explained the “Three-Step” learning method for developers, which includes learning the basics of syntax, studying an excellent project, and practicing projects. By using this method, you can not only efficiently develop excellent features but also gain recognition from your boss, ultimately leading to an outstanding employee title in your year-end performance evaluation.

Architect Stage #

In the developer stage, after becoming an excellent Go developer through your own efforts, you may encounter a career bottleneck. At this time, the best way to break through the bottleneck is to transition into an architect (please note that the architect mentioned here refers to a technical architect, not a pre-sales architect). There are many directions for architects, and in the era of cloud-native technology, transitioning to a cloud-native architect is a good choice for those of us who have learned Go language. I am also moving forward on this path and look forward to growing together with you.

To become a cloud-native architect, you need to first learn cloud-native technologies. There are many cloud-native technologies, and the recommended learning path is shown in the following diagram:

Image

By learning technologies such as microservices, Docker, Kubernetes, Knative, Prometheus, Jaeger, EFK, and DevOps, you can master the core technology stack of cloud-native. By learning KVM, Istio, Kafka, Etcd, and Tyk, you can complement your core technology stack. If you still have the energy, you can also learn TKEStack, Consul, Cilium, and OpenShift. Below, I will introduce some excellent reference materials to you.

If needed, you can also refer to my curated list of awesome-books, which contains more comprehensive reference materials.

After learning the above technologies, you already have the technical foundation required of a cloud-native architect and can build the entire cloud-native technology stack comprehensively. What you need to do next is to actively take on more architectural work in your job. Your role in the team will gradually transition from a developer to an architect.

In the architect stage, you should continue learning, but the focus of learning is no longer on specific technical details. This is not because details are not important, but because with your current technical ability, a simple understanding is enough for you to know how things are built. In this stage, the focus of your learning should be to enhance your architectural capabilities. You can do this in many ways, and I recommend the following:

  • Research and understand the architecture design and implementation methods of competing products.
  • Participate in technical conferences and learn about excellent architecture designs of other companies, such as ArchSummit Global Architect Summit, QCon, etc.
  • Participate in technical sharing within and outside the company to learn about cutting-edge technologies, architectures, and solutions.
  • Follow some excellent technical public accounts and learn from their high-quality technical articles.
  • As a creator, actively think and design excellent architectures that meet current business requirements.

It is worth noting that in the architect stage, you are still a technical developer and must not detach yourself from coding. You can maintain your coding abilities by using the following methods:

  • Participate in the development of core code as a coder.
  • Review the pull requests submitted by team members as a reviewer.
  • Read the source code developed by other project members in your spare time.
  • Follow some excellent open-source projects, conduct research, deploy, and try them out.

Entrepreneurial Stage #

Becoming an excellent architect means that you have already, or are about to reach the ceiling of technology. So how do you break through at this point?

In my opinion, a good direction is to break out of the technical circle and treat technology as a tool to create an outstanding product. At this point, you have actually transitioned from a technical professional to an entrepreneur. The ceiling at this stage can be infinitely high for you: through hard work, you can become a manager, president, or even CEO of a company, or you can become the founder of a top company in the industry.

As for how to play the role of an entrepreneur, there is too much content and too much variation, and it does not match the technical nature of this column. So let’s leave some blank space here, waiting for you to fill. In any case, at that time, it will be: with technology in hand, the world is mine!

Conclusion #

Thank you for accompanying me through this 4-month journey of learning Go. However, as you stand at the finish line, you can see that your Go development journey has just begun. I hope that the knowledge and experience I shared with you today can help you go even further on this path.

At this point, you might think that our relationship is ending here? No, it’s not over. You can continue to stay in touch with me and discuss how to develop Go projects and ask any questions about the course by following these two steps:

  • Step 1: Give a Star to the practical project of this course. The IAM project will continue to be upgraded and maintained, and giving it a Star is definitely worth it!
  • Step 2: If you have any questions about the course, or if you want to know the secret of how I stay up late to complete my column while keeping a strong hairline (I won’t share it without a Star, haha), you can add me on WeChat: echo bmlnaHRza29uZw==|base64 -d.

Lastly, I have prepared a survey for you. It won’t take long, about two minutes to complete. It’s mainly to hear your thoughts and suggestions about this course. Looking forward to your feedback! -