Supporting For Software Engineering Environment - Introduction

Supporting For Software Engineering Environment

转载请保留作者信息：

作者：88250

Blog：http:/blog.csdn.net/DL88250

MSN & Gmail & QQ：DL88250@gmail.com

Int
roduction

Introduction

Abstract

Construction

Project Management

Dependencies Management

SCM

Helpful Practices

Continuous Integration

Abstract

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.

Construction

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.

It
means developers can code using the best suitable development
environments. For example, Java programmer can use eclipse, JDeveloper,
or NetBeans to write codes, and HTML / CSS / Javascript programmers can
use other development tools for convenience. The project building is
only relies on maven's build configuration and independent of IDE.

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.

Project Management

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.

Dependencies Management

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 [b]control
of dependencies change easy . [/b]

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.

SCM

Software
Configuration Management (SCM) is focus on the management of changes of
software. Commonly, we use source version control system to track the
changes.

Helpful Practices

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.

Continuous Integration

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.

Conclusion

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
nothing.

TODO: Issue Tracking, Software Process Management

Edit this page (if you have permission)
|

Google Docs -- Web word processing, presentations and spreadsheets.