7 key steps from development to launch of the project
Framework planning and construction
Construction of development environment (server side)
Synchronization of progress
Completion of functional modules
Multiple rounds of testing and verification
7. Peripheral processing (before going online)
Some time ago, I took a new project. Only some ideas are in the mind of the business demand side, and then the demand discussion begins, and then things start to work. The project is not complicated, but it seems more meaningful to me personally.
In summary, it is actually a list of items. Personally, I think it s still a bit meaningful, for reference to students who don t have a comprehensive practice!
- Project planning
In this process, you may have to read the requirements once, twice, or three times. . . Then assume that you are already using this product.
1.2 Secondly, after understanding the requirements, we must develop the overall framework!
For example, what is presented to the user, what is used to store the data, what kind of system is needed, etc.
At this level, generally follow the company's regulations, and then make some corresponding adjustments according to the needs of the project itself.
Our overall framework in this project is: the front end uses APP (ios&android), H5 for user interface presentation ===>> access to the gateway for data encryption and decryption, flow control forwarding, etc. ===>> the first layer of API services, Accept client requests, do simple business inspection and assembly ===>> The second-tier core business SERVICE service, perform core business processing, such as writing libraries, calling third-party interfaces, etc. ===>> The lowest layer of basic services, providing a single Functional services, such as message service, order service.
In the early stage, only APP is provided, so there is no separate H5 calling API service, but the application scenario of H5 still exists. At this time, the H5 address is provided by the service interface and returned to the APP for webview loading.
1.3 Personnel planning
After the overall framework of the project comes out, someone needs to implement it.
Here generally we need to follow a minimum principle, that is, the divided personnel should try to be able to complete their own modules independently, rather than relying on the implementation of the other party to go further. For example, there are one person for android and ios, and multiple persons for API and SERVICE can be provided, but they must have full authority, because API and SERVICE are strongly dependent. If they are separated from one party, they cannot be completed independently. The basic services are implemented by relevant personnel respectively. Finally, the joint debugging can be carried out.
1.4 Time planning
With people, you can't do things for unlimited time. It must be planned, otherwise there is no pressure and no motivation. I don't know when the project will end. When setting a time plan, you must ask the parties concerned, how much time is required, and try to give reasonable suggestions and evaluations from a professional perspective. Promote the completion of the project.
2. Framework planning and construction2.1 Once the overall framework is conceived, it is necessary to go to the details of each level of practice
Because they are all layers of applications, it is impossible to have a unified description, only for each application layer. Do what you should do. For example, android/ios has its own development framework; h5 has its own development framework (because many application scenarios may involve the native interaction between h5 and app, so even if the function is simple, try to use some existing frameworks for development).
Although the server side is divided into multi-layer applications, you should try to use the same language and use the same development framework. It is naturally best to have a research and development framework in your own company, and try to use a unified open source framework if you don't have one. The advantage of this is that when there is a change in personnel, you can immediately familiarize yourself with its code and application scenarios, thereby increasing adaptability and management.
Regarding the server-side framework, I think it is necessary to say more. Because the smoothness, reliability, and accuracy of the entire application is determined by the server. Although users see APP or H5, it can be said that the server is the core of the application. Therefore, the server has a lot of things to do.
2.2 How to build some server-side frameworks?
First of all, the framework of things, it is natural to learn in advance. However, as far as the current market is concerned, it should be relatively simple to use the framework, especially the framework provided by the company, there must be a demo. In this way, follow the demo and debug step by step until the entire application is connected;
Delete unnecessary modules and add specially needed modules to ensure that you can use whatever you want in the specific development process;
Fully understand some of the configuration parameters required by the framework, and know where the transactions come from and where they go? Here, there should be a configuration center corresponding to it, but you have to be clear.
Using a handy IDE tool does not mean that you are not skilled enough, but a good tool that can make you do more with less. (Actually, if you can learn more routines, it does not have to be reflected in the formal project)
Write the first available interface service. It can be said that the first one is always more important. Because the first idea is the direction of all your subsequent functions, so write the first "hello, world.";
- Construction of development environment (server side)
3.2 The construction of the development environment is mainly subject to the concept of the overall framework.
It mainly includes how many services are needed, how many servers are needed, how many basic applications are needed, how many basic configurations are needed, and so on.
Of course, the development environment itself is a big problem, and it is usually completed by old drivers who have been professional operation and maintenance for decades. Think of it by yourself.
Except for some small-scale companies that are still using a set of server-side code to do everything, most of the current project development should be done with the cooperation of multiple applications. The test environment is unlikely to use multiple servers to provide services. Therefore, it is better to use docker to build a test environment. Establishing multiple dockers to simulate multiple servers is also consistent with the online environment.
The current mainstream technology can be used (of course the key depends on your framework planning), zookeeper,
dubbo, redis, mongo, mq,
3.3 Only when the development environment is set up, can the subsequent processes be worry-free. The build process must be, build again, change the code, and troubleshoot...
- Synchronization of progress
For a new project, it is normal for some places to move slowly. And some of the development classmates (such as myself) like to be entangled in their own small world, unable to get out, and thus forget to report to the leader. As a leader with a little empathy, he is unwilling to stare at you and do things in real time, because he is afraid that you will encounter difficulties and wants to give you more time to solve them. However, in this case, the development of the classmates themselves is actually a disadvantage, because the feeling to outsiders is that you have not done anything. Therefore, while solving the problem, do not forget to report to the leader.
4.2 If there are problems that cannot be handled, please consult the big cows or leaders in time
Solving the problem independently is a good thing, but don't overdo it. If you really can't solve it, you should ask for advice in time. Otherwise, time is wasted. The fastest way to make progress is to ask someone who is better than yourself. Knowing is knowing, not knowing is not knowing!
4.3 Try to share the problem as much as possible
There are definitely problems, and there will be many. Don't put everything on yourself, otherwise you will be exhausted and the progress of the project will also slow down. Make more use of the individual strengths of the group members and let them do more things as appropriate.
Work is never a single thing, there will definitely be other things inserted in, observing the importance of things to solve. If it can be solved by other students, try to let other students handle it. This point must also be synchronized with the leader. Otherwise, the distraction is too high and the only hindrance is the progress of the project, and the delay is not my own business.
It is impossible for the demand to be perfect at once. In the process of doing it, some potential problems may be discovered. At this time, communicate with the demand side in time to maintain an efficient state. Of course, in the later follow-up, try not to do it all by one person, but the corresponding person will be responsible for the follow-up of the corresponding thing. Others just need to know the result.
4.4 Facing the current popular technology, I don't know where to start. Those who need to break through the technical bottleneck can be added.
I have been in the company for a long time and have a very comfortable life, but when I changed my job, the interview hit a wall. Those who need to study in a short period of time or change jobs to get a high salary can be added. If you don t have work experience, but you have a very solid foundation, you can add proficiency in java working mechanism, common design ideas, and common java development framework. I feel that I am very good, and I can handle general needs. However, the knowledge points learned are not systematic, and it is difficult to continue to break through in the technical field. You can add my new Java group: 650385180! Alibaba's senior Java player will explain knowledge points, share knowledge, sort out and summarize years of work experience, and take everyone to comprehensively and scientifically establish their own technical system and technical cognition!
- Completion of functional modules
5.2 After the completion of what the respective systems can do, it is particularly important to jointly adjust the calling relationship between the systems and maintain efficient communication so that the problem can be solved in a short time. At this time, I think a small dark house may also be a good choice.
5.3 The process of joint debugging is actually a self-testing process, and as many situations as possible should be considered.
5.4 Code inspection. It is basically difficult to find the problems in the code developed by yourself. Finding the corresponding person to help check the code immediately is a better solution to the code problem. In fact, when you check it for others, it is also when you check it yourself, which is equivalent to developing again by yourself, and you can find problems in time.
- Multiple rounds of testing and verification
6.2 The first round of testing may mainly be the verification of large functions and the inspection of small functions. The baffle environment is sufficient, and the real environment is not required.
6.3 The second round of testing is to clear all the previous tests and various configurations, treat them as a brand new project, re-build the corresponding environment, deploy the code, and then perform the test to ensure that the problem is solved, do a good job The corresponding processing plan was backed up. At this time, you need to use the real application environment. Re-test some previously unresolved issues. Make sure there are no problems.
6.4 The third round of testing should be a gray release environment, or it can be considered pre-launch. Treat all environments as online. If you run it ok, you are ready to release and go online.
6.5 In the testing process, because the tester only handles it manually, sometimes it may not be able to capture all the problems. At this time, the development should also stand from the perspective of the test, find the problem, monitor it and deal with it immediately.
6.6 Automated testing, this should actually be a later process, but if you can do this, you can quickly reproduce the problem.
6.7 Stress testing, dealing with the online environment, requires a certain ability assessment, otherwise, just guessing, I am afraid it is not a good thing. Being ready to scale horizontally at any time is just a solution after a problem occurs. Do a good job of stress testing, find out the problems in the code, and deal with them immediately.
- Peripheral processing (before launch)
Various basic data in the test environment can be exported and backed up at any time, and directly inserted and used when online;
Server, quantitative evaluation during the architecture review process;
Domain name, it must be a domain name to provide services to the Internet;
Permission, for example, if there is a problem after going online, who has the permission to deal with the problem must be given in advance;
Acceptance, this is the key point. After the function is completed, check and accept it in time. If there are minor problems on the line, try to negotiate and do not make frequent online changes.
in this way! The entire project is completed.
In fact, it is found that the real function realization of a project does not take up a large proportion, but some preliminary preparations and subsequent processing take up more time.
After the first version goes live, it may be followed by rapid iteration. (If the operation is okay!)
The above steps are a process list of the entire project. It is summarized step by step in the experience. It does not involve specific language codes, but the ideas are all the same. I hope it will be helpful to you!