I hope every 2017 "Java program Ape" in the 2018 grand undertaking __java

The Goblin strives to

In the 2017, the more you do, the more you don't feel like you're going to have the same kind of a satanic effort. This year in the technical thinking and practice of more, but also bold attempt to do cross-role cross-functional architecture. Also a bit of what all want to do the impulse, so instead some things do not do, do not do fine.

Primary Awareness Programming

This year did not spend much time in writing code above, but Codereview code a lot, a kind of jump out of "not know the truth, only the body in this mountain," but more attention to the quality of the code, readability, maintainability. have been writing Java, this year also wrote a two-month vue, and then wrote a period of time react Native, there is a cross language comparison, the programming has a handy feeling.

Specification

The name is thought, often to want to understand the need after naming will be very natural, in turn looking at the uncomfortable naming at least indicates that there may be many problems:

The duties are unclear.

Responsibility is not a single

Need not understand correctly

The idea or algorithm is not concise and straightforward.

Norms are actually the means to solve problems, not constraints.

Increase maintainability. No additional translations are required. The code written by several people is the same. Although not always right, but there is always a relatively correct wording.

Reduce the cost of writing code. You don't have to think about repetitive things all the time.

Avoid some low-level debug.

Improve performance.

There is a normative premise, can be automated way to solve the duplication of labor.

Code fragment plug-in for the IDE

The standard demo scene

Code generator

Java Development Specification

Recommended

"Alibaba Java Development Manual"

"Refactoring"

Tree-like programming

Many small partners are linear programming methods, write a method to put all the details inside. The drawbacks of this approach

The focus is too high. You must know all the points of concern to complete this method.

Come back and constantly switch thinking

If you change a place, you need to index the location from scratch

Not convenient to collaborate

If you change the programming mode to a tree shape. Write a method that considers the demand point at the same level, and then further refine the demand point. It is difficult here to judge how the same level of abstraction is.

Recommended "Code Neat Way"

Defense-Type Programming

Many of the small partners are linear programming methods, in the normal logic will have a variety of special circumstances to judge. This disadvantage:

It's easy to think about normal when you start to write a program, and then, as you find the problem, add various if processes or code to destroy the original structure. Then there's the bad code smell.

The normal logic and the exception, the special logic is coupled in a piece, think the attention point high.

Defensive programming: All exceptions and special cases are processed, and the code finally considers the normal logic. And always think that the program is unsafe, not artificial assumption is normal.

Recommended "Code Encyclopedia"

Write code in a natural language

Always found a very strange problem: many people will be a natural demand, through their own processing, and then add their own understanding of the algorithm, the end will be very complex code to get dizzy. It is especially noticeable when writing complex algorithm code and complex SQL.

In fact, after the demand is clear, the use of natural language into pseudo code, the last pseudocode, just according to different language characteristics, pure translation. Advanced Java

You've only stayed at the stage where Java syntax is used. Later found that in high-performance, high concurrency or architectural design, only to understand the grammar is powerless.

Java Virtual machines

Memory. Tracking memory leaks and tuning applications.

Class is loaded. Resolve class conflicts.

byte code. Do not invade the added monitoring of the business. Remote debugging.

Multithreading

Lock.

Thread.

Asynchronous.

Recommend deep understanding of the Java Virtual machine

Deep Object Oriented

Object-oriented is a way of thinking of abstract simplification problem. At the same time, it solves the common problems in the object-oriented abstraction simplification process through the classical features: encapsulation, inheritance and polymorphism.

Diffuse light object-oriented--pojo object

Diffuse light object-oriented-algorithm | design pattern

Diffuse object-oriented--analysis of abstract problem domain

Raise the object-oriented way, think more. Think more. Think more. A quick way to improve

Domain Driven Design

Uml

Design Patterns

Recommend

"Thinking in UML"

UML Basics, applications, and cases

"Domain Driven Design"

Head of the design model

"Dahua Design Model"

Using the face-plane

It is a way of thinking that reduces repetitive code, reduces attention, and reduces complexity in the non intrusive business. Can make business simpler, more focused, and can reduce complexity. For example, the following application scenario:

Authority judgment

Data aggregation

Data format

Custom Label engine

Transaction

Log

Statistics

Monitoring

Data collection, etc.

Cache

This does not refer to SPRINGMVC or application levels. Refers to the whole system of various links or to solve the problem of the way of thinking. For example: Some of the cache, may be placed in the proxy node plus a middle tier. Monitoring may be placed at the container level to be implemented through the broker.

Recommended

A description of AOP in "Spirng in action"

A description of AOP in "Java EE Internet Lightweight Framework Integration development"

Forming architectural Principles

In fact, the architecture itself is a way of thinking and ability. It is a kind of balance of technology planning, choosing, solving problems with the best resources, and simultaneously expanding and succeeding.

Recommended

"Software architecture design--programmer to architect transformation necessary"

"12 disciplines of software Architects"

Positioning problems

Defining the boundaries of the architecture and the issues to be addressed is the first and important step in the architecture.

You can think from the following 4 maintenance to find the problem.

Repeat. Can be solved by encapsulation and automation or by means of tooling.

Attention to high. Addressed through encapsulation and tiering, process, and specification conventions.

Complex and high. Addressed through encapsulation tools and tiering and specification conventions.

High coupling. Resolved by layering, step-by-step, and normative engagements.

Planning

Depending on how much of a problem to solve the income ratio. Save time/Time: To make clear the priority of doing things. Do not depend on whether the technology is good or bad or not. Solving the problem is the key.

Reasonable split, will make late landing more controllable.

Split horizontally. Layered

Split vertically. Step-by-Step

Iterative thinking. One-Step and every validation practice is too great to cause premature death.

The first is perfect.

It is better to break one finger than ten fingers.

After all, the business, production environment, so demand stability.

Small scope test. In general, the user tolerance of high, commercial value impact relatively small to test.

Do a fallback scheme or backup plan.

Design

The design is designed to minimize risk, prepare early and focus on areas of high risk to avoid rework or even overturn when the back falls. Not all content needs to be designed, and this is over design.

Open source

Use a third party first, try not to reinvent the wheel. To directly use open source third parties, you need to consider the following questions.

Ecology (community)

Advancement

Success Stories

of active

Extensibility

Ease of Use

Rationality

Disadvantages

Self-research

If you can't find the right wheel. You can think, analyze, and decompose the design to do in the following way.

Divide

Layered

Step-by-Step

Clear responsibilities

Abstraction, modeling

Design Patterns

Thought

Object-oriented

Facing plane

Plug-in oriented

Service oriented

Implement

Quality

Code Quality

Software Quality

Quality of demand

R & d

Core code

Algorithm

Implementation of the critical node (high degree of complexity)

Guidance

There is a solution available

Verify