How to Become a Good PHP Programmer
In a narrow sense, a PHP programmer is a programmer who uses PHP as a development language. But often a programmer is not limited to a certain development language, or divided by a certain development language. Learning today, the editor will share with you: How can I become an excellent PHP programmer? The specific content is as follows:
Attitude
-
Do real things: don't complain, whine, blame others, find out what the problem is, and find a way to solve it. Be brave to take responsibility for problems and mistakes.
-
Haste makes waste: using clever and expedient solutions to solve problems, seeking speed without regard to code quality, will leave a fatal dead end for the project.
-
Dealing with the matter rather than the person: discuss the matter as it stands, discuss issues wisely, sincerely, and humbly, and propose innovative solutions.
-
Go ahead against all odds: Courage is often the only way to overcome difficulties.
Learning articles
-
Tracking Changes: It’s not scary to see new technologies emerging one after another. Persist in learning new technologies, reading books, reading technical magazines, participating in technical activities, and communicating with others. It is necessary to understand the reasons behind the new words, grasp the general trend of technology, and be cautious in using new technologies in product development.
-
Invest in the team: build a learning team and continuously improve the average level of the brothers.
-
Know how to discard: old routines and techniques should be discarded, and they must be discarded. Don't rest on your laurels.
-
Break the casserole and ask the end: keep asking, and really understand the essence of the problem. Why? Should be your mantra.
-
Grasp the development rhythm: control the time well, develop good habits, and don't work overtime.
Development Process
-
Let customers make decisions: Let users be on site, listen to their voices, and let them have the final say on the most important decisions for the business.
-
Let design guide rather than steer development: Design is the map forward, providing direction rather than an end in itself. The level of detail in the design should be appropriate.
-
Use technology wisely: Choose technology based on need rather than other factors. Strictly question various technical solutions and face various problems sincerely.
-
Make your app ready to release: By making good use of continuous integration and version management, you should be able to compile, run, and even deploy your app at any time.
-
Early integration, frequent integration: integration is risky, and it is necessary to integrate as much as possible as early as possible.
-
Automate deployment early
-
Use Demos to Get Frequent Feedback
-
Use short iterations, release incrementally
-
Fixing prices means betraying promises: estimates should be constantly changing based on actual work being done.
User articles
-
Guardian Angel: Automated unit tests are your guardian angels.
-
Use it before implementing it: Test-driven development is really a design tool.
-
Different environments have different problems: attention should be paid to multi-platform issues.
-
Automated Acceptance Tests
-
Measure real progress: Don't kid yourself when it comes to effort estimates.
-
Listen to your users: every complaint hides a valuable truth.
Programming
-
The code should clearly express the intention: the code is for people to read, don't be clever.
-
Communicating in Code: The Art of Commenting.
-
Make trade-offs dynamically: Remember, there is no best solution. It is impossible to cover all kinds of goals and focus on the important needs of users.
-
Incremental programming: write a little code and build, test, refactor, rest. Keep your code clean and tidy.
-
Keep it simple: keep it simple over complicated. Do not use patterns, principles, or particular techniques without good reason.
-
Write cohesive code: classes and components should be small enough to have a single task.
-
Tell, don't ask: use more message passing and less function calls.
-
Replace by contract: delegation is often better than inheritance.
Debugging
-
Keep a Problem Solving Journal: Don't fall over in the same place twice. Mistakes are the most precious wealth.
-
Warnings are errors: ignoring compiler warnings can be a big mistake.
-
Tackle problems individually: Divide and conquer is one of the most important ideas in computer science. However, consider from the design and prototyping stage that the parts should be well separated.
-
report all exceptions
-
Provide useful error messages: A little extra thought will come in handy when things go wrong.
Teamwork
-
Schedule regular meeting times: regular meetings, short meetings.
-
Architects must write code: An architect who doesn't write code is not a good architect. Good design comes from actual programming. Programming can lead to deep understanding.
-
Implement collective code ownership: Have developers rotate between different modules and tasks in different areas of the system.
-
Becoming a Mentor: Teaching and Learning. Sharing can improve the overall ability of the team.
-
Let people figure it out for themselves: provide direction rather than direct solutions. Give everyone the opportunity to learn by doing.
-
Share code when you're ready: don't submit code that won't compile or fail unit tests!
-
Do code reviews: Reviews are extremely important to improve code quality and reduce bugs.
-
Report progress and problems in a timely manner: take the initiative to report, and don't let others ask you.