5 wonders that non-programmers don't know

It's been more than 20 years since I started working. Even so, I still remember the vision of graduating from college and starting work. Until then, I spent most of my life in school, except for a handful of summer jobs that didn't have anything to do with programming. Although most of my expectations for the job came true, I found many amazing things in the first few years of my career, and here are the first five things:

1. Complexity after system integration

Since there are no ingenious algorithms and the entire application is using the basic data structure, does it seem that there is no challenge in working here? wrong! I quickly realized that the system was highly complex, not because of the complex features, but because too many simple functions were integrated together.

2. Few ingenious algorithms

In college I got a master's degree in Computer Science and engineering, and I learned the communication system, which included the course of signal processing, error correction code, queuing theory and so on. We also have core computer science courses like algorithms and data structures, I love these classes and I think it's cool to learn these clever algorithms and data structures, so I'm looking forward to seeing them at work.

My first job was to be a software engineer at a cellular phone exchange center in Montreal, Ericsson. There's a lot of code to control the build, hang up, roam, and so on, but I feel a bit disappointed when I see that these features are done with the most basic data structure and algorithms. Most interestingly, I found that the code used to track the user's roaming status was made up of more than 1000 two-fork trees, and the end three digits of the user's mobile phone number determine which tree the user is in. When you need to find this user, according to the user's phone tail find the user's tree, and then traverse the tree to find the user. In addition to this, the others are linked lists and even simpler data structures.

3. Never finished software

Before I started working, I felt that when I developed a feature, this feature was developed. But in reality, you will often have to return to this feature. Sometimes it's because it's not exactly what the customer wants, it may be because you need to add more functionality to it, or if you want to combine some similar features or fix a bug. Anyway, it's normal to continue programming your code.

In college, we often start a program from scratch, but it's almost never seen in the real world. Of course, in addition to the new features you do, the code will always fit into the old code. Because of this, a large part of the effort to do new functions is to read and understand the old code. This is a skill we haven't practiced in school.

4. Writing is important

It helps to express ideas clearly through writing. In a way, writing code is very similar to writing, both of which require you to express your thoughts clearly and without ambiguity in a structured way. Email is certainly not finished, but there are documentation for the features you have developed, a bug report that requires a clear description of bugs, and an explanation of the bugs you fix. Writing in college is not the point, but if you're writing well, it's definitely a bargaining chip in your job.

5. Interpersonal relationships

Programming seems like a rather lonely job-you need to do a function so you sit down and implement it in code. But in fact, you and other colleagues will have quite a lot of communication. You will discuss the design with your co-workers, you will review the new features in the meeting, and you will discuss your code with the tester.

Learn euphemism and tact, in the communication is very helpful. If not, you have to learn. In this regard, there is a bestseller-Carnegie's "weakness of human nature." If you have not read this book, I strongly recommend that you read it.

In so many sets of systems I've worked with, I've seen something in common: Most features are very simple, but just because there are so many simple features, the subtle (or less subtle) interaction that comes with integrating these features causes bugs.