Supporting For Software Engineering Environment
MSN & Gmail & QQ：DL88250@gmail.com
Software Engineering Environment involves the processes, approaches and tools of a software project life cycle with human-centric. This article introduces the advantages of two open source and stable tools, and reflects the basic, simple and critical factors that affects on the development of a software project.
Maven2 is a project management and comprehension tool based on Ant. Generally speaking, by using maven2 (maven for short) takes the following advantages:
IDE independent debugging, testing, building and deployment.
Makes the continuous integration easily.
A maven project can configures the source repository and integration tool easily. For example, when an artifact code completed, we can publish the artifact into a integration tool (such as Hudson) to build and finally put the artifact into test server or put it into maven repository as other project dependency.
Simplicity of extension for different type projects.
Maven can customizes plugins for the specified project on demand. Some specified projects need to append process in the specified construct phase, such as when compiling source codes, may need to check the quality of source codes by using some static or dynamic analysis tools; after compilation, may need to append the project license on the source files; and after the whole construction, project manager may want to take a glance at a project report for getting how many tests fail / succeed, how many source codes are below standard.
Maven depicts projects using the object-oriented approach. A project has its own pom.xml for representing the project's structure, sub-projects, referenced projects (as dependencies) for instance. The relation between these projects are equivalent to the object-oriented approach's basically. So, it takes some advantages of object model, such as inheritance and polymorphism.
The project management of maven can not reach some factors (plan, cost, risk, time, etc) of Project Management Theories. In other words, maven's project management focus on the structure and construction behaviors of a software project.
In modern software development, the dependencies management is very significant and very difficult. For example, our current projects depend on some third-part libraries, and each dependency has its own version and runtime dependencies . Maven can automatically downloads these libraries, resolves and downloads their runtime dependencies respectively. It takes the following advantages:
Make the automatic project building and integration simplest.
Obviously, resolving the runtime dependencies are very dull and complicated. Fortunately, the most dependencies currently in the world have maven packages, then maven could decide the library 's dependency which is made by the library's authors or packager.
Make the control of dependencies change easy .
Frequently the libraries project depends on need to be upgraded. The upgrade is from an older version to a newer version. According to the above advantage, the operation is very simple, just need to modify the version number of the dependencies.
Scoping for every dependency becomes more easier.
This is a very typical case in test libraries. Commonly, we do not package a junit.jar into production. So, scoping the dependencies will help for project building and release. In practice, scoping dependencies can keep the consistence of software architect. For example, we selected eclipse as the project IDE and using JPA for persistence and Hibernate as the JPA implementation. After the phase architect verification, proved JPA is enough to use and never need to use its delegation. But someone use Hibernate annotations to annotated entities and others use JPA annotations to do that in deed. It breaks the consistence of design, make the maintainers drop into mud. By using maven dependencies management, it never be happen, just identifies the scope of hibernate-annotation.jar to runtime.
Basically, a software project source repository should has three folders: trunk , branch and tag . Trunk tracks the sources of current project's version. Branch tracks the sources of current project's branches, a fully-reimplementation version, a upgrade version, etc, for instance. Tag save the released sources of the project's several versions.
The source we define that is source code commonly. Strictly speaking, a source repository should not include any hard modified binary data, the reason is that different binary data can not compare the differences easily, it can only compare manually by human. But so many developers commit the project's binary dependencies into source repository just for convenience. The dependencies should be resolved out side source repository. This point is very important to the automation for further development and maintenance, otherwise the binary dependencies is managed by another tools, maven for instance.
Another problem in multiple humans development collaboratively is the conflict . To resolve conflicts, so many developers just to delete the conflicted source file and commit his / her own version. This is not the problem that whether the usage of the source version control client developers got familiar or not, rather than the philosophy of why and how to identify the configuration item. The configuration items are core source of software process management and improvement.
Hudson is an extensible continuous integration engine like CruiseControl. But it more easily to configure and extend. It can configures some build strategies, such as build condition (sources commit, time step, etc). And a friendly integration status reporting by using dashboard.
See the following continuous integration status come from JBoss.
The continuous integration has the following advantages:
- Exposes the problems of the project as soon as possible.
Each integration has it own 'health' or / 'weather' which quantifies the productivity of the team. Once encounters an integration fail, every member in the team will receive a mail that notifies the member what, when, where is it happen. Helps the team to fix the issue ASAP.
- Combines team members together into a more efficient team.
Here is a case: a programmers finished the development of a module, and then commit the codes into source repository. The CI tool will get source from source repository and get start a build. Once the build passed tester will receive a mail from CI tool that tells the tester it is time to test this build.
This article introduced some philosophies of
software engineering with maven2 and hudson. Some of these practices
and principles are such simple, but it is efficient if combined them on
a organized way. To build a helpful software engineering supporting
environment is very sophisticated and constructive, and not only relies
on tools but also depends on human collaboration. I always trust that
is a team should to select and adapt the environment rather then do
TODO: Issue Tracking, Software Process Management