| HOME |
| ANALYSIS |
| BUSINESSES |
| DATABASE |
| DESKTOP |
| FILESERVER |
| FIREWALL |
| INTRANET |
| PHILOSOPHY |
| SECURITY |
| TECHNICAL |
| TRAINING |
A database is similar to a file server in many ways; it forms a storage system for business data. However, file server storage tends to be unstructured and ad-hoc -- anyone can create a directory, files get named invarious ways, etc. In contrast, a database is usually much more structured with particular fields, records and tables being defined. Because of this rigid structure, searching a database can be done more systematically than searching a file server.
The structural declarations that define exactly how your data will be stored are called a schema. The details of the schema need to be different for different business applications but some aspects of the schema are very consistent (such as name and address contact details). The process of searching through a database is called a query.
Client / Server means that the system is split into two chunks:
the client
is also known as the front-end
and does the job of
providing an interface for the user (or operator) to work at. At the same
time the server
works as a back end to do the real grunt work.
This design is preferred for most large operations because a single server
can support large numbers of clients. For very complex systems there
might be multiple layers of clients and servers, for example in a J2EE
system the SQL database engine is a server to the Java client which in
turn is a server to the web browser client. This is also known as
a Tiered Architecture
.
Stand-Alone is the opposite to a Client / Server
system
in that the database, application and interface are all bundled into
a single monolithic chunk of code. This is good for small systems because
it is neat and self-contained. Usually this sort of system is easier to
get up and running than the more complex client/server architecture.
hierarchical database is a database that logically has the
shape of a tree. For example, the files, directories, folders, documents, etc.
on a computer's hard drive are logically organised as a tree. For example,
suppose you have a directory (or folder) called Clients
and inside
that you have directories for each last name, and inside each of those directories
you have a document named after the first name of the client. This is really
fast to use if you know the name of the client you are looking for (which
you usually do). However, if you want to find a list of all clients in
Sydney then having it organised by Last Name / First Name doesn't help.
relational database is a database where all data is stored as
tables
and then relationships between the tables are codified so that
complex data structured can be decomposed into a normal form
.
The detailed theory of the Relational Model
is quite complex and more difficult to grasp than the
Hierarchical Model
but the relational database has become popular due to its flexibility.
Flat ASCII File is the most simple and easy to use database format. A flat ASCII file can be viewed and edited in a normal text editor or word processor so it does not require special database software to work with. Each line in the file is usually one single record. It is equivalent to just one single table in a relational database with no index and no relations. Despite the limitations, it remains a popular for small applications because it is so easy to work with and so portable.
eXtensible Markup Language (XML) is another ASCII based format that can be viewed and edited in a normal text editor. It includes special markup tags that provide a simple ASCII file with features similar to a hierarchical database. Since XML is still a recent development people are busy arguing about what it is good for. The most likely application for XML will be as a medium of exchange between systems so that data records or requests can be encoded into XML and transmitted from one system to another.
The "engine" is the low level part of the database that does the fetch and carry and knows how to search for what you ask. Most of the popular database engines use what is called a relational database model and talk a language called Structured Query Language or just SQL for short.
There are many different software packages than can provide an SQL server. Proprietary products such as Oracle and DB2 are now available to run on Linux and these packages have been around for a long time. Other free-software packages such as PostgreSQL and MySQL are newer but compete favorably in performance and you don't have to pay license fees to use them.
Although SQL is a standard (and even has ANSI and ISO support), there are significant variations in the details between various databases. Thus, if you start development on Oracle and then decide to move to PostgreSQL, usually there will be some adjustments required. However, some standard is better than none at all and an application that is written with portability in mind can usually be made to work with more than one brand of database engine.
A "front end" is whatever interface sits immediately in front of the user. One simple front end is a plain text console, this is the oldest front end and has remained popular because it is efficient, clean, fast and excellent for running across a network. This is great for working with text, but it doesn't look pretty, will not work with images and graphics and does not support proportional fonts.
Another newer front end is a web browser, this also works well across a network and has good support for fonts, images, graphical layout, etc. Because of the popularity of web pages on the Internet, and because web browsers are widely available using a web browser as a front end has started to dominate the market.
Another, more flexible option is a Java front end which can either run inside a web server as an applet or run as a stand-alone java application. Java is a convenient language for rapid development and easy deployment and provides the ability to do things that would be impossible for a web browser. One example is the St George Bank internet banking system which uses a Java front end allowing customised encryption that would not be possible in a mere web browser.
A front end can be constructed with one of the application builder packages such as glade (from the gnome project) or designer (from the QT project). These are rapid development tools that let you build the GUI screens of your application by placing the objects where you want them. Once the screens are built, the tool will generate skeleton code and the SQL queries can be added to that skeleton in order to make the front end talk to the back end.
Third party front end packages are available. For example, Microsoft Access (which comes with a database engine of its own, albeit an engine that is horribly slow when dealing with more than a few thousand data records) makes a workable front end for various SQL database engines. The ODBC interface standard is essentially an SQL based standard and most database engines (including free-software engines) have ODBC drivers available. This means you can us a high-powered linux server running PostgreSQL on one machine and run a Microsoft desktop machine running the MS-Access front end. For people who already use MS-Access but have found their needs have grown too big for the internal engine that is part of Access, this option can help improve speed and reliability without substantially changing their application.
The name "middleware" merely means whatever is not part of the database engine and not part of the front end. It is the stuff that sits in the middle of front and back. The word "middleware" became a buzzword around the turn of the century because usually business logic gets codified in the middleware. It seemed that this was where the action is at. Common middleware languages are perl, PHP, Java, ruby and python. Microsoft Access uses it's own internal BASIC as middleware. Some database engines allow scripted middleware to be inserted into the engine itself while in other cases CGI scripts may be running and the script will connect to the database.
The acronym LAMP is often
used as a shorthand for Linux, Apache, MySQL and Perl
. Linux
is the basic operating system, Apache is the web server, MySQL is the
database engine and perl is the middleware language. This is
describing the server back end of a database oriented application
with the presumption that a web browser is being used as the front end.
Various other similar permutations are also proffered (see link above).
Of course, many businesses don't want to start developing their own system from scratch... and in many cases there is no need because someone already has an application that is close enough to a good fit for your business. The application consists of a schema, some middleware and can probably work with a choice of back ends. Many applications use a web browser as a front end but some may have other types of front end.
The good thing about a pre-written application is you are up and going quickly and it usually costs less than writing it yourself. The bad thing is that you get a lot of junk that was good for someone else but doesn't suit your business. You probably end up needing some modifications to the application and might find yourself only using 20% of the features because that is all you need. Moreover, the extra features can be undesirable from a security point of view and you will quite likely need to go to some trouble to remove features in order to focus it down to your real business needs.
The other good thing about pre-written applications is that there are many to choose from and you can shop around a bit before committing yourself. With open-source applications you can download the code and set it up as a test in order to evaluate it and see what you think.
bloggingsystem to let you run your own web log, it supports a bunch of other content management facilities too.
tickets.