INDEX
ACKNOWLEDGEMENT
CERTIFICATE
PART – I (ABOUT TOOLS PROJECT)
MISSION AND AIMS
COMMITTEE
MEMBER’S LIST
INTRODUCTION TO TOOLS
PROJECT
ACHIEVEMENTS
PART II (ABOUT FRONT-END AND BACK-END)
INTRODUCTION
TO PHP
INTRODUCTION
TO MY SQL
HARDWARE
AND SOFTWARE REQUIREMENTS
PART – III (ABOUT PROJECT)
SYSTEM DEVELOPMENT LIFE
CYCLE
LIMITATIONS AND ADVANTAGES OF PROJECT
DATA FLOW DIAGRAMS
DATABASE DESIGNS
ABOUT FORMS
ABOUT
REPORTS
ABOUT TABLES
OUTPUT
AND CODING
REFERENCE
ACKNOWLEDGEMENT
We have found this golden chance to
acknowledge all those people who had blessed, Encouraged and supported us
technically and normally and through all
the phases of this project.
There are many people who deserve
acknowledgement and gratitude for their contribution to the development and completion
of this project.
We would like to express our
sincere thanks to my project supervisors
Mr.Tarun
Kumar Lakhanpal for his constant help and encouragement in our project.
We also thank all our
classmates and friends for their valuable suggestions and help during the
project work.
CERTIFICATE
This is
to certified that Project on Mail Server “TOOLS PROJECT” has been developed and
implemented by Janu Bajaj(College Roll No.105326) students of BTech-II GNDEC,Ludhiana
.This Project is not entitled to another university or college.
I first want to motivate this talk by discussing why we
chose email as a research target. There are several reasons. First is that mail
is important. The use of large scale email service are rapidly expanding these
days, and we see a real demand here..
The next reason is that mail is a difficult problem,
especially compared to a typical web service, which has been studied very
extensively. Unlike simple web, mail is a type of application that is more
write intensive, and has lower access locality. These properties make it
difficult to use techniques, such as proxies, that are effective in scaling we
services.
On the other hand, mail turns out to be easier than
traditional data storage services such as distribute file systems or data base
services. First, mail has a well defined
and narrow API, which is a message send
and receive rather than a generic byte read/write. Also, the mail workload has
large inherent parallelism, so we can scale the system without worrying much
about access conflicts. Finally, consistency requirement for mail is fairly
weak. We experience delay in mail delivery or duplicate messages all so often.
To summarize, the service requirements for mail sits somewhere between web and
database, and we believed we could come up with a better architecture by not
binding ourselves to either web or database.
|
|
 |
The goal of the project is to build a very large scale email
service using just a cheap commodity hardware. When we say large, today’s large
mail sites, such as AOL or hotmail handles about 100 million messages per day,
and given that Internet is still growing rapidly, we can expect an order of
magnitude growth in the scale of email servers. That’s the area we target,
about 1 billion messages per day.
The key word in our project is to “scale”, and we define the
work along three axes. First, of course, we need the system performance to
scale. Not only that, we need to scale in terms of managing. We expect the mail
traffic to constantly grow, and therefore the mail server needs to grow continuously
as well.Our decision to use commodity hardware makes the system more prone to
component failures. Thus, we want the system to survive gracefully various
types of failures, including multiple node failures and network partitions.
GOALS
Availability Manageability Performance
Goals:
Maintain
function after failures
React
quickly to changes regardless of cluster size
Graceful
performance degradation / improvement
Strategy: Two complementary mechanisms
Hard state: email messages, user profile
Þ Optimistic
fine-grain replication
Soft state: user map, mail map
Þ Reconstruction after membership change
Now our first issue is how we scale performance linearly
with the cluster size, and the strategy is to partition data management
responsibility uniformly among nodes to avoid creating hot spots, and to make
the partition very fine grain to further reduce the chance of creating hot
spots.
I actually already described the data structures such as
user map and mail map that achieves these goals, so I don’t repeat them. I’ll
just show you a graph tells how our design
scales in practice.
Tools Project
The responsibility for defining the project scope is often assumed by the
project manager. He is likely to employ a tool—like a Work Breakdown Structure
(WBS)— to define the deliverables, such as requirements specifications, design
plans, source code modules and training delivery. The problem with a WBS is
that it doesn't provide a clear enough picture of the functional requirements,
and as we all know, "the devil is in the details." Project managers
must focus on the broad picture, and should rely on a business analyst to focus
on the requirements scope: Who will use the system? What do they need it to do?
What information is needed to do it?
Today's business analysts are equipped with two important tools for defining
the project scope requirements: context diagrams and use case models. The first
thing a business analyst should do when assigned to a project is to confirm
that these two models exist, and have been approved and accepted by the
stakeholders. If they don’' exist, or haven’t been approved, the business
analyst should tackle these before starting detailed business system analysis.
A project scope, or project scope statement, is a tool used to describe the
major deliverables of a project including the key milestones, high level
requirements, assumptions, and constraints. The project scope statement is a
useful tool for future decision making when new change requests are considered
to modify the project scope. It also defines the boundaries of a given project
and clarifies what deliverables are in and out of scope. The following sections
describe a project scope statement and show you how to use MatchWare MindView
to create a project scope statement.
CATEGORIES IN TOOLS PROJECT…….
Air Tools
Air Polisher
Bearing for Power
Tools Pad
Polisher
Accessories
Twist Drill Bit
PART-II
(About Front-end
and Back-end)
ABOUT FRONT-END
AND BACK-END
INTRODUCTION TO PHP
PHP
|
|
|
|
|
|
Appeared in
|
|
|
Designed by
|
|
|
|
The
PHP Group
|
|
|
5.3.4
(December 10, 2010; 20 days ago (2010-12-10))
|
|
|
|
|
|
|
|
Influenced by
|
|
|
Influenced
|
|
|
Implementation language
|
|
|
|
|
|
|
|
|
|
.php,
.phtml .php5 .phps
|
|
|
|
|
|
PHP: Hypertext Preprocessor is a widely used, general-purpose scripting language that was originally designed
for web development to produce dynamic
web pages. For this purpose, PHP code is embedded into the HTML source document
and interpreted by a web server with a PHP processor module, which generates
the web page
document. As a general-purpose programming language, PHP code is processed by
an interpreter application in command-line
mode performing desired operating system operations and producing program
output on its standard output channel. It may also function as a graphical
application. PHP is available as a processor for most modern web servers and as
a standalone interpreter on most operating
systems and computing platforms.
PHP was originally created by Rasmus
Lerdorf in 1995[1][2] and has been
in continuous development ever since. The main implementation of PHP is now
produced by the PHP Group and serves as the de
facto standard for PHP as there is no formal specification.[3] PHP
is free
software released under the PHP License.
<HTML>
<?php
PHP code ?>
</HTML>
|
|
<HTML>
<B>Hello</B>
</HTML>
|
|
HISTORY
PHP originally stood for
personal home page.
[3] Its
development began in 1994 when the
Danish/
Greenlandic
programmer
Rasmus Lerdorf initially created a set of
Perl scripts he called
'Personal Home Page Tools' to maintain his
personal
homepage, including tasks such as displaying his résumé and recording how
much
traffic
his page was receiving.
[3][4][5]
He rewrote these scripts as
C programming language Common Gateway Interface (CGI)
binaries,
extending them to add the ability to work with
web forms and
to communicate with
databases and called this implementation 'Personal Home
Page/Forms Interpreter' or PHP/FI. PHP/FI could be used to build simple,
dynamic
web applications. Lerdorf released PHP/FI as
'Personal Home Page Tools (PHP Tools) version 1.0' publicly on June 8, 1995, to
accelerate
bug location and improve the code.
[6] This release
already had the basic functionality that PHP has today. This included Perl-like
variables, form handling, and the ability to embed HTML. The syntax was similar
to Perl but was more limited and simpler, although less consistent.
[3] A
development team began to form and, after months of work and
beta testing, officially released PHP/FI 2 in
November 1997.
Zeev
Suraski and
Andi Gutmans, two
Israeli developers
at the
Technion
IIT, rewrote the
parser in 1997 and formed the base of PHP 3, changing the
language's name to the
recursive initialism PHP: Hypertext
Preprocessor.
[3]
Afterwards, public testing of PHP 3 began, and the official launch came in June
1998. Suraski and Gutmans then started a new
rewrite of PHP's core, producing the
Zend Engine
in 1999.
[7]
They also founded
Zend Technologies in
Ramat Gan,
Israel.
[3]
On May 22, 2000, PHP 4, powered by the
Zend Engine
1.0, was released.
[3] As
of August 2008 this branch is up to version 4.4.9. PHP 4 is no longer under
development nor will any security updates be released.
[8][9]
On July 13, 2004, PHP 5 was released, powered by the new
Zend Engine
II.
[3]
PHP 5 included new features such as improved support for
object-oriented programming, the PHP
Data Objects (PDO) extension (which defines a lightweight and consistent
interface for accessing databases), and numerous performance enhancements.
[10] In 2008 PHP
5 became the only stable version under development.
Late static binding had been missing from PHP
and was added in version 5.3.
[11][12]
A new major version has been under development alongside PHP 5 for several
years. This version was originally planned to be released as PHP 6 as a result
of its significant changes, which included plans for full Unicode support.
However, Unicode support took developers much longer to implement than
originally thought, and the decision was made in March 2010
[13] to move the
project to a branch, with features still under development moved to a trunk.
Changes in the new code include the removal of
register_globals,
[14] magic
quotes, and
safe mode.
[8][15] The reason
for the removals was that register_globals had given way to security holes, and
the use of magic quotes had an unpredictable nature, and was best avoided.
Instead, to escape characters, magic quotes may be replaced with the
addslashes() function, or more appropriately an escape mechanism specific to
the database vendor itself like mysql_real_escape_string() for
MySQL. Functions that
will be removed in future versions and have been deprecated in PHP 5.3 will
produce a warning if used.
[16]
Many high-profile open-source projects ceased to support PHP 4 in new code
as of February 5, 2008, because of the GoPHP5 initiative,
[17]
provided by a consortium of PHP developers promoting the transition from PHP 4
to PHP 5.
[18][19]
PHP currently does not have native support for
Unicode or
multibyte strings; Unicode support is under development for a future version of
PHP and will allow strings as well as class, method, and function names to
contain non-
ASCII
characters.
[20][21]
PHP interpreters are available on both
32-bit and
64-bit operating
systems, but on
Microsoft Windows the only official distribution
is a 32-bit implementation, requiring Windows 32-bit compatibility mode while
using
Internet Information Services (IIS)
on a 64-bit Windows platform. As of PHP 5.3.0, experimental 64-bit versions are
available for MS Windows.
[22]
Licensing
PHP is
free software released under the
PHP License,
which insists that:
4. Products derived from this software may not be called "PHP", nor
may "PHP" appear in their name, without prior written permission
from group@php.net. You may indicate that your software works in
conjunction with PHP by saying "Foo for PHP" instead of calling
it "PHP Foo" or "phpfoo"
|
|
Meaning
|
|
Red
|
Release no longer supported
|
|
Green
|
Release still supported
|
|
Blue
|
Future release
|
|
|
|
|
Major version
|
Minor version
|
Release date
|
Notes
|
|
1
|
1.0.0
|
1995-06-08
|
Officially called
"Personal Home Page Tools (PHP Tools)". This is the first use of
the name "PHP".[3]
|
|
2
|
2.0.0
|
1997-11-01
|
Considered by its creator as
the "fastest and simplest tool" for creating dynamic web pages.[3]
|
|
3
|
3.0.0
|
1998-06-06
|
Development moves from one
person to multiple developers. Zeev Suraski and Andi Gutmans rewrite the base
for this version.[3]
|
|
4
|
4.0.0
|
2000-05-22
|
Added more advanced two-stage
parse/execute tag-parsing system called the Zend engine.[25]
|
|
4.1.0
|
2001-12-10
|
Introduced 'superglobals' ($_GET, $_POST, $_SESSION, etc.)[25]
|
|
4.2.0
|
2002-04-22
|
Disabled register_globals by
default. Data received over the network is not inserted directly into the global
namespace anymore, closing possible security holes in applications.[25]
|
|
4.3.0
|
2002-12-27
|
|
|
4.4.0
|
2005-07-11
|
Added man pages for phpize and php-config scripts.[25]
|
|
4.4.2
|
2006-01-13
|
Various fixes as per the
reference.[25]
|
|
4.4.8
|
2008-01-03
|
Several security enhancements
and bug fixes. Was to be the end of life release for PHP 4. Security updates
only until 2008-08-08, if necessary.[27]
|
|
4.4.9
|
2008-08-07
|
More security enhancements and
bug fixes. The last release of the PHP 4.4 series.[28][29]
|
|
5
|
5.0.0
|
2004-07-13
|
Zend Engine II with a new
object model.[30]
|
|
5.1.0
|
2005-11-24
|
Performance improvements with
introduction of compiler variables in re-engineered PHP Engine.[30]
|
|
5.2.0
|
2006-11-02
|
Enabled the filter extension
by default. Native JSON
support.[30]
|
|
5.2.11
|
2009-09-16
|
Bug and security fixes.
|
|
5.2.12
|
2009-12-17
|
Over 60 bug fixes, including 5
security fixes.
|
|
5.2.13
|
2010-02-25
|
Bug and security fixes.
|
|
5.2.14
|
2010-07-22
|
Bug and security fixes.
|
|
5.2.15
|
2010-12-10
|
Bug and security fixes.[31]
|
|
5.2.16
|
2010-12-16
|
The last release of PHP 5.2
series. Corrects some regressions introduced in PHP 5.2.15.[32]
|
|
5.3.0
|
2009-06-30
|
Namespace support; Late
static bindings, Jump label (limited goto), Native closures, Native PHP archives (phar), garbage collection for circular
references, improved Windows support, sqlite3, mysqlnd as a
replacement for libmysql as underlying library for the extensions that work
with MySQL,
fileinfo as a replacement for mime_magic for better MIME support, the
Internationalization extension, and deprecation of ereg extension.
|
|
5.3.1
|
2009-11-19
|
Over 100 bug fixes, some of which
were security fixes as well.
|
|
5.3.2
|
2010-03-04
|
Includes a large number of bug
fixes.
|
|
5.3.3
|
2010-07-22
|
Mainly bug and security fixes;
FPM SAPI.
|
|
5.3.4
|
2010-12-10
|
Mainly bug and security fixes;
improvements to FPM SAPI.
|
|
php-trunk-dev
|
?.?
|
No date set
|
Removed items:
'register_globals', 'safe_mode', 'allow_call_time_pass_reference', session_register(),
session_unregister() and session_is_registered() functions
New features: traits, array dereferencing,
closure $this support, JsonSerializable interface
|
Usage
PHP is a general-purpose scripting language that is especially suited to
server-side web
development where PHP generally runs on a
web server.
Any PHP code in a requested file is
executed by the PHP runtime, usually to create
dynamic
web page content. It can also be used for
command-line
scripting and
client-side GUI applications. PHP can be deployed on
most
web
servers, many
operating systems and
platforms, and can be used with many
relational database management
systems (RDBMS). It is available free of charge, and the PHP Group provides
the complete source code for users to build, customize and extend for their own
use.
[33]
PHP primarily acts as a
filter,
[34] taking
input from a file or stream containing text and/or PHP instructions and outputs
another stream of data; most commonly the output will be HTML. Since PHP 4, the
PHP
parser compiles input
to produce
bytecode
for processing by the
Zend Engine, giving improved performance over its
interpreter predecessor.
[35]
Originally designed to create dynamic web pages, PHP now focuses mainly on
server-side scripting,
[36] and it is
similar to other server-side scripting languages that provide dynamic content
from a web server to a
client, such as
Microsoft's
Asp.net,
Sun
Microsystems'
JavaServer Pages,
[37] and
mod_perl. PHP
has also attracted the development of many
frameworks that provide building blocks and a
design structure to promote
rapid application development (RAD).
Some of these include
CakePHP,
Symfony,
CodeIgniter, and
Zend
Framework, offering features similar to other
web application frameworks.
The
LAMP architecture has become popular in the
web industry as a way of deploying web applications. PHP is commonly used as
the
P in this bundle alongside
Linux,
Apache and
MySQL, although the
P
may also refer to
Python or
Perl or some
combination of the three.
WAMP packages (
Windows/ Apache/ MySQL / PHP) and
MAMP packages (
Macintosh /
Apache / MySQL / PHP) are also available.
As of April 2007, over 20 million Internet domains had web services hosted
on servers with PHP installed and mod_php was recorded as the most popular
Apache HTTP Server module.
[38] PHP
is used as server-side programming language on 75% of all web servers.
[39]
Significant websites are written in PHP including the user-facing portion of
Facebook,
[40] Wikipedia (
MediaWiki),
[41] Digg,
[42] Joomla,
eZ Publish,
WordPress,
[43] Drupal [44] and
Moodle.
[45]
Security
The
National Vulnerability Database
maintains a list of vulnerabilities found in computer software. The overall
proportion of PHP-related vulnerabilities on the database amounted to: 20% in
2004, 28% in 2005, 43% in 2006, 36% in 2007, 35% in 2008, and 30% in 2009.
[46] Most of
these PHP-related vulnerabilities can be
exploited remotely: they allow
attackers to
steal
or destroy data from data sources linked to the webserver (such as an
SQL database), send
spam
or contribute to
DoS attacks using
malware, which
itself can be installed on the vulnerable servers.
These vulnerabilities are caused mostly by not following best practice
programming rules: technical security flaws of the language itself or of its
core libraries are not frequent (23 in 2008, about 1% of the total).
[47][48] Recognizing
that programmers cannot be trusted, some languages include
taint
checking to detect automatically the lack of
input
validation which induces many issues. Such a feature is being developed for
PHP,
[49]
but its inclusion in a release has been rejected several times in the past.
[50][51]
Hosting PHP applications on a server requires a careful and constant
attention to deal with these security risks.
[52] There are
advanced protection patches such as
Suhosin and
Hardening-Patch, especially designed for web
hosting environments.
[53]
Syntax
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>PHP Test</title>
</head>
<body>
<?php
echo 'Hello World';
/* echo("Hello World"); works as well, although echo isn't a
function, but a language construct. In some cases, such
as when multiple parameters are passed to echo, parameters
cannot be enclosed in parentheses. */
?>
</body>
</html>
PHP code embedded within HTML code
PHP only parses code within its
delimiters.
Anything outside its delimiters is sent directly to the output and is not
processed by PHP (although non-PHP text is still subject to
control structures described within PHP code).
The most common delimiters are
<?php
to open and
?> to close
PHP sections.
<script
language="php"> and
</script> delimiters are also available, as are the
shortened forms
<? or
<?= (which is used to echo back a
string or
variable) and
?> as well as
ASP-style short forms
<% or
<%= and
%>.
While short delimiters are used, they make script files less portable as
support for them can be disabled in the
PHP configuration, and so they are
discouraged.
[54]
The purpose of all these delimiters is to separate PHP code from non-PHP code,
including HTML.
[55]
The first form of delimiters,
<?php
and
?>, in
XHTML and other
XML documents, creates
correctly formed XML 'processing instructions'.
[56] This means
that the resulting mixture of PHP code and other markup in the server-side file
is itself well-formed XML.
Variables are prefixed with a
dollar
symbol and a
type does not need to be specified in advance.
Unlike function and class names, variable names are case sensitive. Both
double-quoted (
"")
and
heredoc strings
allow the ability to embed a variable's value into the string.
[57] PHP treats
newlines as
whitespace in the manner of a
free-form language (except when inside string
quotes), and statements are terminated by a semicolon.
[58] PHP has
three types of
comment syntax:
/* */ marks block and inline comments;
// as well as
# are used for one-line comments.
[59] The
echo statement is one of several
facilities PHP provides to output text (e.g. to a web browser).
In terms of keywords and language syntax, PHP is similar to most high level
languages that follow the C style syntax.
if
conditions,
for and
while loops, and function returns
are similar in syntax to languages such as C, C++, Java and Perl.
Data types
PHP stores whole numbers in a platform-dependent range, either a 64-bit or
32-bit
signed integer equivalent to the
C-language long type. Unsigned
integers are converted to signed values in certain situations; this behavior is
different from other programming languages.
[60] Integer
variables can be assigned using decimal (positive and negative),
octal, and
hexadecimal
notations.
Floating point numbers are also stored in a
platform-specific range. They can be specified using
floating
point notation, or two forms of
scientific notation.
[61] PHP
has a native
Boolean type that is similar to the native Boolean
types in
Java and
C++. Using the
Boolean type conversion rules, non-zero values are interpreted as true and zero
as false, as in
Perl
and
C++.
[61] The
null data type represents a variable that has no value. The only value in the
null data type is
NULL.
[61]
Variables of the "resource" type represent references to resources
from external sources. These are typically created by functions from a
particular extension, and can only be processed by functions from the same
extension; examples include file, image, and database resources.
[61]
Arrays can contain elements of any type that PHP can handle, including
resources, objects, and even other arrays. Order is preserved in lists of
values and in
hashes with both keys and values, and the two can be
intermingled.
[61]
PHP also supports
strings, which can be used with single quotes,
double quotes, or
heredoc
syntax.
[62]
The Standard PHP Library (SPL) attempts to solve standard problems and
implements efficient data access interfaces and classes.
[63]
Functions
PHP has hundreds of base functions and thousands more via extensions. These
functions are well documented on the PHP site; however, the built-in library
has a wide variety of naming conventions and inconsistencies
[64]. PHP
currently has no functions for
thread programming, although it does
support multiprocess programming on
POSIX systems.
[65]
You can create your own functions, like this:
function myFunction() {
return 'Tyler';
}
echo 'My name is ' . myFunction() . '!';
PHP 5.2 and earlier
Functions are not
first-class functions and can only be
referenced by their name, directly or dynamically by a variable containing the
name of the function.
[66]
User-defined functions can be created at any time without being
prototyped.
[66]
Functions can be defined inside code blocks, permitting a
run-time
decision as to whether or not a function should be defined. Function calls
must use parentheses, with the exception of zero argument class
constructor functions called with
the PHP
new operator, where
parentheses are optional. PHP supports quasi-
anonymous functions through the
create_function() function, although
they are not true anonymous functions because anonymous functions are nameless,
but functions can only be referenced by name, or indirectly through a variable
$function_name();, in PHP.
[66]
PHP 5.3 and newer
PHP gained support for
closures. True
anonymous functions are supported using the
following syntax:
function getAdder($x) {
return function ($y) use ($x) {
return $x + $y;
};
}
$adder = getAdder(8);
echo $adder(2); // prints "10"
Here, the
getAdder()
function creates a closure using the parameter
$x (the keyword
use
imports a variable from the lexical context), which takes an additional
argument
$y and returns it
to the caller. Such a function is a first class object, that means, it can be
stored, passed as a parameter to other functions, etc. For more details see
Lambda functions and closures RFC.
The
goto flow
control statement is used as follows:
function lock() {
$file = fopen('file.txt', 'r+');
retry:
if (!flock($file, LOCK_EX)) {
goto retry;
}
fwrite($file, 'Success!');
fclose($file);
return 0;
}
When
lock() is called,
PHP opens a file and tries to lock it. retry:, the target label, defines the
point to which execution should return if
flock()
is unsuccessful and
goto retry;
is called.
goto is
restricted and requires that the target label be in the same file and context.
goto is supported since PHP
5.3.
Objects
Basic
object-oriented programming
functionality was added in PHP 3 and improved in PHP 4.
[3]
Object handling was completely rewritten for PHP 5, expanding the feature set
and enhancing performance.
[67]
In previous versions of PHP, objects were handled like
value types.
[67]
The drawback of this method was that the whole object was copied when a
variable was assigned or passed as a parameter to a method. In the new
approach, objects are referenced by
handle, and not by value. PHP 5 introduced
private and protected
member variables and methods, along with
abstract
classes and
final classes as well as
abstract
methods and
final methods. It also introduced a standard way of
declaring
constructors and
destructors, similar to that of other
object-oriented languages such as
C++, and a standard
exception handling model. Furthermore, PHP 5
added
interfaces and allowed for multiple
interfaces to be implemented. There are special interfaces that allow objects
to interact with the runtime system.
Objects implementing ArrayAccess can be
used with
array syntax and
objects implementing
Iterator or
IteratorAggregate
can be used with the
foreach
language construct. There is no
virtual
table feature in the engine, so
static
variables are bound with a name instead of a reference at compile time.
[68]
Basic example of
object-oriented programming as
described above:
class Person {
public $first;
public $last;
public function __construct($f, $l = '') { //Optional parameter
$this->first = $f;
$this->last = $l;
}
public function greeting() {
return "Hello, my name is " . $this->first . " " . $this->last . ".";
}
static public function staticGreeting($first, $last) {
return "Hello, my name is " . $first . " " . $last . ".";
}
}
$him = new Person('John', 'Smith');
$her = new Person('Sally', 'Davis');
$other= new Person('Joe');
echo $him->greeting(); // prints "Hello, my name is John Smith."
echo '<br />';
echo $her->greeting(); // prints "Hello, my name is Sally Davis."
echo '<br />';
echo $other->greeting(); // prints "Hello, my name is Joe ."
echo '<br />';
echo Person::staticGreeting('Jane', 'Doe'); // prints "Hello, my name is Jane Doe."
Visibility of properties and methods
The visibility of PHP properties and methods refers to
visibility in PHP. It is defined
using the
keywords "public,"
"private," and "protected." The default is public, if only
var is used; "var"
is a synonym for "public." "Public" declared items can be
accessed everywhere. "Protected" limits access to
inherited
classes (and to the class that defines the item). "Private"
limits visibility only to the class that defines the item.
[70] Objects of
the same type have access to each other's private and protected members even
though they are not the same instance. PHP's member visibility features have
sometimes been described as "highly useful."
[71] However,
they have also sometimes been described as "at best irrelevant and at
worst positively harmful."
[72]
Speed optimization
PHP
source
code is
compiled
on-the-fly to an internal format that can be executed by the PHP engine.
[73][74] In order to
speed up execution time and not have to compile the PHP source code every time
the webpage is accessed, PHP scripts can also be deployed in executable format
using a
PHP
compiler.
Code optimizers aim to enhance the performance of the compiled code by
reducing its size, merging redundant instructs and making other changes that
can reduce the execution time. With PHP, there are often opportunities for
code optimization,
[75]. An example
of a code optimizer is the
eAccelerator PHP extension.
[76]
Another approach for reducing compilation overhead for PHP servers is using
an
opcode cache. Opcode caches work by
caching the
compiled form of a PHP script (
opcodes) in
shared
memory to avoid the overhead of
parsing and
compiling the
code every time the script runs. An opcode cache,
APC, will be built into an upcoming release
of PHP.
[77]
Opcode caching and code optimization can be combined for best efficiency, as
the modifications do not depend on each other (they happen in distinct stages
of the compilation).
Compilers
The PHP language was originally implemented using a PHP interpreter. Several
compilers now exist, which decouple the PHP language from the interpreter:
- phc - a C++ based compiler for PHP,
using the Zend run-time for maximum compatibility
- Roadsend - achieves native
compilation by compiling to bigloo scheme, which in turn is compiled to C,
then to machine code
- Raven - a rewrite of Roadsend
PHP (rphp), based on LLVM and a new C++ runtime
- Phalanger - compiles source code written
in the PHP scripting language into CIL byte-code
- Caucho Resin/Quercus - compiles PHP to
Java bytecode
- HipHop
- developed at Facebook and now available as open source, transforms the
PHP Script into C++, then compiles it.
- php-to-scala
- converts PHP to human-readable Scala source code, which the developer
can compile to Java bytecode
Advantages of compilation include not only better execution speed, but also
obfuscation, static analysis, and improved interoperability with code written
in other languages.
[78]
11Resources
PHP includes
free and open source libraries with the core
build. PHP is a fundamentally
Internet-aware system with modules built in for accessing
FTP servers, many database servers, embedded
SQL libraries such as embedded
PostgreSQL,
MySQL and
SQLite,
LDAP servers, and others.
Many functions familiar to C programmers such as those in the
stdio family are
available in the standard PHP build.
[79]
PHP allows developers to write
extensions in
C to add functionality to the PHP
language. These can then be compiled into PHP or loaded dynamically at runtime.
Extensions have been written to add support for the
Windows API,
process management on
Unix-like operating
systems, multibyte strings (
Unicode),
cURL, and several popular
compression
formats. Some more unusual features include integration with
Internet Relay Chat, dynamic generation of
images and
Adobe Flash content, and even
speech
synthesis. The
PHP Extension Community Library
(PECL) project is a repository for extensions to the PHP language.
[80]
Zend provides a
certification exam for programmers to
become certified PHP developers.
What is MySQL?
MySQL is a database.
The data in MySQL is stored in database objects called tables.
A table is a collections of related data entries and it consists of columns
and rows.
Databases are useful when storing information categorically. A company may
have a database with the following tables: "Employees",
"Products", "Customers" and "Orders".
Database Tables
A database most often contains one or more tables. Each table is identified
by a name (e.g. "Customers" or "Orders"). Tables contain
records (rows) with data.
Below is an example of a table called "Persons":
|
LastName
|
FirstName
|
Address
|
City
|
|
Hansen
|
Ola
|
Timoteivn 10
|
Sandnes
|
|
Svendson
|
Tove
|
Borgvn 23
|
Sandnes
|
|
Pettersen
|
Kari
|
Storgt 20
|
Stavanger
|
The table above contains three records (one for each person) and four
columns (LastName, FirstName, Address, and City).
Queries
A query is a question or a request.
With MySQL, we can query a database for specific information and have a
recordset returned.
Look at the following query:
|
SELECT LastName FROM Persons
|
The query above selects all the data in the "LastName" column from
the "Persons" table, and will return a recordset like this:
|
LastName
|
|
Hansen
|
|
Svendson
|
|
Pettersen
|
Create a Connection to a MySQL Database
Before you can access data in a database, you must create a connection to
the database.
In PHP, this is done with the mysql_connect() function.
Syntax
|
mysql_connect(servername,username,password);
|
|
Parameter
|
Description
|
|
servername
|
Optional. Specifies the server to connect to. Default value
is "localhost:3306"
|
|
username
|
Optional. Specifies the username to log in with. Default
value is the name of the user that owns the server process
|
|
password
|
Optional. Specifies the password to log in with. Default
is ""
|
Closing a Connection
The connection will be closed automatically when the script ends. To close
the connection before, use the mysql_close() function:
|
<?php
$con = mysql_connect("localhost","root","");
if (!$con)
{
die('Could not connect: ' . mysql_error());
}
// some code
mysql_close($con);
?>
|
Create a Database
The CREATE DATABASE statement is used to create a database in MySQL.
Syntax
|
CREATE DATABASE database_name
|
Create a Table
The CREATE TABLE statement is used to create a table in MySQL.
Syntax
|
CREATE TABLE table_name
(
column_name1 data_type,
column_name2 data_type,
column_name3 data_type,
....
)
|
Insert Data Into a Database Table
The INSERT INTO statement is used to add new records to a database table.
Syntax
It is possible to write the INSERT INTO statement in two forms.
The first form doesn't specify the column names where the data will be
inserted, only their values:
|
INSERT INTO table_name
VALUES (value1, value2, value3,...)
|
The second form specifies both the column names and the values to be
inserted:
|
INSERT INTO table_name (column1, column2, column3,...)
VALUES (value1, value2, value3,...)
|
Insert Data From a Form Into a Database
Now we will create an HTML form that can be used to add new records to the
"Persons" table.
Here is the HTML form:
|
<html>
<body>
<form action="insert.php" method="post">
Firstname: <input type="text" name="firstname" />
Lastname: <input type="text" name="lastname" />
Age: <input type="text" name="age" />
<input type="submit" />
</form>
</body>
</html>
|
When a user clicks the submit button in the HTML form in the example above,
the form data is sent to "insert.php".
The "insert.php" file connects to a database, and retrieves the
values from the form with the PHP $_POST variables.
Then, the mysql_query() function executes the INSERT INTO statement, and a
new record will be added to the "Persons" table.
Here is the "insert.php" page:
|
<?php
$con = mysql_connect("localhost","root","");
if (!$con)
{
die('Could not connect: ' . mysql_error());
}
mysql_select_db("my_db", $con);
$sql="INSERT INTO Persons (FirstName, LastName, Age)
VALUES
('$_POST[firstname]','$_POST[lastname]','$_POST[age]')";
if (!mysql_query($sql,$con))
{
die('Error: ' . mysql_error());
}
echo "1 record added";
mysql_close($con)
|
?>
Select Data From a Database Table
The SELECT statement is used to select data from a database.
Syntax
|
SELECT column_name(s)
FROM table_name
|
Example
The following example selects all the data stored in the "Persons"
table (The * character selects all the data in the table):
|
<?php
$con = mysql_connect("localhost","root","");
if (!$con)
{
die('Could not connect: ' . mysql_error());
}
mysql_select_db("my_db", $con);
$result = mysql_query("SELECT * FROM Persons");
while($row = mysql_fetch_array($result))
{
echo $row['FirstName'] . " " . $row['LastName'];
echo "<br />";
}
mysql_close($con);
?>
|
The output of the code above will be:
|
Peter Griffin
Glenn Quagmire
|
Display the Result in an HTML Table
The following example selects the same data as the example above, but will
display the data in an HTML table:
<?php
$con =
mysql_connect("localhost","peter","abc123");
if (!$con)
{
die('Could not connect: ' . mysql_error());
}
mysql_select_db("my_db", $con);
$result = mysql_query("SELECT * FROM Persons");
echo "<table border='1'>
<tr>
<th>Firstname</th>
<th>Lastname</th>
</tr>";
while($row = mysql_fetch_array($result))
{
echo "<tr>";
echo "<td>" . $row['FirstName'] .
"</td>";
echo "<td>" . $row['LastName'] .
"</td>";
echo "</tr>";
}
echo "</table>";
mysql_close($con);
?> |
The output of the code above will be:
|
Firstname
|
Lastname
|
|
Glenn
|
Quagmire
|
|
Peter
|
Griffin
|
Update Data In a Database
The UPDATE statement is used to update existing records in a table.
Syntax
|
UPDATE table_name
SET column1=value, column2=value2,...
WHERE some_column=some_value
|
Delete Data In a Database
The DELETE FROM statement is used to delete records from a database table.
Syntax
|
DELETE FROM table_name
WHERE some_column = some_value
|
HARDWARE & SOFTWARE REQUIREMENTS
MINIMUM REQUIREMENTS :
TO RUN THIS PROJECT
, THE MINIMUM HARDWARE CONFIGURATION IS :
·
PENTIUM –I (133 Mhz)
·
32 MB RAM
·
2 G.B HDD
·
1.44 MB FLOPPY DISK DRIVE
·
VGA/SVGA COLOR MONITOR
·
101 KEY STATNDARD KEYBOARD
·
SERIAL / PS2 MOUSE
·
DOT MATRIX. / INKJET PRINTER
FOR BEST PERFORMANCE :
·
PENTIUM –III (733 Mhz)
·
128 MB RAM
·
10 GB HDD
·
1.44 FLOPPY DISK DRIVE
·
15 “ SVGA COLOR MONITOR
·
121 MULTIMEDIA STANDARD KEYBOARD
·
SCROLL MOUSE
·
INKJET /LASER PRINTER
SOFTWARE
REQUIREMENT
·
WINDOWS XP
·
VB.Net
-6.0
·
MS-ACCES
PART-III
(About project)
SYSTEM DEVELOPMENT LIFE CYCLE
The system
development life cycle is a sequence of events carried out by analysts,
designers and users to develop and implement an information system. These
activities are carried out in different stages.
SYSTEM DEVELOPMENT STAGES
System design is the most
creative phase of the system development. The term design describes a final
system and the process by which it is developed. It includes the construction
of programs and program testing. The key question of system design is : How
should problem be solved ?
A Systematic method has to achieve the
beneficial results at the end. It involves starting with a vagus idea and
developing it into series of steps. The series of steps for successful system
development or successful system design are explained below. First step is to
study problem completely because first of all we should know the goal, which we
want to achieve from the system. It is very challenging step of the system
development. According to the input requirement of the system the structure of
various have to achieve. Second step we should see what kind of output we
require and what kind of input we give to it so that we can get desired output
individual programs, which later on joining solve problem. Then we test these
programs and make necessary correction in them to achieve target of the
programs. At last combining all these problems in the form of databases should
be designed. Next we should what kind of program should be developed to reach
final goal.
In
other words, various steps involved in system design are:--
- Requirements analysis
- Feasibility study
- Software requirement
specification
- Design
- Coding
- Testing
- Implementation
- Maintenance
- Post Implementation
REQUIREMENT ANALYSIS :-
Requirement
analysis is done
in order to properly
understand the problem
which is solved
by the software
system which is to be
developed. Here, software
development is a puzzle, which is
to be
solved to create
a new system. When we start we
should know clearly and exactly
about the problem. For example,the problem could be automating an existing manual
process,
