Added files via upload

Created a standard version comment at the top of every file, which reads [//]: # (Version:1.0.0)

Author: ajsebastian

LANGS.md

@@ -1,2 +1,3 @@
 * [English](en/)
-* [Chinese](zh/)
+* [Chinese](zh/)
+ [//]: # (Version:1.0.0)

README.md

@@ -1,5 +1,5 @@
 # How to be a Programmer: Community Version
-
+[//]: # (Version:1.0.0)
 Robert L. Read with Community
 
 Copyright 2002, 2003, 2016 Robert L. Read

en/1-Beginner/Personal-Skills/02-How to Debug by Splitting the Problem Space.md

@@ -1,5 +1,5 @@
 # How to Debug by Splitting the Problem Space
-
+[//]: # (Version:1.0.0)
 Debugging is fun, because it begins with a mystery. You think it should do something, but instead it does something else. It is not always quite so simple---any examples I can give will be contrived compared to what sometimes happens in practice. Debugging requires creativity and ingenuity. If there is a single key to debugging it is to use the divide and conquer technique on the mystery.
 
 Suppose, for example, you created a program that should do ten things in a sequence. When you run it, it crashes. Since you didn't program it to crash, you now have a mystery. When you look at the output, you see that the first seven things in the sequence were run successfully. The last three are not visible from the output, so now your mystery is smaller: ‘It crashed on thing #8, #9, or #10.’

en/1-Beginner/Personal-Skills/03-How to Remove an Error.md

@@ -1,5 +1,5 @@
 # How to Remove an Error
-
+[//]: # (Version:1.0.0)
 I've intentionally separated the act of examining a program's execution from the act of fixing an error. But of course, debugging does also mean removing the bug. Ideally you will have perfect understanding of the code and will reach an ‘A-Ha!’ moment where you perfectly see the error and how to fix it. But since your program will often use insufficiently documented systems into which you have no visibility, this is not always possible. In other cases the code is so complicated that your understanding cannot be perfect.
 
 In fixing a bug, you want to make the smallest change that fixes the bug. You may see other things that need improvement; but don't fix those at the same time. Attempt to employ the scientific method of changing one thing and only one thing at a time. The best process for this is to be able to easily reproduce the bug, then put your fix in place, and then rerun the program and observe that the bug no longer exists. Of course, sometimes more than one line must be changed, but you should still conceptually apply a single atomic change to fix the bug.

en/1-Beginner/Personal-Skills/04-How to Debug Using a Log.md

@@ -1,5 +1,5 @@
 # How to Debug Using a Log
-
+[//]: # (Version:1.0.0)
 *Logging* is the practice of writing a system so that it produces a sequence of informative records, called a log. *Printlining* is just producing a simple, usually temporary, log. Absolute beginners must understand and use logs because their knowledge of programming is limited; system architects must understand and use logs because of the complexity of the system. The amount of information that is provided by the log should be configurable, ideally while the program is running. In general, logs offer three basic advantages:
 
 - Logs can provide useful information about bugs that are hard to reproduce (such as those that occur in the production environment but that cannot be reproduced in the test environment).

en/1-Beginner/Personal-Skills/05-How to Understand Performance Problems.md

@@ -1,5 +1,5 @@
 # How to Understand Performance Problems
-
+[//]: # (Version:1.0.0)
 Learning to understand the performance of a running system is unavoidable for the same reason that learning debugging is. Even if you understand perfectly precisely the cost of the code you write, your code will make calls into other software systems that you have little control over or visibility into. However, in practice performance problems are a little different and a little easier than debugging in general.
 
 Suppose that you or your customers consider a system or a subsystem to be too slow. Before you try to make it faster, you must build a mental model of why it is slow. To do this you can use a profiling tool or a good log to figure out where the time or other resources are really being spent. There is a famous dictum that 90% of the time will be spent in 10% of the code. I would add to that the importance of input/output expense (I/O) to performance issues. Often most of the time is spent in I/O in one way or another. Finding the expensive I/O and the expensive 10% of the code is a good first step to building your mental model.

en/1-Beginner/Personal-Skills/06-How to Fix Performance Problems.md

@@ -1,5 +1,5 @@
 # How to Fix Performance Problems
-
+[//]: # (Version:1.0.0)
 Most software projects can be made with relatively little effort 10 to 100 times faster than they are at the time they are first released. Under time-to-market pressure, it is both wise and effective to choose a solution that gets the job done simply and quickly, but less efficiently than some other solution. However, performance is a part of usability, and often it must eventually be considered more carefully.
 
 The key to improving the performance of a very complicated system is to analyse it well enough to find the *bottlenecks*, or places where most of the resources are consumed. There is not much sense in optimizing a function that accounts for only 1% of the computation time. As a rule of thumb you should think carefully before doing anything unless you think it is going to make the system or a significant part of it at least twice as fast. There is usually a way to do this. Consider the test and quality assurance effort that your change will require. Each change brings a test burden with it, so it is much better to have a few big changes.

en/1-Beginner/Personal-Skills/07-How to Optimize Loops.md

@@ -1,5 +1,5 @@
 # How to Optimize Loops
-
+[//]: # (Version:1.0.0)
 Sometimes you'll encounter loops, or recursive functions, that take a long time to execute and are bottlenecks in your product. Before you try to make the loop a little faster, spend a few minutes considering if there is a way to remove it entirely. Would a different algorithm do? Could you compute that while computing something else? If you can't find a way around it, then you can optimize the loop. This is simple; move stuff out. In the end, this will require not only ingenuity but also an understanding of the expense of each kind of statement and expression. Here are some suggestions:
 
 - Remove floating point operations.

en/1-Beginner/Personal-Skills/08-How to Deal with IO Expense.md

@@ -1,5 +1,5 @@
 # How to Deal with I/O Expense
-
+[//]: # (Version:1.0.0)
 For a lot of problems, processors are fast compared to the cost of communicating with a hardware device. This cost is usually abbreviated I/O, and can include network cost, disk I/O, database queries, file I/O, and other use of some hardware not very close to the processor. Therefore building a fast system is often more a question of improving I/O than improving the code in some tight loop, or even improving an algorithm.
 
 There are two very fundamental techniques to improving I/O: caching and representation. Caching is avoiding I/O (generally avoiding the reading of some abstract value) by storing a copy of that value locally so no I/O is performed to get the value. The first key to caching is to make it crystal clear which data is the master and which are copies. There is only one master - period. Caching brings with it the danger that the copy sometimes can't reflect changes to the master instantaneously.

en/1-Beginner/Personal-Skills/09-How to Manage Memory.md

@@ -1,5 +1,5 @@
 # How to Manage Memory
-
+[//]: # (Version:1.0.0)
 Memory is a precious resource that you can't afford to run out of. You can ignore it for a while but eventually you will have to decide how to manage memory.
 
 Space that needs to persist beyond the scope of a single subroutine is often called *heap allocated*. A chunk of memory is useless, hence *garbage*, when nothing refers to it. Depending on the system you use, you may have to explicitly deallocate memory yourself when it is about to become garbage. More often you may be able to use a system that provides a *garbage collector*. A garbage collector notices garbage and frees its space without any action required by the programmer. Garbage collection is wonderful: it lessens errors and increases code brevity and concision cheaply. Use it when you can.