JavaScript exploration: the importance of writing maintainable code

Fixing software bugs is expensive, and the cost of these bugs increases over time, especially when

Fixing software bugs is expensive, and the cost of these bugs increases over time, especially when these bugs lurks and gradually appear in released software. It is best to fix a bug immediately when you discover it. At this time, the problem that your code will solve is very clear in your mind. Otherwise, you move to another task and forget the specific code. You need to view the code after a while:

• Spend time learning and understanding this problem
• It takes time to understand the code for the problem to be solved

There are still problems, especially for large projects or companies, the guy who fixes the bug is not the one who writes the Code (and found that the bug is not the same person who fixes the bug ). Therefore, it is necessary to reduce the time it takes to understand the code, whether it is the code you wrote yourself some time ago or the code written by other members of the team. This is related to the bottom line (business revenue) and the happiness of developers, because we should develop new exciting things instead of spending hours and days to maintain legacy code.

Another fact related to software development life is that it takes much time to read code than to write code. Sometimes, when you focus on and think deeply about a problem, you can sit down and write a lot of code one afternoon.

Your code can work very quickly, but as the application matures, there will be many other things happening, which requires you to review, modify, and adjust. For example:

• Bugs are exposed.
• New features added to applications
• Programs work in new environments (for example, new browsers appear on the market)
• Code Change Purpose
• Code should be completely re-written from the beginning, transplanted to another architecture, or even using another language

As a result of these changes, the code that is rarely written by several hours has finally evolved into reading the code for weeks. This is why creating maintainable code is crucial to the success of the application.

The maintained code means:

• Readable
• Consistent
• Predictable
• It looks like it was written by the same person.
• Recorded

Additional reading

The topic list of this article is as follows:

1. How should we understand the working principle of the JavaScript engine?
2. JavaScript exploration: the importance of writing maintainable code
3. JavaScript exploration: exercise caution when using global variables
4. JavaScript exploration: var pre-parsing and side effects
5. JavaScript exploration: for Loop (for Loops)
6. JavaScript exploration: for-in loop (for-in Loops)
7. Exploring JavaScript: Prototypes is too powerful
8. JavaScript: eval () is the devil"
9. JavaScript exploration: Using parseInt () for Numerical Conversion
10. Exploring JavaScript: Basic coding specifications
11. JavaScript exploration: function declaration and function expression
12. JavaScript exploration: Name function expressions
13. JavaScript: function name in the debugger
14. JavaScript: JScript Bug
15. JavaScript exploration: Memory Management of JScript
16. Exploring JavaScript: SpiderMonkey's quirks
17. JavaScript exploration: an alternative solution to naming function expressions
18. JavaScript exploration: Object
19. JavaScript exploration: Prototype chain
20. JavaScript exploration: Constructor
21. JavaScript probing: executable context Stack
22. Execution context 1: Variable object and activity object
23. Execution context 2: Scope chain Scope Chains
24. Execution context 3: Closure Closures
25. Execution context 4: This pointer
26. Exploring JavaScript: Powerful prototype and prototype chain
27. JavaScript Functions 1: function declaration
28. JavaScript function 2: function expressions
29. JavaScript function 3: function expressions in a group
30. JavaScript function 4: function Constructor
31. JavaScript variable object 1: VO Declaration
32. JavaScript variable object 2: VO in different execution contexts
33. JavaScript variable object 3: two stages of execution Context
34. JavaScript variable object IV: Variables
35. Property of the JavaScript variable object __parent _
36. JavaScript scope chain 1: Scope chain Definition
37. JavaScript scope chain 2: function Lifecycle
38. JavaScript scope chain 3: Scope chain features
39. JavaScript closure 1: Introduction to closures
40. JavaScript closure 2: Implementation of closure
41. JavaScript closure 3: Closure usage

Address of this article: http://www.nowamagic.net/librarys/veda/detail/1621,welcome.