1 Software Requirement Specification

4.1.1 Objective:

The main objectives of system for Online voting system are:

The objective of Online voting system is to help the organization in automating the
whole manual processing of the existing system.
The main objective to develop the system is to make the accurate & efficient decisions in
different tasks at different time at different situations. The existing system is manual so
members of the unit generally face a lot of embarrassing situations many times. Now they
need to automate the whole process so as to make it more easy and accurate.
System should support multi-user environment.
System should be fully automated.
System should provide concrete security features like creating users and assigning
privileges to users of the system.
System should be capable to keep track of all the detailed descriptions of the client and the
whole details of services offered by the client organization.
Various outputs (reports) should be available online any time.
System should be able to handle extremely large volumes of data (i.e. Large database
support)

4.1.2 Scope:-

Advanced technology- It is an advanced technology used now a days. It increases the E

knowledge of the users which is very necessary for current generation.
4.1.3 Advantages:

Fast and easy service.

The online voting system provides a less time consuming .

It reduces the paper work and makes the work less tedious for ELESTION COMMISION.

It is a better way for voting.

By this voting percentage will increase drastically.

Voter has no need to go to any polling booth ,so it is easy to use.

4.1.4 Technologies to be used:-

This project will be having

Database Design (Ms Access)

Form Design (VB.NET)
Coding (VB.NET)
Testing (XAMP SERVER)
About vb.net:

.NET Framework SDK

You can develop such varied types of applications. Thats fine. But how? As with
most of the programming languages, .NET has a complete Software Development
Kit (SDK) - more commonly referred to as .NET Framework SDK - that
provides classes, interfaces and language compilers necessary to program for
NET. Additionally it contains excellent documentation and Quick Start tutorials.
that help you learn .NET technologies with ease. Good news is that - .NET
Framework SDK is available FREE of cost. You can download it from the MSDN
web site. This means that if you have machine with .NET Framework installed
and a text editor such as Notepad then you can start developing for .NET right
now!
Rich Functionality out of the box
NET framework provides a rich set of functionality out of the box. It contains.
hundreds of classes that provide variety of functionality ready to use in your
applications. This means that as a developer you need not go into low level details
of many operations such as file IO, network communication and so on.
Easy development of web applications
ASP.NET is a technology available on .NET platform for developing dynamic
and data driven web applications. ASP.NET provides an event driven
programming model (similar to Visual Basic 6 that simplify development of web
pages (now called as web forms) with complex user interface. ASP.NET server
controls provide advanced user interface elements (like calendar and grids) that
save lot of coding from programmers side.
OOPs Support
The advantages of Object Oriented programming are well known. .NET provides
a fully object oriented environment. The philosophy of .NET is Object is
mother of all. Languages like Visual Basic.NET now support many of the OO
features that were lacking traditionally. Even primitive types like integer and
characters can be treated as objects something not available even in OO
languages like C++.
Security
Windows platform was always criticized for poor security mechanisms. Microsoft
has taken great efforts to make .NET platform safe and secure for enterprise
applications. Features such as type safety, code access security and role based
authentication make overall application more robust and secure.

Just-In-Time Compilation (JIT)

The MSIL is the language that all of the .NET languages compile down to. After they
are in this intermediate language, a process called Just-In-Time (JIT) compilation
occurs when resources are used from your application at runtime. JIT allows parts
of your application to execute when they are needed, which means that if something
is never needed, it will never compile down to the native code. By using the JIT, the
CLR can cache code that is used more than once and reuse it for subsequent calls,
without going through the compilation process again.

Assembly
Assemblies are the building blocks of .NET Framework applications; they form the
fundamental unit of deployment, version control, reuse, activation scoping, and
security permissions. An assembly is a collection of types and resources that are
built to work together and form a logical unit of functionality. An assembly provides
the common language runtime with the information it needs to be aware of type
implementations. To the runtime, a type does not exist outside the context of an
assembly

The .NET runtime/Common Language Runtime (CLR) ships three different classes of
JITters. The Main JIT compiler converts the MSIL code it to native code with out any
optimizations. The JIT compiler takes the MSIL code and optimizes it. So this compiler
requires lot of resources like, time to compile, larger memory footprint, etc. The PreJIT
is based on the Main JIT and it works like the traditional compilers (compiles MSIL to
native code during compilation time rather than runtime). This compiler is usually used at
the time of installation.
No matter whatever language we used to develop the HelloWorld program, its a known
fact that compilers are going to generate a MSIL format, once our code has been
converted in to MSIL format, from MSIL format all the code that we write will be
converted to native code in the same way whether if it is a VB.NET source or C# source.

.
Debugging is the most important feature of any programming language and Visual Studio
NET IDE provides this feature in an effective manner (but you can still do pretty good.
job with the .NET SDK alone). Application source code goes through two distinct steps
before a user can run it. First, the source code is compiled to Microsoft Intermediate
Language (MSIL) code using a .NET compiler. Then, at runtime, the MSIL code is
compiled to native code. When we debug a .NET application, this process works in
reverse. The debugger first maps the native code to the MSIL code. The MSIL code is
then mapped back to the source code using the programmer's database (PDB) file. In
order to debug an application, these two mappings must be available to the .NET runtime
environment.
To accomplish the mapping between the source code and the MSIL, use
the/debug:pdbonly compiler switch to create the PDB file (Note: When building
ASP.NET applications, specify the compilation setting debug="true" in the applications
Web.config file). The second mapping between the MSIL code and native code is
accomplished by setting the JITTracking attribute in our assembly. By specifying the
/debug compiler switch, the PDB file is created and the JITTracking attribute is enabled.
When using this compiler switch, a debugger can be attached to an application loaded
outside of the debugger.
Once the required mappings exist, there are several means by which to debug our
applications. We can use the integrated debugger within Visual Studio .NET, or, if we
prefer, we can use DbgClr, a GUI-based debugger. There is also a command line
debugger, CorDBG that is included in the .NET Framework SDK.

Constants &Variables
A variable is a named memory location. They are programming elements that can change
during program execution. Data that needs to be stored in memory & accessed at a later
time are stored in variables. Instead of referring to the memory location by the actual
memory address you refer to it with a variable name.
Variables are declared as follows
Dim a as Integer
They can also be initialized at the time of declaration as follows:
Dim a as Integer = 10
Constants are very similar to variables. The main difference is that the value contained in
memory cannot be changed once the constant is declared. When you declare a constant
its value is also specified and this value cannot be changed during program execution.
Constants are used in situations where we need to keep the value in some memory
location constant. If you use hard-coded values, and the value is changed then it has to be
changed in all the locations in the code where it has been used. Instead if we are using
constants, all we will need to do is to change the value of the constant. This would
propagate the changes to our entire application.

Simple Types (Primitive Data types)

Simple or value type variables are those, which are assigned space in the stack instead of
the heap. All the primitive types such as int, double etc are value type variables. The
simple types basically consist of Boolean and Numeric types, where Numeric is further
divided into Integral and Floating Point.
The first rule of value types is that they cannot be null. Anytime you declare a variable of
value type, you have allocated the number of bytes associated with that type on the stack
and are working directly with that allocated array of bits. In addition, when you pass a
variable of value type, you are passing that variables value and not a reference to the
underlying object.
Object Type
Object type or reference type variables are those, which are allocated storage space in the
heap. Reference type objects can be null. When a reference type is allocated under the
covers a value is allocated on the heap and a reference to that value is returned. There are
basically four reference types: classes, interfaces, delegates and arrays.
Class Type
Custom data types are available in .NET framework in the form of classes or class type. It
is nothing but a set of data and related behavior that is defined by the developer.