I will not speak Advanced.
Just say junior programmers tend to make mistakes, to correct these errors, you off near the middle.
Junior programmers often mistake Highlights
1 non-standard naming
2 log irregularities
3 refused to write interfaces and false data
4 do not write unit tests
5 blind Integration
6 logic is unclear
7 programs do
8 does not care about performance
9 afraid reconstruction
10 made out just fine, regardless of elegant solutions
11 does not consider future changes in demand
12 will not encounter problems when trial and error
13 will not write pseudo code
14 not estimate the amount of data
15 submit code does not regulate
16 do not like to play Tag
17 non-compliance with the publishing process
18 Do not know Bug fix priority
19 likes manually modify the code line
20 do not do data backup
21 do not do self-test
22 does not try to imitate the real data, test data very casual
23 does not extract the common code
24 do not listen demand explanation
25 do not look acceptance criteria
26 does not actively promote the progress of the project
27 encountered problems not active feedback
-------------------------------------------------------------------------------------------------------------------------------
Junior programmer
Junior programmers code farmers is legendary, relying copy and paste, writing code to complete than the painted gourd dipper way, a method usually several hundred lines of code, wait a class all of the functions are implemented without regard to the principles of programming, but also irrespective of the performance of programs, regardless of the SQL injection problem, but not to think about how to make my program better quality, their sole purpose is to be able to run my program.
Intermediate programmers
Intermediate programmers prefer elegant code, and write their own elegant code, encapsulation, inheritance, abstract with ease, able to finish the development system modules.
Senior Programmer
Senior programmer to complete the design of the system has been able to use the acquired skills to solve the problem. And to take into account the problem of system scalability, security and stability.
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Many programmers stop at the intermediate level, on one hand SSH technology line world, while living in the time to develop primary problems still exist, and some have even 5 years has been the case,
Plasticity poor, due to the long working hours are also a good skill to learn first-hand to cover up the problem.
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Many programmers stop at the intermediate level, on one hand SSH technology line world, while living in the time to develop primary problems still exist, and some have even 5 years has been so, poor plasticity, due to the long working hours also learn a hand to cover up the problem of good skill, not polite to say these people is the scourge of the project. There are also some people are tired of coding after reaching the intermediate or advanced level, so go do needs analysis, product manager or project manager in the country to do the technical indeed difficult to get high wages, and this is the reason a lot of technical personnel transition.
----------------
the Java beginner, intermediate, advanced, skills or awareness of what you think should correspond to it?
Primary:
master java basics
to master java multithreading concurrency,
understand java web containers principles and garbage collection,
have some understanding of design patterns,
uses Spring, hibernate, Mybatis, Struts2 and other frameworks,
with good programming style and habits ,
have their own opinion on polymorphism and generics, with the ability to quickly solve the problem.
Intermediate:
can master the reflex mechanism,
can simulate write java web containers,
can simulate write several common framework,
in-depth understanding of the underlying operating principle of java,
for a common front-end frame have a certain understanding,
the code has some design patterns of thought, low coupling codes.
Advanced: have a strong sense of architecture,
is generally present as a senior systems architect,
the vast majority of problems can be proficient in java to solve,
and can produce their own insights to lack of java and propose optimization strategy,
but also to have written (new) competency framework.
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Getting started: use Notepad to write Helloworld, basic grammar logic is no problem, entry algorithm, can write Tao Tao apple picking ..
Primary: students can complete their own information management system (say you did not do, I do not believe), the distinction between authority, business logic can be completed, SSH or SSM will use already, you can take a project, simple things they can do, but why do so, do not understand. The algorithm can write Joseph cycle ...
In extreme:
Framework source code should be involved, he usually would write a little gadget,
made a little wheel, network protocols, database theory, and so have primary understanding,
lists tree, and so have been able to write, and understand the principles
Advanced: they can combine business needs making framework, and there is no stress-free,
high concurrency, multithreading, and so on, and so have some understanding of operating systems,
various network-related knowledge, such as TCP, RPC, and so no pressure,
the JVM-depth understanding, proficient in database principle and so on,
SQL and NOSQL have some understanding and practice, although not all proficient in arithmetic,
but to write it, and no pressure.
Ultimate: wear women knock Code
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
Primary: the basics are understood, the foundation will use the JDK classes, to write basic logic.
Intermediate: this time we should learn a bit JVM, the Java runtime to understand the mechanism, you can write a beautiful hand skilled Code, a few BUG, can independently solve some of the problem.
Advanced: work independently, have a very deep understanding of Java, a Java basically skilled explain any knowledge of a point, have their own ideas, you can create your own code style and writing techniques.
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Primary 1--3 years, mid-level 3--5 years, senior 5--10 years, the average person's general line is, if you are talented, naturally 3 years is the high-level talent, it all depends on your personal good luck.