Data Flow Diagrams (DFD):

The data flow diagram (DFD) is one of the most

important modeling tools. It is used to model the system
components. These components are the system process, the
data used by the process, an external entity that interacts
with the system and the information flows in the system.
DFD shows how the information moves through the
system and how it is modified by a series of
transformations. It is a graphical technique that depicts
information flow and the transformations that are applied as
data moves from input to output.
DFD is also known as bubble chart. A DFD may be
used to represent a system at any level of abstraction. DFD
maybe partitioned into levels that represent increasing
information flow and functional detail.
A level 0 DFD, also called as the context level
diagram, represents the entire system as a single module
with input and output data indicated by incoming outgoing
arrows respectively. Additional process and information
flow paths are represented as the level 0 DFD is portioned
to reveal more details. The context level diagram for the
proposed system is shown in the fig.
A level 1 DFD, also called as top-level DFD, represent
the system with major modules and data stores. The other
levels will show each module in the top-level DFD in more
detailed fashion. The top-level and other level DFD s for
the proposed systems are shown next.
To context a data flow diagram four basic symbols are
used. They are given below.

5.1.2Notation:

Source or destination of data:

External sources or destinations, which may be people or

organizations or other entities.
Data Source:

Here the data referenced by a process is stored and

retrieved.

Process:

People, procedures or devices that produce data. The

physical component is not identified.

Data Flow:

Data moves in a specific direction from an origin to a

destination. The data flow is a “packet” of data
5.2 Modeling Rules

There are several common modeling rules when creating

DFDs:

1. All processes must have at least one data flow in and

one data flow out.
2. All processes should modify the incoming data,
producing new forms of outgoing data.
3. Each data store must be involved with at least one data
flow.
4. Each external entity must be involved with at least one
data flow.
5. A data flow must be attached to at least one process.

Unified Modeling Language (UML):

 UML is a method for describing the system
architecture in detail using the blueprint. UML represents a
collection of best engineering practices that have proven
successful in the modeling of large and complex systems.
The UML is a very important part of developing objects
oriented software and the software development process.
The UML uses mostly graphical notations to express the
design of software projects. Using the UML helps project
teams communicate, explore potential designs, and validate
the architectural design of the software

Definition:
UML is a general-purpose visual modeling language
that is used to specify, visualize, construct, and document
the artifacts of the software system.
UML is a language:
It will provide vocabulary and rules for
communications and function on conceptual and physical
representation. So it is modeling language.
UML Specifying:
 Specifying means building models that are precise,
unambiguous and complete. In particular, the UML address
the specification of all the important analysis, design and
implementation decisions that must be made in developing
and displaying a software intensive system.
UML Visualization:
The UML includes both graphical and textual
representation. It makes easy to visualize the system and
for better understanding.
UML Constructing:
UML models can be directly connected to a variety of
programming languages and it is sufficiently expressive
and free from any ambiguity to permit the direct execution
of models.
UML Documenting:
UML provides variety of documents in addition raw
executable codes.
Goal of UML:
The primary goals in the design of the UML were:
 • Provide users with a ready-to-use, expressive visual
modeling language so they can develop and exchange
meaningful models.

• Provide extensibility and specialization mechanisms to

extend the core concepts.

• Be independent of particular programming languages

and development processes.

• Provide a formal basis for understanding the modeling

language.

• Encourage the growth of the OO tools market.

• Support higher-level development concepts such as

collaborations, frameworks, patterns and components.

• Integrate best practices.

Uses of UML
The UML is intended primarily for software intensive
systems. It has been used effectively for such domain as
• Enterprise Information System

• Banking and Financial Services

 • Telecommunications

• Transportation

• Defense/Aerospace

• Retails

• Medical Electronics

• Scientific Fields

• Distributed Web

Rules of UML
The UML has semantic rules for
• NAMES: It will call things, relationships and
diagrams.

• SCOPE: The content that gives specific meaning to a

name.

• VISIBILITY: How those names can be seen and used

by others.

• INTEGRITY: How things properly and consistently

relate to another.
 • EXECUTION: What it means is to run or simulate a
dynamic model.

Building blocks of UML

The vocabulary of the UML encompasses 3 kinds of
building blocks
1. Things

2. Relationships

3. Diagrams

Things:
Things are the data abstractions that are first class
citizens in a model. Things are of 4 types
• Structural Things

• Behavioral Things

• Grouping Things

• Annotational Things

Relationships:
 Relationships tie the things together.
Relationships in the UML are
• Dependency

• Association

• Generalization

• Specialization

UML Diagrams:
A diagram is the graphical presentation of a set of
elements, most often rendered as a connected graph of
vertices (things) and arcs (relationships).
There are two types of diagrams, they are:
• STRUCTURAL DIAGRAMS

• BEHAVIORAL DIAGRAMS

STRUCTURAL DIAGRAMS:-
The UML‘s four structural diagrams exist to visualize,
specify, construct and document the static aspects of a
system. we can View the static parts of a system using one
of the following diagrams.
Structural diagrams consists of
• Class Diagram

• Object Diagram

• Component Diagram

• Deployment Diagram

BEHAVIORAL DIAGRAMS :
The UML’s five behavioral diagrams are used to
visualize, specify, construct, and document the dynamic
aspects of a system. The UML’s behavioral diagrams are
roughly organized around the major ways which can model
the dynamics of a system.
Behavioral diagrams consists of
• Use case Diagram

• Sequence Diagram

• Collaboration Diagram

• State chart Diagram

 • Activity Diagram

5.4 UML Diagrams

Class Diagram:
A class diagram is a type of static structure
diagram that describes the structure of a system by showing
the system's classes, their attributes, and the relationships
between the classes.
• Class: Class is a description of a set of objects that
share the same attributes, operations, relationships and
semantics. A class implements one or more interfaces.
• Interface: Interface is a collection of operations that
specify a service of a class or component. An interface
describes the externally visible behavior of that
element. An interface might represent the complete
behavior of a class or component.
• Collaboration: Collaboration defines an interaction
and is a society of roles and other elements that work
together to provide some cooperative behavior. So
collaborations have structural as well as behavioral,
 dimensions. These collaborations represent the
implementation of patterns that make up a system.

Relationships such as
• Dependency: Dependency is a semantic relationship
between two things in which a change to one thing
may affect the semantics of the other thing.
• Generalization: A generalization is a specialization /
generalization relationship in which objects of the
specialized element (child) are substitutable for
objects of the generalized element (parent).
Association: An association is a structural relationship that
describes a set of links, a link being a connection among
objects. Aggregation is a special kind of association,
representing a structural relationship between a whole and
its parts.

Testing Methods:

Testing is a process of executing a program to find out

errors. Any testing can be done in two ways:
White Box Testing:

White Box testing uses an internal perspective of the

system to design test cases based on internal structure. It
requires programming skills to identify all paths through
the software. The tester chooses test case inputs to exercise
paths through the code and determines the appropriate
outputs. Using the testing a software engineer can derive
the following
Test cases:
Exercise all the logical decisions on either true or false
sides. Execute all loops at their boundaries and
within their operational boundaries. Exercise the internal
data structures to assure their validity.

Black Box Testing:

 Black box testing takes an external perspective of the
test object to derive test cases. These tests can be functional
or non-functional, though usually functional. The test
designer selects valid and invalid input and determines the
correct output. There is no knowledge of the test object's
internal structure.

Black Box testing attempts to find errors in the

following categories:
• Incorrect or missing functions
• Interface errors

• Errors in data structures

• Performance errors

• Initialization and termination errors

6.3 Test Approach:

Testing can be done in two ways:

 o Bottom-up approach
o Top-down approach

Bottom-up approach:

In a bottom-up approach the individual base elements

of the system are first specified in great detail. These
elements are then linked together to form larger
subsystems, which then in turn are linked, sometimes in
many levels, until a complete top-level system is formed.
This strategy often resembles a "seed" model, whereby the
beginnings are small, but eventually grow in complexity
and completeness. However, "organic strategies", may
result in a tangle of elements and subsystems, developed in
isolation, and subject to local optimization as opposed to
meeting a global purpose.

Top-down approach:

In a top-down approach an overview of the system is first

formulated, specifying but not detailing any first-level
subsystems. Each subsystem is then detailed enough to
realistically validate the model.
USER GUIDE

9.1 Installation/Environment setup

Setting up the java environment

Our project has been coded using the JAVA version
1.5.0 so before getting on to running the project we
need to install the java environment. Here is how we do
it.
1. Java installation file is included in the CD
accompanying this document. You can find in the
requirements folder in the CD.

2. Go to the requirements folder and run jdk-1_5_0_04-

windows-i586-p.exe file

3. You will be greeted by the java setup wizard. It will

guide through the rest of the setup.

4. This above file should install both JAVA runtime

libraries as well as JAVA development kit
5. Now to set up the path, right click on my computer
and click properties.

6. Click on the advanced tab on open environment

variables.

7. There add the path were java’s bin folder is located.

Default is C:\Program Files\Java\jdk1.5.0_04\bin.

8. Now the environment is up and ready to be used.

Extracting the source files

The source files have been zipped so you will need
some utility like winrar to extract its content
1. To install winrar go to requirements folder in the CD
and click on winrar.exe

2. A wizard will pop up and will guide through the

setup.

3. Now copy steganography.rar file on to the local

drive.

4. Right click on the copied file and click extract here.

 5. This will extract all the source files on to the local
disk

6. Now the files are ready to be complied and executed

Compiling the code

1. . Using command “cd manet1”

2. Type javac –classpath <path of the source

files>\javac *.java

3. That should compile the manet1

4. Type javac –classpath<path of the source

files>\java Split

Running the application

1. To run the program make sure you are in the
application root folder.

2. Type “java –classpath <path of the source

files>\javac *.java;<path of the source files>; java
Split”
 3. The application window pops up. The details on
how to operate the program is described in the next
section

9.2 How to Operate

Implementation

11.2Features of JAVA

The above mentioned algorithms have been implemented

on JAVA because of the characteristics of the language
which are listed below.
• Simple

Java is simple to use for three main reasons: First,

Java is familiar to you if you know C. Second, Java
eliminates components of C that cause bugs and memory
leaks. Java provides a powerful set of pre-tested class
libraries that give you ability to use their advanced features
with just a few additional lines of code.

• Object-Oriented

Java is an object-oriented programming language that

uses software objects called classes and is based upon
reusable, extensible code. This means that you can use
java’s classes, which are sets of variables and methods, as
templates to create other classes with added functionality
without rewriting the code from the parent classes or super
classes.

• Robust

Java is robust because the language removes the use of

pointers and the java runtime system manages memory.
The problems with pointers in C and C++ were that
pointers directly address memory space. In a distributed
environment like the internet, when code is downloaded to
diverse systems, there is no way of knowing for sure that
memory space addressed by pointers is not occupied by the
system. Overwriting this memory space could crash a
system. Java also gives you automatic bounds checking for
arrays, so they cannot index address space not allocated to
the array. Automatic memory management is done using
Garbage Collector, “Creating Your Own Objects.”

• Architecture Neutral

Java is architecture neutral, so your applications are

portable across multiple platforms. Java’s applications are
written and compiled into byte code for java’s virtual
machine. Byte code is converted to binary machine code by
java interpreter installed at the client, so applications need
to be written for individual platforms and then ported from
platform to platform. Java additionally ensures that your
applications are the same on every platform by strictly
defining the sizes of its basic data types and the behavior of
its arithmetic operators. Operator overloading, the process
of modifying the behavior of operators, is prohibited by
java.
 • Exception Handling

An exception is an abnormal condition that arises in

code sequence at run time. In other words, an exception is a
run time error. In computer languages that do not support
exception handling, errors must be checked and handled
manually, typically through the use of error codes and so
on. This approach is as cumbersome as it is troublesome
Java’s exception handling avoids three problems and, in the
process, brings run-time error management into the object-
oriented world.

• Interpreted and High Performance

Java enables the creation of cross-platform programs

by compiling into an intermediate representation called
byte code. This code can be interpreted on any system that
provides Java Virtual Machine. Java byte code was
carefully designed so that it would be easy to translate
directly into native machine code for very high
performance by using a just-in-time compiler.

• Java I/O:

A large part of what network programs do is simple

input and output, moving bytes from one system to another.
I/O in Java is built on streams. A stream represents a flow
of data and is logical entity that connects a data source with
its destination. There are two ways to read and write data to
a file in Java: the first uses byte streams and the second
uses character streams. Input stream read data. Output
streams write data.

JAVA Foundation Classes and JAVA Swing

Swing is a GUI toolkit for Java. Swing is one part of
the Java Foundation Classes (JFC). Swing includes
graphical user interface (GUI) widgets such as text boxes,
buttons, split-panes, and tables. Swing widgets provide
more sophisticated GUI components than the earlier
Abstract Windowing Toolkit. Since they are written in pure
Java, they run the same on all platforms, unlike the AWT,
which is tied to the underlying platform's windowing
system. Swing supports pluggable look and feel – not by
using the native platform's facilities, but by roughly
emulating them. This means you can get any supported
look and feel on any platform. The disadvantage of
lightweight components is possibly slower execution. The
advantage is uniform behavior on all platforms.
With J2SE 1.4.x and now 1.5, Sun have taken great
strides in improving Swing. It's faster, and the new Ocean
theme (though it still draws criticism) is a big step forward
in the modernization of Swing's look, if not its feel.
Trouble is, the rest of the world has advanced apace -
and in certain cases (as we'll explore in this article) leapt
ahead of Swing. As a result, Swing's recent improvements
fail to address certain key issues that may prevent its
wholesale adoption.
One of Swing's main advantages is its incredible
flexibility. If there's something you need to do with your
UI, Swing will get you there. You might have to write a
custom tree-cell renderer, or even your own custom look &
feel, but ultimately you will be able to achieve what you
need to use Swing. Unfortunately, this flexibility comes at
a price. Swing has a steep learning curve for novices. It's
also difficult to master.
Features of the Java Foundation Classes
Feature Description
Swing GUI Includes everything from buttons to
Components split panes to tables.
Gives any program that uses Swing
components a choice of look and feel.
For example, the same program can
use either the Java or the Windows
look and feel. Many more look-and-
Pluggable Look-
feel packages are available from
and-Feel Support
various sources. As of v1.4.2, the
Java platform supports the GTK+
look and feel, which makes hundreds
of existing look and feels available to
Swing programs.
Accessibility API Enables assistive technologies, such
as screen readers and Braille displays,
 to get information from the user
interface.
Enables developers to easily
incorporate high-quality 2D graphics,
text, and images in applications and
Java 2D API
applets. Java 2D includes extensive
APIs for generating and sending high-
quality output to printing devices.
Provides the ability to drag and drop
Drag-and-Drop
between Java applications and native
Support
applications.
Allows developers to build
applications that can interact with
users worldwide in their own
languages and cultural conventions.
Internationalization With the input method framework
developers can build applications that
accept text in languages that use
thousands of different characters,
such as Japanese, Chinese, or Korean.
REFERENCES