Three-tier Project

I have been studying in Beijing for more than a month, and the three-tier project has ended almost a week. I think it is necessary to summarize it. The effect of the three-tier class project is as follows.

The three-tier project we set up is a distributor management system. To be honest, after the project is over, I don't know what our group has done. Before replying to the project, I always thought that the project in our group was the second one, but I did not expect the result to be unexpected. In my opinion, the projects in other groups are all completely formed projects. However, only the projects in our group are semi-finished products that cannot be used. Maybe the problem is too big, it cannot be obtained in a short time.

In this project, as the leader of our group, I had a great harvest. I would like to summarize the gains and problems.

1. Clarify project requirements

Before starting a project, you must understand the needs of the project. If you do not understand the requirements, the project will basically fail in half at the beginning. In this project, when determining the requirements, the entire group was basically ignorant. Only the person who raised the requirements was clear, but what he said was basically unknown. The final problem is that the defects of the entire system are constantly found. In particular, as the owner of a project, it is critical to clearly determine the entire requirement.

2. Database Design

After determining the requirements, we must consider the database design. A reasonable database design in a project can make the entire project get twice the result with half the effort. The Design of others' databases referenced in this project is relatively easy. However, because the project needs are not very considerate, the database is also changed throughout the development process, which makes the work of the entire team member quite troublesome. At the same time, when creating a database, it is best to set naming rules and Data Types first, and then let a person build the entire data table. Since we tried the SQLite database this time, every member of the team was responsible for creating one or two tables, and then copying the DDL code to create a database by myself, I did not expect it to be a mess, this has also become a major cause of database changes behind the entire project team.

3. Build a project framework

In this three-tier project, as the project leader of the entire group, I set up the project, at first, I imagined using the tabcontrol Control to integrate multiple modules into a form. Each team member operated on a tabpage to develop their own module functions. I did not expect it to take less than one morning, the entire project team is paralyzed and cannot continue. The reason is that everyone is on a different page, but the code that vs background helps us generate is still in the same CS file, resulting in constant conflicts, so later, I had to spend time rewriting to build a framework. Therefore, at the beginning of the project, we must design a project framework to avoid the case where multiple people operate on the same creation. Otherwise, it is basically a dead end.

4. Naming rules

On this issue, it is better that before the project starts, it specifies the naming rules used for database design. during development, it also specifies the naming rules for each CS file and method, however, since the team members often do not follow this prescribed method, it is sometimes troublesome. However, because the project is not large in general, you can basically find out who wrote this file when looking at the CS file, but when maintaining the integration later, because the team members do not have names for some controls, the maintenance is still relatively difficult.

5. Code specifications

In fact, this problem is not easy to talk about. In general, nothing is a code specification. I just think that sometimes some necessary comments are missing in the Code, which makes it difficult to maintain them later and call methods by others.

6. Task Allocation

As the owner of a project, it is essential to assign project content to each group member and clearly describe the various requirements of the task during the assignment. At the beginning of this project, I was not very clear about the requirements of the entire project. As a result, I did not know what the function should look like in the allocation of some function modules, I simply told them what to do. The first result is terrible. Some modules are relatively clear and the effect is better.

7. Cooperative Development

In this project, SVN is used for team cooperation, which is also the biggest achievement of every member of our project team. In team cooperation, you cannot modify others' code at will. You must change the code first, let him make a slight adjustment to meet his own needs. If it cannot be changed, you can write a new method, in Layer 3, a table corresponds to a BLL and a dal, so that you can rewrite a method and write it to the person in the class to call this method, in this way, access to the same table can be avoided in different places. In this project, I did not discuss the Code with the team members during subsequent integration. The result is that the subsequent functions are basically paralyzed, this is because the results should be obtained through joint queries according to the database design, but it is not imagined that this is not the case when the data table he is responsible for is filled in. There is no way to change the modified Code back to the end due to the time relationship, although the implementation of the code is unreasonable. At the end of the project, a team member said that he had secretly modified our code at night, and he did not know whether it was true or not, because every time the Code is submitted by him, the result is that when we update the code, conflicts continue. In this project, we can say that 70% of the conflicts are caused by the Code submitted by him, it also took a lot of time to debug errors, which showed that there was less communication in the entire development process. Fortunately, every team member was easygoing and did not care too much.

In addition, when using SVN for source code management, when the submitted code encounters a conflict problem, you should first check what causes the conflict, if the conflict is caused by two people moving the same file, it is best for the two people to discuss the problem and determine how to solve the conflict. If they are all other people's files, they can overwrite their existing files, but it is best to ask if they have been changed. Of course, if they are their own files, they can be overwritten directly. After a conflict, it is generally to reference other people's solutions, and then manually add your own code, so that you can get a new version locally, do not forget to back up your own code before updating the Code.

8. Communication issues

When many people work together to do one thing, they must communicate a lot. Multi-communication can solve many unnecessary problems. As a group leader, I really had less communication with the group members, and this caused some problems. As mentioned above, I changed the Member Code and changed it back because of lack of communication. At first, when I didn't know the members in the group were doing things, this is the root cause of implementation or failing to convey some basic requirements for implementation. Later, when I changed the code, I did not notify the group members, at last, I had a serious mood. Finally, considering the relationship between time and time, there was still a fundamental mistake on me. So I made a compromise and changed it back. Although he wrote it unreasonably, if it is unreasonable, it can only be used, but I think it will not happen again in the future. In addition, after assigning tasks, it does not matter their implementation. Some members submit a mess of results and then call back to change the results. The reason for all this is that the demand is not clear and there is a problem with communication. There are also many problems in the mutual calling of forms, that is, it is found that the called forms are different from the functions they want to implement, in the end, you can only modify the form again or write another form. In fact, you can discuss this problem before, so that you can do something for each other at one time to avoid wasting time and effort on secondary modification.

9. Permission issues

When many people work together, a lot of operations are the same. A typical example is the database and mode object, because each member is assigned the read and write permissions at the beginning. Therefore, each person has the permission to rewrite the mode object, resulting in a problem: After the joint query, the data is bound to a dview, and some attributes are an object, the full name of this object is displayed, not data. Therefore, the first method that everyone can think of is to override the tostring method of this class, this leads to a problem where everyone may rewrite it. The latter rewrite it to overwrite the previous one. In fact, it is also a communication problem. However, in many large projects, communication may not be able to solve these problems. Later, we changed the read and write permissions on the mode and database to read and write data only, when displaying data, do not use data binding, manually create cells, or overwrite the display mode of cells. This solves the problem. Now I think this type of problem should be solved when the project is set up, or there should be a project specification or a sub-class rule before the project starts to be bound.

10. Project Integration

In fact, there are not many problems in this regard. As long as there is not much conflict during development, it takes a lot of time to integrate the main interface. Fortunately, my roommate gave me some advice, after the main interface is moved out, the solution of this problem also shows how important communication is.

In general, the project gains a lot. Although I personally think that the project is not a poor job, I did not expect the Speaker to be awesome, and the results are still objective. Through this project, I learned not only about knowledge, but also how to better work with a team and how to build a simple project framework, clear project requirements and development specifications are important to a project. Of course, the project owner knows that he is no longer responsible for his or her own functions and does not have bugs, instead, the entire team must complete the task efficiently.