Type, Signature and Visibility

Type:

The Type of an attribute specifies the range of values the attribute can take and the operations that can be applied to the attributes.

Signature:

Given an operation, the tuple made out of the types of its parameters and the type of the return value is the Signature. Signatures are generally defined for operations.

Visibility:

The Visibility of an attribute or an operation is a mechanism for specifying whether other classes can use the attribute or the operation or not. In general there are three levels of visibility:

Private Attribute or Operation     (indicated by ‘-‘)

Protected Attribute or Operation (indicated by ‘#‘)

Public Attribute or Operation      (indicated by ‘+‘)

Constraints

In this step we identify the constraints for each operation in each class. The conditions to perform an operation and to complete an operation are to be known to describe the operations. The various Pre and Post conditions of the system are as follows:

/* to login purpose user must register first */

Context: user:: register(id)  pre:

/* to communicate with user client in a LAN we need to establish a connection. */

Context: user:: connect(client)  pre:

/* disconnection is complete only after finishing the chatting */

Context: user:: server disconnection () post:

Invariants and Inheriting Contracts:

Invariants are complicated conditions that are implemented during the design that enables the developer to generate the code easily. In the present system there are no such combinations of conditions to describe
 

About Class Diagram in CCFD

About Class Diagram:

Class diagrams model class structure and contents using design elements such as classes, packages and objects. Class diagrams describe three different perspectives when designing a system, conceptual, specification, and implementation. Classes are composed of three things: a name, attributes, and operations. Class diagrams also display relationships such as containment, inheritance, associations and others. The association relationship is the most common relationship in a class diagram.  The association shows the relationship between instances of classes.  The multiplicity of the association denotes the number of objects that can participate in then relationship.

object specification in CCFD

object specification

Object Design is an activity during which developers develop custom objects to bridge the gap between the application objects and off-the-shelf components by identifying additional solution objects and refining objects.

Object design includes:

Reuse: During which developers identify off-the-shelf components and design patterns to make use of existing solutions.

Service Specification: During which developers precisely describe each class interface.

Object Model Restructuring: During which we transform the object design model to improve its understandability and extensibility.

Object Mode Optimization: During which developers transform the object design model to address performance criteria such as response time, memory utilization.

Specification inheritance & Implementation inheritance:

Inheritance is the best way to implement the most critical tasks that are well defined in the Operating System. These operations are present in the system, we need not develop any new method, and just we extract and extend the methods present. The exam operations present in the system are fallows there are some other methods that are inherited and can be used to implement the system with ease by reducing the coding activity.

 Selecting patterns:

In the system design and other phases implemented we defined more goals in different manner with a complexity in them. To achieve all these goals we need to define architecture, which enables us to deal with complexity and allow flexibility to deal with change later in development process.

Verification and Validation & Installation Guidelines ( In CCFD)

            Verification is the process of checking the product built is right or not. Validation is the process of checking whether the right product is built or not. 

Verification and Validation of the system is integrated into the system while it is coded. All the code is tested using the .NET Framework for unit level perfection at the time of coding. However various tests and test cases are designed to employ on the system for its effectiveness and efficiency.

During the system development, coding for the object has been thoroughly verified from different aspects regarding their design. In the way they are integrated and etc.

Validations applied to the entire system at two levels:

Form level Validation: Validation of all the inputs given to the system at various points in the forms are validated while navigating to the next form. System raises appropriate custom and pre-defined exceptions to alert the user about the errors occurred or likely to occur.

Field level Validation: Validations at the level of individual controls are also applied wherever necessary. System pops up appropriate and sensuous dialogs wherever necessary.

Installation guidelines include the following steps

1.       Install  .NET FRAMEWORK 2.0 or above

2.       Now  you can run the application by double clicking the .exe provided

                                                (Or)

“Install by clicking the setup file and run the application thereafter”

Information Handling and Programming Style

Information Handling

            Any software system require some amount of information during its operation selection of appropriate data structures can help us to produce the code so that objects of the same system can better operate with the available information decreased complexity.

In this project, if any one of the input is not given or inappropriate input was given it displays an error message, and also specifies what the error is.

 Programming Style

The .NET Framework has no restrictions on the types of application possible, as we discussed above. VB uses the framework, and so also has no restrictions on possible applications. However, let's look at a few of the more common application types:

Windows Applications – These are applications such as Microsoft Office, which have a familiar Windows look and feel about them. This is made simple using the Windows Forms module of the .NET Framework, which is a library of controls (such as buttons, toolbars, menus, and so on) that we can use to build a Windows user interface (UI).

Web Applications – These are web pages such as might be viewed through any web browser. The .NET Framework includes a powerful system of generating web content dynamically, allowing personalization, security, and much more. This system is called Active ServerPages.NET (ASP.NET) and we can use VB to create ASP.NET applications using Web Forms.

Web Services – These are a new and exciting way of creating versatile distributed applications. Using web services we can exchange virtually any data over the Internet, using the same simple syntax regardless of the language used to create a web service, or the system that it resides on.

Programming style deals with a set of rules that a programmer has to follow so that the characteristics of coding such as traceability, understandability, modifiability, extensibility can be satisfied.

In the current system we followed the coding rule for naming the variables and methods. As part of coding internal documentation is also provided that help the readers to better understand the code.

Coding in CCFD

The goal of the coding or programming phase is to translate the design of the system produced during the design phase into code in a given programming language, which can be executed by a computer and that performs the computation specified by the design.

The coding phase affects both testing and maintenance.  The goal of coding is not to reduce the implementation cost but the goal should be to reduce the cost of later phases. In other words the goal is not to simplify the job of programmer.  Rather the goal should be to simplify the job of the tester and maintainer.

6.1 Coding Approach

            There are two major approaches for coding any software system.  They are top-Down approach and Bottom-up approach.        

Bottom-up approach can be best suitable for developing the object oriented systems. During system design phase to reduce the complexity, we decompose the system into an appropriate number of subsystems, for which objects can be modeled independently. These objects exhibit the way the subsystems perform their operations. Once objects have been modeled they are implemented by means of coding. Even though related to the same system as the objects are independent of each other the Bottom up approach is more suitable for coding these objects.           

In this approach we first do the coding of objects independently and then we integrate these modules into one system to which they belong.

Boundary Conditions in ccfd

During this activity, we review the design decisions we made so far, and identify additional use cases.

1. Configuration use cases:

The handling of most persistent objects is already described in the use cases developed during analysis. Additional use cases are identified when reviewing persistent objects.

2. Exceptional use cases:

In general, an exception is an unexpected event or error that occurs during the execution of the system exceptions are caused by

A user error:  The user mistakenly or deliberately inputs data that are out of bounds for example; a negative value or a fractional value in a genetic parameter could lead to wrong and inconsistent data

A Hardware failure: Hardware ages and fails.

A Software bug: An error can occur either because the system or on its components contain a design error. Although writing bug free software is difficult.

System Architecture og CCFD

System Architecture describes the subsystem decomposition in terms of subsystem responsibilities, dependencies among subsystems, subsystem mapping to hardware and major policy decisions such as control flow, access control and data storage.

Popular System Architectures are as follows:

      Repository

      Model/View/Controller (MVC)

      Document/View /Controller (DVC)

     Peer-to-Peer

      Client/Server

      Three-tier

      Four-tier

      Pipe and Filter

The architecture of the present system is of great importance. The architecture of the tool is Model/view/Controller (DVC) and two-tier Architecture

Design Goals in CCFD

A design goal is a quality that the system should optimize. Design goals are often inferred from non-functional requirements and are used to guide design decisions. Examples of Design goals include usability, reliability, security and safety. The following are the design goals that are to be met during the design of the system under consideration:

Response Time: The proposed system should be very responsive as it is a stand-alone system and involves no client/server interactions.

Usability: Users capable of handling simple GUI’s must be able to use the system

Reliability: Users may rely on the system for an effective and secure data hiding and distribution. Hence the schemes should be guaranteed for security.

Cost: Since the proposed system is a free ware. No high development and maintenance costs should be incurred.

Portability: As the system is targeted for developing using .net, Platform portability is inherited into the system by default.

Object Interaction in CCFD

Object Interaction:

Interaction diagrams model the behavior of use cases by describing the way groups of objects interact to complete the task.  The two kinds of interaction diagrams are sequence and collaboration diagrams. Sequence diagrams generally show the sequence of events that occur. Sequence diagrams demonstrate the behavior of objects in a use case by describing the objects and the messages they pass.  The diagrams are read left to right and descending. Following are the Sequence Diagrams for the system under consideration:

Collaboration diagram:

Sequence diagram:

Controller object in CCFD

The Controller object in this system is described as follows:

Entity , Boundary and Control objects

Entity objects:

                        Entity Objects represent the persistent information tracked by the system.

The set of Entity Objects that are involved in the system are as follows:

       authentication:

Here providing authentication between two nodes and also password based authentication for logging.

      TCP/IP protocols :

Here providing Communication link between the two nodes.

      Client:

Client is a node that uses to receive services from server.

      Server :

Server is a node that provides services to the Client.

3.2 Boundary Objects:

Boundary Objects represent the interactions between the actor and the system. The set of Boundary Objects that are involved in the system are as follows:

3.3 Control Objects:

Control Objects are in-charge of realizing use cases. These are responsible for coordinating Boundary objects and Entity objects. Control objects describe the behavior associated with the sequencing of forms, undo and history queues and dispatching information in a distributed system.

Participating Objects

Client:

He/She login the system for chatting with other person. So, they enter the username and password. Instead of this we providing MD5 password based authentication for future seeking of hackers.

Here client be two persons i.e.

i.         Administrator

ii.       User

            Here administrator client was handles administrator works like giving username and password to the respected user and manages the server.

               Here user client takes the username and password then goes to the chat room and them with respected user. After authentication then they chooses respective opponent and the client must request to the server for connect the choose user system using his/her node TCP/ IP address. Finally communicate with each other

Server:

He/She connects the server to the respected user with respect TCP/ IP, port address and system name. The server provides services for the clients.

Requirement Elicitation and How to Microsoft .Net Framework

Microsoft .Net Languages Source Code are compiled into Microsoft Intermediate Language (MSIL) . MSIL we can call it as Intermediate Language (IL) or Common Intermediate Language (CIL). Microsoft Intermediate Language (MSIL) is a CPU independent set of instructions that can be converted to the native code. Metadata also created in the course of compile time with Microsoft Intermediate Language (MSIL) and stored it with the compiled code . Metadata is completely self-describing . Metadata is stored in a file called Manifest, and it contains information about the members, types, references and all the other data that the Common Language Runtime (CLR) needs for execution.

The Common Language Runtime (CLR) uses metadata to locate and load classes, generate native code, provide security, and execute Managed Code. Both Microsoft Intermediate Language (MSIL) and Metadata assembled together is known as Portable Executable (PE) file. Portable Executable (PE) is supposed to be portable across all 32-bit operating systems by Microsoft .Net Framework.

During the runtime the Common Language Runtime (CLR)'s Just In Time (JIT) compiler converts the Microsoft Intermediate Language (MSIL) code into native code to the Operating System. The native code is Operating System independent and this code is known as Managed Code , that is, the language's functionality is managed by the .NET Framework . The Common Language Runtime (CLR) provides various Just In Time (JIT) compilers, and each works on a different architecture depends on Operating Systems, that means the same Microsoft Intermediate Language (MSIL) can be executed on different Operating Systems. In the following section you can see how Common Language Runtime (CLR) functions.

Requirement Elicitation of CCFD - What is .Net Frame work

What is Microsoft .Net Framework

The Microsoft .Net Framework is a platform that provides tools and technologies you need to build Networked Applications as well as Distributed Web Services and Web Applications. The .Net Framework provides the necessary compile time and run-time foundation to build and run any language that conforms to the Common Language Specification (CLS).The main two components of .Net Framework are Common Language Run time (CLR) and .Net Framework Class Library (FCL).

The Common Language Runtime (CLR) is the runtime environment of the .Net Framework that executes and manages all running code like a Virtual Machine. The .Net Framework Class Library (FCL) is a huge collection of language-independent and type-safe reusable classes. The .Net Framework Class Libraries (FCL) is arranged into a logical grouping according to their functionality and usability is called Namespaces. In the following sections describes how to .Net Framework manages the code in compile time and run time.

Hardware and Software Requirements

Hardware Requirements:

TYPE	MINIMUM	RECOMMENDED
Processor	400 MHz	800 MHz or above
Memory	96 MB (Client) 128 Mb (Server)	256 megabytes (MB) or above
Hard Disk Space	280 megabytes (MB)	1 gigabyte (GB)
Display	800 x 600 256 colors	1024 x 768 High Color (16-bit)

Software Requirements:

     Operating System:

               Any Operating system

      Database Support:

               Required to stored information of user details & file info

      Integrating Development Environment :

                    There are no requirements

      Web Server:

               The system does not need any web server.