metric suit final report

8/22/2019 Metric Suit Final Report

1/32

Metric Suit


2/32

BONAFIED CERTIFICATE


3/32

TABLE OF CONTENTS

CHAPTER TITLE PAGE NO.

ABSTRACT

LIST OF FIGURE

LIST OF ABBREVATIONS

1. INTORDUCTION

1.1 OBJECTIVE

1.2 TOOLS AND TECHNOLOGY

1.2.1 .Net Framework 3.5

1.2.2 C#

1.3 NEED OF SOURCE CODE EDITOR

1.4 PROJECT REQUIREMENTS

2. SYSTEM DESIGN SPECIFICATION

2.1 ENTITY RELATIONSHIP DIAGRAM

2.2 DATA FLOW DIAGRAM

2.3 USE CASE DIAGRAM

2.4 CLASS DIAGRAM

3. PRODUCT SPECIFICATIONS

3.1 BASIC FEATURES

3.2 ADVANCE FEATURES

4. SNAPSHOTS OF PROJECT

5. CONCLUSION

6. BIBILIOGRAPHY


4/32

ABSTRACT

Metric Suit is a source code editor and notepad replacement. It supports Java, C

,C++, C# and VB.Net programming language and provides lot of exclusive

features for user convenience. Metric Suit is a powerful editor targeted towards

programmers and to focus on dynamic implementation of a source code editor.

Metric Suit is completely written in .Net Programming Language: C# so it

provides better UI (User Interface) and programming facilities.

Metric Suit provides all basic editor features (i.e. cut, copy, paste, undo, redo) as

well as advanced features like syntax highlighting and line numbers while writing.

It successfully runs on Windows operating system with a .Net Framework 3.5 and

above. Metric Suit provides quite effective "Search and replace" method, which is

capable of searching both exact words and patterns. This is more than a editor as it

provides compile and run features for Multiple Programming Languages for the

programmers.


5/32


6/32

LIST OF ABBREVATIONS

GUI = Graphics user interface

GPL = General public license

DFD = DATA FLOW DIAGRAM

ER = ENTITY RELATIONSHIP

JIT = Just In Time

I/O = Input - output

INTRODUCTION


7/32

Objective : To design a powerful and user friendly source code editor for Java,C,C++, C#and VB.Net programmers which will be capable of editing as well compile and run this code.

Speed and robustness should be the key factors.

Tools and Technology:

.Net Framework 3.5

The main features of .Net Framework 3.5 are as below, which prompted us to

choose this platform to develop the application of this complex nature.

Interoperability

Because computer systems commonly require interaction between newer andolder applications, the .NET Framework provides means to access

functionality implemented in newer and older programs that execute outside

the .NET environment. Access toCOMcomponents is provided in the

System.Runtime.InteropServices and System.EnterpriseServices namespaces

of the framework; access to other functionality is achieved using

the P/Invoke feature.

Common Language Runtime engine

The Common Language Runtime (CLR) serves as the execution engine of the

.NET Framework. All .NET programs execute under the supervision of the

CLR, guaranteeing certain properties and behaviors in the areas of memory

management, security, and exception handling.

Language independence

The .NET Framework introduces a Common Type System, or CTS. The

CTS specification defines all possible data types and programming constructs

supported by the CLR and how they may or may not interact with each otherconforming to the Common Language Infrastructure (CLI) specification.

Because of this feature, the .NET Framework supports the exchange of types

and object instances between libraries and applications written using any

conforming .NET language.

Base Class Library
http://en.wikipedia.org/wiki/Component_Object_Modelhttp://en.wikipedia.org/wiki/Component_Object_Modelhttp://en.wikipedia.org/wiki/Component_Object_Model


8/32

The Base Class Library (BCL), part of the Framework Class Library (FCL), is a

library of functionality available to all languages using the .NET Framework.

The BCL provides classes that encapsulate a number of common functions,

including file reading and writing, graphic

rendering, database interaction, XML document manipulation, and so on. It

consists of classes, interfaces of reusable types that integrates with

CLR(Common Language Runtime).

Simplified deployment

The .NET Framework includes design features and tools which help manage

the installation of computer software to ensure it does not interfere with

previously installed software, and it conforms to security requirements.

Security

The design addresses some of the vulnerabilities, such as buffer overflows,

which have been exploited by malicious software. Additionally, .NET provides

a common security model for all applications.

Portability

While Microsoft has never implemented the full framework on any system

except Microsoft Windows, it has engineered the framework to be platform-

agnostic,[3]and cross-platform implementations are available for other

operating systems (see Silverlight and the Alternative

implementations section below). Microsoft submitted the specifications for

the Common Language Infrastructure(which includes the core class

libraries, Common Type System, and the Common Intermediate

Language), the C# language, and the C++/CLI language to both and the,

making them available as official standards. This makes it possible for third

parties to create compatible implementations of the framework and its

languages on other platforms.

C#

By design, C# is the programming language that most directly reflects the

underlying Common Language Infrastructure (CLI).Most of its intrinsic types
http://en.wikipedia.org/wiki/.NET_Framework#cite_note-3http://en.wikipedia.org/wiki/.NET_Framework#cite_note-3http://en.wikipedia.org/wiki/.NET_Framework#cite_note-3http://en.wikipedia.org/wiki/.NET_Framework#cite_note-3


9/32

correspond to value-types implemented by the CLI framework. However, the

language specification does not state the code generation requirements of the

compiler: that is, it does not state that a C# compiler must target a Common

Language Runtime, or generate Common Intermediate Language (CIL), or generate

any other specific format. Theoretically, a C# compiler could generate machine

code like traditional compilers of C++ or Fortran. Some notable features of C# that

distinguish it from C and C++ (and Java, where noted) are:

C# supports strongly typed implicit variable declarations with the keyword var,

and implicitly typed arrays with the keyword new[]followed by a collection

initializer.

Meta programming via C# attributes is part of the language. Many of these

attributes duplicate the functionality of GCC's and VisualC++'s platform-

dependent preprocessor directives.

Like C++, and unlike Java, C# programmers must use the keyword virtual to

allow methods to be overridden by subclasses.

Extension methods in C# allow programmers to use static methods as if they

were methods from a class's method table, allowing programmers to add

methods to an object that they feel should exist on that object and its

derivatives.

The type dynamic allows for run-time method binding, allowing for JavaScript

like method calls and run-time object composition.

C# has strongly typed and verbose function pointer support via the

keyword delegate.

Like the QT framework's pseudo-C++ signaland slot, C# has semantics

specifically surrounding publish-subscribe style events, though C# uses

delegates to do so.

C# offers Java like syncronized method calls, via the

attribute [MethodImpl(MethodImplOptions.Synchronized), and has support for

mutually-exclusive locks via the keyword lock.


10/32

The C# languages does not allow for global variables or functions. All methods

and members must be declared within classes. Static members of public classes

can substitute for global variables and functions.

Local variables cannot shadow variables of the enclosing block, unlike C and

C++.

A C# namespace provides the same level of code isolation as a

Java package or a C++ namespace, with very similar rules and features to

a package.

C# supports a strict Boolean data type, bool. Statements that take conditions,

such as while and if, require an expression of a type that implements

the true operator, such as the boolean type. While C++ also has a boolean

type, it can be freely converted to and from integers, and expressions suchas if(a) require only that a is convertible to bool, allowing a to be an int, or a

pointer. C# disallows this "integer meaning true or false" approach, on the

grounds that forcing programmers to use expressions that return

exactly bool can prevent certain types of common programming mistakes in C

or C++ such as if(a = b) (use of assignment =instead of equality ==).

In C#, memory address pointers can only be used within blocks specifically

marked as unsafe, and programs with unsafe code need appropriate

permissions to run. Most object access is done through safe object references,

which always either point to a "live" object or have the well-defined null value;

it is impossible to obtain a reference to a "dead" object (one that has been

garbage collected), or to a random block of memory. An unsafe pointer can

point to an instance of a value-type, array, string, or a block of memory

allocated on a stack. Code that is not marked as unsafe can still store and

manipulate pointers through theSystem.IntPtr type, but it cannot dereference

them. Managed memory cannot be explicitly freed; instead, it is automatically garbage

collected. Garbage collection addresses the problem of memory leaks by freeing

the programmer of responsibility for releasing memory that is no longer needed.


11/32

In addition to the try...catch construct to handle exceptions, C# has

a try...finally construct to guarantee execution of the code in the finally block,

whether an exception occurs or not.

Multiple inheritance is not supported, although a class can implement any

number of interfaces. This was a design decision by the language's lead

architect to avoid complication and simplify architectural requirements

throughout CLI. When implementing multiple interfaces that contain a method

with the same signature, C# allows the programmer to implement each method

depending on which interface that method is being called through, or, like Java,

allows the programmer to implement the method once and have that be the

single invocation on a call through any of the classes interfaces.

C#, unlike Java, supports operator overloading. Only the most commonlyoverloaded operators in C++ may be overloaded in C#.

C# is more type safe than C++. The only implicit conversions by default are

those that are considered safe, such as widening of integers. This is enforced at

compile-time, during JIT, and, in some cases, at runtime. No implicit

conversions occur between booleans and integers, nor between enumeration

members and integers (except for literal 0, which can be implicitly converted to

any enumerated type). Any user-defined conversion must be explicitly marked

as explicit or implicit, unlike C++ copy constructors and conversion operators,

which are both implicit by default.

C# has explicit support for covariance and contra variance, unlike Java which as

neither, and unlike C++ which has some degree of support for contra variance

simply through the semantics of return types on virtual methods.

Enumeration members are placed in their own scope.

C# provides properties as syntactic sugar for a common pattern in which a pair

of methods, accessor (getter) and mutator (setter)encapsulate operations on asingle attribute of a class. No redundant method signatures for the getter/setter

implementations need be written, and the property may be accessed using

attribute syntax rather than more verbose method calls.

Checked exceptions are not present in C# (in contrast to Java). This has been a

conscious decision based on the issues of scalability and versionability.


12/32

Though primarily an imperative language, since C# 3.0 it supports functional

programming techniques through first-class function objects and lambda

expressions.

Needs of Source Code Editor:

Apart of the ordinary notepad users, There is an another group of people who actually work with

other important side of notepad editor, they are computer programmers. Computer programmers

need to have a powerful programming interface where they should be capable of writing code

with ease of access and convenience. So there is always a requirement of good source codeeditor which provide reliable, fast, powerful, and multi featured user interface. There is few other

thing which a programmer may want in source code editor, which is compiling and run facility

for multiple languages so that the user need not have to move from one IDE to other to write

programs for different languages. So Metric Suit is a source code editor which is having all those

requirements. Metric Suit is basically designed for those programmers which works on Multiple

Technology thus it has been designed to support C, C++, Java, C# and VB.Net Languages.


13/32

Project Requirements:

Hardware Requirements

Processor : Celeron 400 Mhz clock speed

Hard Disk : 10GB RAM : 64MB Floppy Disk : 3 inches

Monitor : Samsung 15 inches

Mouse : Logitech Scroll Mouse

Compcat Disk : Samsung CD-ROM

Keyboard : Samsung 101 keys

Software Requirements

.Net Frame work 3.5 and above

Microsoft Visual Studio 2008

C Sharp

Operating System

Windows XP


14/32

SYSTEM DESIGN DIAGRAMS

Entity-Relationship (ER) Diagrams

In software engineering, an entity-relationship model (ERM) is an abstract and conceptual

representation of data. Entity-relationship modeling is a database modeling method, used toproduce a type of conceptual schema or semantic data model of a system, often a relational

database, and its requirements in a top-down fashion. Diagrams created by this process are

called entity-relationship diagrams, ER diagrams, orERDs.

The building blocks: entities, relationships, and attributes:

An entity may be defined as a thing which is recognized as being capable of an independent existence

and which can be uniquely identified. An entity is an abstraction from the complexities of somedomain. When we speak of an entity we normally speak of some aspect of the real world which can

be distinguished from other aspects of the real world.

A relationship captures how two or more entities are related to one another. Relationships can be

thought of as verbs, linking two or more nouns. Examples: an owns relationship between a company

and a computer, a supervises relationship between an employee and a department, a performs

relationship between an artist and a song, a proved relationship between a mathematician and a

theorem. Entities and relationships can both have attributes.


15/32

Diagramming conventions:

Entity sets are drawn as rectangles, relationship sets as diamonds. If an entity set participates in arelationship set, they are connected with a line.

Attributes are drawn as ovals and are connected with a line to exactly one entity or relationship set.

An entity may be a physical object such as a house or a car, an event such as a house sale or a car

service, or a concept such as a customer transaction or order. Although the term entity is the one most

commonly used, following Chen we should really distinguish between an entity and an entity-type.

An entity-type is a category. An entity, strictly speaking, is an instance of a given entity-type. There

are usually many instances of an entity-type. Because the term entity-type is somewhat cumbersome,

most people tend to use the term entity as a synonym for this term.

Entities can be thought of as nouns. Examples: a computer, an employee, a song, a mathematical

theorem. Entity-relationship diagrams don't show single entities or single instances of relations.

Rather, they show entity sets and relationship sets. Example: a particular song is an entity. The

collection of all songs in a database is an entity set. The eaten relationship between a child and her

lunch is a single relationship. The set of all such child-lunch relationships in a database is a

relationship set.


16/32

E R Diagram for Metric Suit Editor

Figure 1

Metric Suit


17/32

Data flow diagram:

A data-flow diagram (DFD) is a graphical representation of the "flow" of data through an

information system. DFDs can also be used for the visualization of data processing (structured

design).

On a DFD, data items flow from an external data source or an internal data store to an internal

data store or an external data sink, via an internal process.

A DFD provides no information about the timing of processes, or about whether processes will

operate in sequence or in parallel. It is therefore quite different from a flowchart, which shows

the flow of control through an algorithm, allowing a reader to determine what operations will be

performed, in what order, and under what circumstances, but not what kinds of data will be input

to and output from the system, nor where the data will come from and go to, nor where the data

will be stored (all of which are shown on a DFD).

The Level 1 DFD shows how the system is divided into sub-systems (processes), each of which

deals with one or more of the data flows to or from an external agent, and which together provide

all of the functionality of the system as a whole. It also identifies internal data stores that must be

present in order for the system to do its job, and shows the flow of data between the various parts

of the system.

Data-flow diagrams were invented by Larry Constantine, the original developer of structured

design, based on Martin and Estrin's "data-flow graph" model of computation.

Data-flow diagrams (DFDs) are one of the three essential perspectives of the structured-systems

analysis and design method SSADM. The sponsor of a project and the end users will need to be

briefed and consulted throughout all stages of a system's evolution. With a data-flow diagram,

users are able to visualize how the system will operate, what the system will accomplish, and

how the system will be implemented. The old system's dataflow diagrams can be drawn up and


18/32

compared with the new system's data-flow diagrams to draw comparisons to implement a more

efficient system. Data-flow diagrams can be used to provide the end user with a physical idea of

where the data they input ultimately has an effect upon the structure of the whole system from

order to dispatch to report. How any system is developed can be determined through a data-flow

diagram.

In the course of developing a set of leveled data-flow diagrams the analyst/designers is forced to

address how the system may be decomposed into component sub-systems, and to identify the

transaction data in the data model.

There are different notations to draw data-flow diagrams, defining different visual

representations for processes, data stores, data flow, and external entities.

Data flow diagram ("bubble charts") are directed graphs in which the nodes specify processing

activities and the arcs specify data items transmitted between processing nodes.

DFD is also a virtually designable diagram that technically or diagrammatically describes the

inflow and outflow of data or information that is provided by the external entity.


19/32

Level 0 DFD:

Level 0 and level 1 are probably the easiest for someone to create, because they are done

at such a high level view.

Shows the systems major processes, data flows, and data stores at a high level of

abstraction.

Level 0 DFD shows how the system is divided into sub-systems(processes).

It also identifies internal data stores that must be present in order for the system to do its

job.

Shows the flow of data between the various parts of the system.

When the Context Diagram is expanded into DFDlevel-0, all the connections that flow

into and out of process 0 needs to be retained.

0Level DFD

Figure 2

Metric Suit


20/32

Level 1 DFD:

The next stage is to create the Level 1 Data Flow Diagram. This highlights the main

functions carried out by the system. As a rule, we try to describe the system using

between two and seven functions - two being a simple system and seven being a

complicated system. This enables us to keep the model manageable on screen or paper.

Level 1 DFD

Figure 3


21/32

Use Case:

A use case diagram in the Unified Modeling Language (UML) is a type of behavioral diagram

defined by and created from a Use-case analysis. Its purpose is to present a graphical overview

of the functionality provided by a system in terms of actors, their goals (represented as use

cases), and any dependencies between those use cases.

Use cases are a software modeling technique that helps developers determine which features to

implement and how to gracefully resolve errors.

Within systems engineering, use cases are used at a higher level than within software

engineering, often representing missions or stakeholder goals. The detailed requirements may

then be captured in SysML requirement diagrams or similar mechanisms.

The main purpose of a use case diagram is to show what system functions are performed for

which actor.

Actors:

An actor is a person, organization, or external system that plays a role in one or more interactions

with the system. The same person using the system may be represented as different actors

because they are playing different roles. For example, user "Joe" could be playing the role of a

Customer when using an Automated Teller Machine to withdraw cash, or playing the role of a

Bank Teller when using the system to restock the cash drawer.

Types of Actors:

Primary Actor - Fulfills the user goals by using the services of the SuD (System Under

Discussion). Ex: 'Cashier' in a Process Sale System.

Secondary Actor - Provides a service to the SuD. Ex: 'Automated payment authorization

service'.

Offstage Actor- Has an interest in the behavior of the system but is not primary or secondary.

Ex: A government tax agency.


22/32

Actor Generalization

One popular relationship between Actors is Generalization/Specialization. This is useful in

defining overlapping roles between actors. The notation is a solid line ending in a hollow triangle

drawn from the specialized to the more general actor.

Use Case Relationships

Four relationships among use cases are used often in practice.

Include

In one form of interaction, a given use case may include another. "Include is a Directed

Relationship between two use cases, implying that the behavior of the included use case is

inserted into the behavior of the including use case".

The first use case often depends on the outcome of the included use case . This is useful for

extracting truly common behaviors from multiple use cases into a single description. The

notation is a dashed arrow from the including to the included use case, with the label

"include". This usage resembles a macro expansion where the included use case behavior is

placed inline in the base use case behavior. There are no parameters or return values. To specify

the location in a flow of events in which the base use case includes the behavior of another, you

simply write include followed by the name of use case you want to include.

Extend

In another form of interaction, a given use case (the extension) may extendanother. The

relationship indicates that the behavior of the extension use case may be inserted in the extended

use case under some conditions.The notation is a dashed arrow from the extension to the

extended use case, with the label "extend". The notes or constraints may be associated with

this relationship to illustrate the conditions under which this behavior will be executed.

Modelers use the extend relationship to indicate use cases that are "optional" to the base use

case. Depending on the modeler's approach "optional" may mean "potentially not executed with

the base use case" or it may mean "not required to achieve the base use case goal".


23/32

Generalization

In the third form of relationship among use cases, ageneralization/specialization relationship

exists. A given use case may have common behaviors, requirements, constraints, andassumptions with a more general use case. In this case, describe them once, and deal with it in

the same way, describing any differences in the specialized cases. The notation is a solid line

ending in a hollow triangle drawn from the specialized to the more general use case (following

the standard generalization notation).

Associations

Associations between actors and use cases are indicated in use case diagrams by solid lines. An

association exists whenever an actor is involved with an interaction described by a use case.

Associations are modeled as lines connecting use cases and actors to one another, with an

optional arrowhead on one end of the line. The arrowhead is often used to indicate the direction

of the initial invocation of the relationship or to indicate the primary actor within the use case.

The arrowheads imply control flow and should not be confused with data flow.


24/32

USE CASE DIAGRAM

Figure 4


25/32

Class Diagram:

The class diagram is the main building block of object oriented modeling. It is used both for

general conceptual modeling of the systematic of the application, and for detailed modeling

translating the models into programming code. Class diagrams can also be used for data

modeling. The classes in a class diagram represent both the main objects and or interactions in

the application and the objects to be programmed.

In the class diagram these classes are represented with boxes which contain three parts:

.

The upper part holds the name of the class

The middle part contains the attributes of the class

The bottom part gives the methods or operations the class can take or undertake

In the system design of a system, a number of classes are identified and grouped together in a

class diagram which helps to determine the static relations between those objects. With detailed

modeling, the classes of the conceptual design are often split into a number of subclasses.

In order to further describe the behavior of systems, these class diagrams can be complemented

by state diagram or UML state machine. Also instead of class diagrams Object role modeling can

be used if you just want to model the classes and their relationships.

Visibility:

To specify the visibility of a class member (i.e., any attribute or method) there are the following

notations that must be placed before the member's name


26/32

+ Public

- Private

# Protected~ Package

/ Derived

Underline Static

Some important concepts in class diagram are given below:

Association:

An association represents a family of links. Binary associations (with two ends) are normally

represented as a line, with each end connected to a class box.

Aggregation:

Aggregation is a variant of the "has a" or association relationship; aggregation is more

specific than association. It is an association that represents a part-whole or part-of

relationship.

Composition:

Composition usually has a strong life cycle dependency between instances of the container

class and instances of the contained class(es): If the container is destroyed, normally every

instance that it contains is destroyed as well.

Generalization:

The Generalization relationship ("is a") indicates that one of the two related classes

(thesubclass) is considered to be a specialized form of the other (thesuper type) and super

class is considered as 'Generalization'of subclass.


27/32

Class Diagram

Figure 5

Metric Suit


28/32

PRODUCT SPECIFICATIONS

Metric Suit Source Code Editor is having number of interactive features which are

mentioned here respectively

Basic Features:

1. File Operations:

Metric Suit Source Code Editor supports a number of file operations, which allows a user to

write code with convenience. Some of these operations are given here :

(a)New: Opening a new file in text editor to edit or write code.

(b)Open: To Open any document for editing or as a new file.

(c)Close: To close the current document or all the document opened in source code editor.

(d) Save: To Save the current file permanently into the disk (with a valid name as per the

operating system).

(e) Save As: To Save the current file with different file name or as a duplicate copy of the

current document.

Advanced Features:

1. Execution of code:This consist of two major features which makes that editor

more useful. they are compiling, and run facilities.

Compile: In this state editor checks for the syntactical and Symantec of

the source code. It is connected to the Java,C,C++,VB.Net and C# Compiler

which enables all the parsing and optimization features.

2. Run: After successful compilation of the source code it's sent to the run time

environment and this enables the execution of byte code created by Compiler.

3. Help: Help set is provided to user to understand the Metric Suit manual. It has

basically 2 major options which are given here


29/32

(i) About Us: Gives information about Metric Suit developer team and their

contact ways.

(ii)About Software: Gives any random tips about Metric Suit editor


30/32

SNAPSHOTS OF PROJECT


31/32

CONCLUSION

The primary goal of this report is to identify action initiatives that make up the

information details regarding Metric SuitMulti Language Source Code editor.

The application is made in all possible way to meet the user requirements using

latest version of available software and hardware. But as user requirements and

operating environment keep changing further extensions can be made on this. The

project that has been developed is a part of programmer's developing tool , so it

can be used and extended the scope and domain of project.


32/32

BIBLOGRAPHY

1. Complete Reference Of .Net Framework: Herbert Schildt

2. A C# primer : E. Balguruswamy

3. COMPLETE .Net Certification : Simon Roberts

Philip Heller

Michael Ernest

4. C# Advance programming : Jason Hunter

William Crawford

metric suit final report

Documents