Object Oriented Programming Tutorial part 4

Inheritance

Another big word for a simple concept. To help explain inheritance, we'll go back to our beer example. Say we want to define a new class to represent a pint of an imported French beer. This class would have all the variables and methods of the normal beer class, but it would have the following additional information:

• A variable representing the price of the beer
• Two methods to set and get the price of the beer

(We need this information because we are students; everyone knows the price of Harp, but we would like to know the price of this expensive beer before we order it!)

It would be rather tedious to define a new class, FrenchBeerType which had all the variables and methods of BeerType plus the few extra we needed. Instead, we can define FrenchBeerType to be a subclass of BeerType.

A subclass is a class definition which derives functionality from another class definition.

What this means is that we only need to define the additional information that the FrenchBeerType class has.

So, we create a new class, FrenchBeerType, and tell our compiler that it is a subclass of BeerType. In the class definition, we would include only the following information:

• A variable BeerPrice
• A method SetBeerPrice
• A method GetBeerPrice

We do not need to include any information about BeerName for example; all this is automatically inherited. This means that FrenchBeerType has all the attributes of BeerType plus a few additional ones. All this talk of beer...

Counters, Counters, Counters...

Back to the counter example then! The counter we had in the last section is fine for most counting purposes. But say in a program we require a counter that can not only be incremented, but can be decremented too. Since this new counter is so similar in behaviour to our previous counter, once again would be mad to define a brand new class with everything that Counter has plus a new method. Instead, we'll define a new class ReverseCounter that is a subclass of Counter. We'll do this in Java.

class ReverseCounter extends Counter
{
    public void DecrementCounter(void)  {
        MyCounter--;
    }
}

The extends clause indicates the superclass of a class definition. A superclass is the "parent" of a subclass; in our beer analogy, BeerType is the superclass of FrenchBeerType, so if we were defining this in Java we would use class FrenchBeerType extends BeerType. We are simply saying that we want ReverseCounter to be a subclass of Counter. In Java, when we define a brand new class that is not a subclass of anything (as we did when we defined Counter) we use the superclass Object to indicate we want the default superclass.

We have defined ReverseCounter to be a subclass of Counter. This means that if we instantiate a ReverseCounter object, we can use any method that the class Counter provided, as well as the new methods provided. For example, if i is an object of the ReverseCounter class, then we can both increment it and decrement it; i.IncrementCounter(); and i.DecrementCounter; respectively.

Inheritance is a powerful tool. Unlike our simple example, inheritance can be passed on from generation to generation; we could define a class SuperDuperReverseCounter for example, that is a subclass of ReverseCounter which could provide added variables or methods.

Bugs, bugs, bugs...

If you tried to compile the above example and found it wasn't compiling, don't worry! There is a semi-deliberate mistake left in the code, which I am very usefully going to use to stress a point.

When defining a class you must consider subclasses.

When we defined the Counter class we didn't even know what a subclass was, so we could be forgiven for breaking this rule. If we go back to how the class was defined:

class Counter extends Object  {
    private int MyCounter;

    ...
    ...
}

We can see that the variable MyCounter is defined to be of type private. In Java, this means that the variable becomes very, very private indeed; in fact, it is only accessible from inside the class from which it is defined. It is not available to any other class, including its derived classes. So when we reference MyCounterReverseCounter the Java compiler will kick up a fuss, since we don't have access to that variable. from inside the

We should have realised at the time of writing the Counter class that subclasses might need to get at this variable too. To fix this, all we have to do is change the definition of MyCounter to:

    protected int MyCounter;

A variable with a protected qualifier means that it can be accessed from within the class in which it is defined, as well as all subclasses of this class. This is appropriate in this case.

sumber:http://www.aonaware.com/OOP5.htm

Object Oriented Programming Tutorial part 3

Classes

Say we wanted to extend the counter example discussed previously. Perhaps in our Modula-2 program we need three counters. We could define an array of MyCounter and work through that. Or say we needed up to 1000 counters. Then we could also declare an array, but that would waste a lot of memory if we only used a few counters. Perhaps if we needed an infinite amount of counters we could put them in a linked list and allocate memory as required.

The point of all this is that we are talking in terms of data structures; all of the above discussion has nothing to do with the behaviour of the counter itself. When programming with objects we can ignore anything not directly concerning the behaviour or state of an object; we instead turn our attention to classes.

A class is a blueprint for an object.

What this basically means is that we provide a blueprint, or an outline of an object. This blueprint is valid whether we have one or one thousand such objects. A class does not represent an object; it represents all the information a typical object should have as well as all the methods it should have. A class can be considered to be an extremely extended TYPE declaration, since not only are variables held but methods too.

C++

As an example, lets give the C++ class definition for our counter object.

class Counter  {

    private:
        int MyCounter

    public:
        Counter()  {
            MyCounter = 0;
        }

        void InitialiseCounter(int value)  {
            MyCounter = value;
        }

        void IncrementCounter()  {
            MyCounter++;
        }

        int GetCounterValue()  {
            return (MyCounter);
        }
}

A lot to go through for this little example. You really need to understand the fundamentals of C before the example will make any sense.

• In the private section, all the objects variables should be placed. These define the state of the object. As the name suggests, the variables are going to be private, that is they cannot be accessed from outside the class declaration. This is encapsulation.
• The public section contains all the object's methods. These methods, as the name suggests, can be accessed outside the class declaration. The methods are the only means of communication with the object.
• The methods are implemented as C++ functions or procedures; the three methods should be easy to understand.
• All class definitions should also have one public method that has the same name as the class itself, in this case Counter. This method is called the class constructor, and will be explained soon.
• Functions and procedures can also be placed in the private section; these will not be accessible to the outside world but only within the class declaration. This can be used to provide support routines to the public routines.

Instantiation

This is an awful big word for a powerfully simple concept. All we have done so far is to create a class, i.e. a specification for our object; we have not created our object yet. To create an object that simulates a counter in C++ then, all we have to do is declare in our main program:

Counter i;

Although this seems just like an ordinary variable declaration, this is much more. The variable i now represents an instance of the counter type; a counter object. We can now communicate with this object by calling its methods, for example we can set the counter to the value '50' by calling i.InitialiseCounter(50);. We can increment the counter - i.IncrementCounter(); - and we can get the counter value - int value = i.GetCounterValue();.

When we first instantiate an object (i.e. when we first declare, or create it), the class constructor is called. The class constructor is the method with the same name as the class definition. This method should contain any start-up code for the object; any initialisation of object variables should appear within this method. In the counter example, whenever we create a new counter object, the first thing that happens to the object is that the variable MyCounter is initialised to zero.

Remember the question posed at the very start? The power of objects starts to kick in now. Say we require another counter within our program. All we have to do is declare a new object, say:

Counter j;

Although the new counter shares the same blueprint as the previous object, it shares none of the same data. What this means is that i and j are two distinct objects, each with their own separate values. We can increment them independently, for example. Should we need 1000 counter objects we could declare an array of counter objects:

Counter loads[1000];

and then initialize one of them using a call such as loads[321].InitialiseCounter();.

Java

The equivalent Java class definition for the counter example follows. It is remarkably similar to the C++ definition, and differs only in syntax.

class Counter extends Object  {

    private int MyCounter;

    Counter()  {
        MyCounter = 0;
    }

    public void InitialiseCounter(int value)  {
        MyCounter = value;
    }

    public void IncrementCounter(void)  {
        MyCounter++;
    }

    public int GetCounterValue(void)  {
        return (MyCounter);
    }
}

A few brief notes about the differences:

• All new classes must be defined with the extension extends Object. This defines the superclass; this will be dealt with in the next section.
• There are no public or private sections, instead all variables and methods are prefixed with the appropriate public or private qualifier.
• The class constructor definition remains the same.

Instantiating objects in Java is slightly different; objects are declared differently:

Counter i;

i = new Counter();

Basically we define a variable to reference the object in the first line. Then we actually create an instance of the object by a call to new in the second line. Accessing object methods is done in the exact same way in Java as in C++.

Why Bother?

The process of designing and programming objects seems very cumbersome, so why bother? Well, it's difficult to see from such a small example, but for larger projects, OOP techniques allow a great deal of flexibility. OOP is used for the following reasons.

• Encapsulation: in our example we cannot alter the value of the counter other than by incrementing it or setting it to a initial value. This drastically helps with understanding of the code and eliminating potential bugs.
• Modularity: Different programmers or teams can work on different independent objects.
• Inheritance: this is covered in the next section.

sumber: http://www.aonaware.com/OOP4.htm

Object Oriented Programming Tutorial part 2

Objects

Objects are the central idea behind OOP. The idea is quite simple.

An object is a bundle of variables and related methods.

A method is similar to a procedure; we'll come back to these later.

The basic idea behind an object is that of simulation. Most programs are written with very little reference to the real world objects the program is designed to work with; in object oriented methodology, a program should be written to simulate the states and activities of real world objects. This means that apart from looking at data structures when modelling an object, we must also look at methods associated with that object, in other words, functions that modify the objects attributes.

A few examples should help explain this concept. First, we turn to any student's favourite pastime...

Drink!

Say we want to write a program about a pint of beer. If we were writing this program in Modula-2, we could write something like this:

TYPE BeerType = RECORD
                    BeerName:       STRING;
                    VolumeInPints:  REAL;
                    Colour:         ColourType;
                    Proof:          REAL;
                    PintsNeededToGetYouDrunk: CARDINAL;
                    ...
                END;

Now lets say we want to initialise a pint of beer, and take a sip from it. In Modula-2, we might code this as:

VAR MyPint: BeerType;

BEGIN
    ...
    (* Initialise (i.e. buy) a pint: *)
    MyPint.BeerName := "Harp";
    MyPint.VolumeInPints := 1.00;
    ...
    ...
    (* Take a sip *)
    MyPint.VolumeInPints := MyPint.VolumeInPints - 0.1;
    ...

We have constructed this entire model based entirely on data types, that is we defined BeerType as a record structure, and gave that structure various names, e.g. Name. This is the norm for procedural programming.

This is however, not how we look at things when we want to program using objects. If you remember how we defined an object at the start of this section, you will remember that we must not only deal with data types, but we must also deal with methods.

A method is an operation which can modify an objects behaviour. In other words, it is something that will change an object by manipulating its variables.

This means that when we take a real world object, in this case a pint of beer, when we want to model it using computational objects, we not only look at the data structure that it consists of, but also all possible operations that we might want to perform on that data. For our example, we should also define the following methods associated with the BeerType object:

• InitialiseBeer - this should allow us to give our beer a name, a volume, etc.
• GetVolume - to see how much beer we have left!
• Take_A_Sip - for lunchtime pints...
• Take_A_Gulp - for quick pints...
• Sink_Pint - for post exam pints...

There are loads more methods we could define - we might want a function GetBeerName to help us order another pint for example. Now, some definitions. An object variable is a single variable from an object's data structure, for example BeerName is one of BeerType's object variables. Now the important bit from this section:

Only an object's methods should modify its variables

There are a few exceptions, but we'll cover them much later. What this means in our example is that unlike the Modula code, we cannot directly modify BeerType's variables - we cannot set BeerName to "Guinness" directly. We must use the object's methods to do this. In practice, what this means is that we must think very carefully when we define methods. Say in the above example we discover when writing the main program that we need to be able to take a drink of arbitrary size; we cannot do this with the above definition, we can only take a sip, a gulp etc. We must go back and define a new method associated with BeerType, say Take_Drink which will take a parameter representing the amount of beer we wish to drink.

Another Example

We'll now deal with a real-life example which will help us understand some more object concepts. We will design an object to emulate a counter.

A counter is a variable in a program that is used to hold a value. If you don't know that then you shouldn't be reading this! To make things very simple, we'll assume that our counter has only three operations associated with it:

• Initialising the counter to a value
• Incrementing the counter by one
• Getting the current value of the counter

So, when we come to implement the above using objects we will define three methods that do the above.

You may be thinking that we could implement this very simply in Modula-2 using definition and implementation modules obtaining the same results as if we used an object oriented language. Well, we nearly can:

DEFINITION MODULE Counter;

PROCEDURE InitialiseCounter(InitialValue: INTEGER);

PROCEDURE IncrementCounter;

PROCEDURE GetCounterValue(): INTEGER;

END Counter.


IMPLEMENTATION MODULE Counter;

VAR MyCounter: INTEGER;

PROCEDURE InitialiseCounter(InitialValue: INTEGER);
BEGIN
    MyCounter := InitialValue;
END InitialiseCounter;

PROCEDURE IncrementCounter;
BEGIN
    INC(MyCounter);
END IncrementCounter;

PROCEDURE GetCounterValue(): INTEGER;
BEGIN
    RETURN MyCounter;
END GetCounterValue;

BEGIN
    MyCounter := 0;
END Counter.

Because Modula-2 is not object oriented, this will only satisfy one of the requirements for an object oriented language - encapsulation. This simply means that we have implemented information hiding, i.e. we cannot directly access MyCounter from any module that imports Counter. But being object oriented means a lot more than just encapsulation, as we'll see...

sumber: http://www.aonaware.com/OOP3.htm

Object Oriented Programming Tutorial

Introduction

This tutorial aims to teach the basics of Object Oriented Programming. It's designed for students who have some knowledge of procedural programming. It is not tailored to any one specific language, although examples in C++ and Java will be given. To compare OOP with procedural languages, examples using Modula-2 will also be used - Modula-2 is from the Pascal family of languages so hopefully should be familiar to most students.

Probably the most important thing I would like you to take away from this tutorial is the idea that programming in an object oriented language is more than just learning new functions, syntax, etc. OOP is more than learning a new language; it requires a new way of thinking. The idea is to not primarily concentrate on the cornerstones of procedural languages - data structures and algorithms - but instead think in terms of objects.

The best way to learn any language is to practice - Learning a new way of programming is no different. There are a number of OOP based languages out there, but for beginners I would recommend starting with either Java or C# (pronounced C-Sharp). You can start playing with these languages straight away - free compilers and development environments are available. The tutorial has some examples in C++, however I don't recommend starting to learn OOP in C++.

Java is a platform-independent language developed by Sun Microsystems. You can pick up the Java SDK and begin developing straight away. If you want to have a complete development environment, you can download the free JBuilder Foundation from Borland

C# is a relatively new language developed by Microsoft. C# is one language that forms part of Microsoft's .NET platform. You can download the .NET SDKVisual Studio - Academic editions are available.

sumber: http://www.aonaware.com/OOP2.htm

Securing your Wireless Network

These days wireless networking products are so ubiquitous and inexpensive that just about anyone can set up a WLAN in a matter of minutes with less than $100 worth of equipment. This widespread use of wireless networks means that there may be dozens of potential network intruders lurking within range of your home or office WLAN.  

What can I do?

Most WLAN hardware has gotten easy enough to set up that many users simply plug it in and start using the network without giving much thought to security. Nevertheless, taking a few extra minutes to configure the security features of your wireless router or access point is time well spent. Here are some of the things you can do to protect your wireless network:

1) Secure your wireless router or access point administration interface Almost all routers and access points have an administrator password that's needed to log into the device and modify any configuration settings. Most devices use a weak default password like "password" or the manufacturer's name, and some don't have a default password at all.  As soon as you set up a new WLAN router or access point, your first step should be to change the default password to something else. You may not use this password very often, so be sure to write it down in a safe place so you can refer to it if needed. Without it, the only way to access the router or access point may be to reset it to factory default settings which will wipe away any configuration changes you've made. 

2) Don't broadcast your SSIDMost WLAN access points and routers automatically (and continually) broadcast the network's name, or SSID (Service Set IDentifier). This makes setting up wireless clients extremely convenient since you can locate a WLAN without having to know what it's called, but it will also make your WLAN visible to any wireless systems within range of it. Turning off SSID broadcast for your network makes it invisible to your neighbors and passers-by (though it will still be detectible by WLAN "sniffers"). 

3)Enable WPA encryption instead of WEP
802.11's WEP (Wired Equivalency Privacy) encryption has well-known weaknesses that make it relatively easy for a determined user with the right equipment to crack the encryption and access the wireless network. A better way to protect your WLAN is with WPA (Wi-Fi Protected Access). WPA provides much better protection and is also easier to use, since your password characters aren't limited to 0-9 and A-F as they are with WEP. WPA support is built into Windows XP (with the latest Service Pack) and virtually all modern wireless hardware and operating systems. A more recent version, WPA2, is found in newer hardware and provides even stronger encryption, but you'll probably need to download an XP patch in order to use it.  

4) Remember that WEP is better than nothing 
If you find that some of your wireless devices only support WEP encryption (this is often the case with non-PC devices like media players, PDAs, and DVRs), avoid the temptation to skip encryption entirely because in spite of it's flaws, using WEP is still far superior to having no encryption at all. If you do use WEP, don't use an encryption key that's easy to guess like a string of the same or consecutive numbers. Also, although it can be a pain, WEP users should change encryption keys often-- preferably every week.   See this page if you need help getting WEP to work.

5) Use MAC filtering for access control Unlike IP addresses, MAC addresses are unique to specific network adapters, so by turning on MAC filtering you can limit network access to only your systems (or those you know about). In order to use MAC filtering you need to find (and enter into the router or AP) the 12-character MAC address of every system that will connect to the network, so it can be inconvenient to set up, especially if you have a lot of wireless clients or if your clients change a lot. MAC addresses can be "spoofed" (imitated) by a knowledgable person, so while it's not a guarantee of security, it does add another hurdle for potential intruders to jump. 

6) Reduce your WLAN transmitter power
You won't find this feature on all wireless routers and access points, but some allow you lower the power of your WLAN transmitter and thus reduce the range of the signal. Although it's usually impossible to fine-tune a signal so precisely that it won't leak outside your home or business, with some trial-and-error you can often limit how far outside your premises the signal reaches, minimizing the opportunity for outsiders to access your WLAN. 

7) Disable remote administration

Most WLAN routers have the ability to be remotely administered via the Internet. Ideally, you should use this feature only if it lets you define a specific IP address or limited range of addresses that will be able to access the router. Otherwise, almost anyone anywhere could potentially find and access your router. As a rule, unless you absolutely need this capability, it's best to keep remote administration turned off. (It's usually turned off by default, but it's always a good idea to check.)

sumber: http://www.practicallynetworked.com/support/wireless_secure.htm

Uploading File tanpa Submit Form (like Gmail Attach file)

 Lagi mengerjakan sebuah project untuk sebuah rental buku di Bandung, dalam form pendaftarannya diminta untuk mengupload foto nya.... nah saya mentok gimana cara menampilkan foto itu tanpa mensubmit form pendaftarannya dulu.... sudah tanya kesana kemari dan akhirnya ketemu di web nya mr Sajith M.R. berikut saya copy pastekan isinya.... beserta link nya, jika ada yang ingin melihat langsung.

Now we can see ajax everywhere. Most of the famous websites are now enabled ajax for providing faster navigation and browsing speed.
If you are a gmail user, the thing you noticed very attractively should be the file attaching part of the email composing window.
If you wait for sometime you can see, your file gets automatically uploaded without submitting the whole form. This is not Ajax. Because XMLHttpRequest (XHR) is not supporting multipart/form-data.
You can use iframe for this purpose by pointing the target of form submission towards the iframe (you can place it as hidden style=”display:none”)

You can write javascript at the upload.php end, you can change the file uploaded updations just like ajax

ini kode pemrogramannya:

index.php

<?php /**

Program by: Sajith.M.R
contact me: admin@sajithmr.com
*/ ?>
<p>File Uploading Like Gmail. You can upload multiple files without submitting the whole page. You can upload file like ajax. This is using iframe for file upload</p>


<form  target="hiddenframe" enctype="multipart/form-data" action="upload.php" method="POST" name="uploadform">
<p>
  <label>To:
  <input name="textfield2" type="text" id="textfield2" size="60" maxlength="60" />
  <br />
  <br />
  Subject: 
  <input name="textfield" type="text" id="textfield" size="60" maxlength="60" />
  <br />
  <br />
  Attach File:
  <input type="file" name="filefieldname" id="fileField"   onchange="document.uploadform.submit()"/>
  </label>
</p>
<p id="uploadedfile" >
  <label></label>
</p>
<p>
  <label>
  <input type="submit" name="button" id="button" value="Submit" />
  </label>
</p>
<iframe name="hiddenframe" style="display:none" >Loading...</iframe>
</form>
<p>&nbsp; </p>

upload.php

<?php /**
Program by: Sajith.M.R
contact me: admin@sajithmr.com
*/ ?>


<?php
$target_path = "upload/";
$target_path = $target_path . basename( $_FILES['filefieldname']['name']);

if(move_uploaded_file($_FILES['filefieldname']['tmp_name'], $target_path)) {
    echo "The file ".  basename( $_FILES['uploadedfile']['name']).
    " has been uploaded";
} else{
    echo "There was an error uploading the file, please try again!";
}?>
<script>
parent.document.getElementById('uploadedfile').innerHTML += '<br><a href="upload/<?php echo $_FILES['filefieldname']['name'] ?>"><?php echo $_FILES['filefieldname']['name'] ?></a>';
</script>

.htaccess Tutorial - Part 3 - Password Protection

.htaccess Tutorial
Part 3 - Password Protection

• Part 1 - Introduction
• Part 2 - .htaccess Commands
• Part 3 - Password Protection

 Introduction

Although there are many uses of the .htaccess file, by far the most popular, and probably most useful, is being able to relaibly password protect directories on websites. Although JavaScript etc. can also be used to do this, only .htaccess has total security (as someone must know the password to get into the directory, there are no 'back doors')

The .htaccess File

Adding password protection to a directory using .htaccess takes two stages. The first part is to add the appropriate lines to your .htaccess file in the directory you would like to protect. Everything below this directory will be password protected:

AuthName "Section Name"
AuthType Basic
AuthUserFile /full/path/to/.htpasswd
Require valid-user

There are a few parts of this which you will need to change for your site. You should replace "Section Name" with the name of the part of the site you are protecting e.g. "Members Area".

The /full/parth/to/.htpasswd should be changed to reflect the full server path to the .htpasswd file (more on this later). If you do not know what the full path to your webspace is, contact your system administrator for details.

The .htpasswd File

Password protecting a directory takes a little more work than any of the other .htaccess functions because you must also create a file to contain the usernames and passwords which are allowed to access the site. These should be placed in a file which (by default) should be called .htpasswd. Like the .htaccess file, this is a file with no name and an 8 letter extension. This can be placed anywhere within you website (as the passwords are encrypted) but it is advisable to store it outside the web root so that it is impossible to access it from the web.

Sitemap | Contact | Link To Us | Advertise Report A Problem

Home : Tutorials : .htaccess : Part 3

.htaccess Tutorial
Part 3 - Password Protection

• Part 1 - Introduction
• Part 2 - .htaccess Commands
• Part 3 - Password Protection

Introduction

Although there are many uses of the .htaccess file, by far the most popular, and probably most useful, is being able to relaibly password protect directories on websites. Although JavaScript etc. can also be used to do this, only .htaccess has total security (as someone must know the password to get into the directory, there are no 'back doors')

The .htaccess File

Adding password protection to a directory using .htaccess takes two stages. The first part is to add the appropriate lines to your .htaccess file in the directory you would like to protect. Everything below this directory will be password protected:

AuthName "Section Name"
AuthType Basic
AuthUserFile /full/path/to/.htpasswd
Require valid-user

There are a few parts of this which you will need to change for your site. You should replace "Section Name" with the name of the part of the site you are protecting e.g. "Members Area".

The /full/parth/to/.htpasswd should be changed to reflect the full server path to the .htpasswd file (more on this later). If you do not know what the full path to your webspace is, contact your system administrator for details.

The .htpasswd File

Password protecting a directory takes a little more work than any of the other .htaccess functions because you must also create a file to contain the usernames and passwords which are allowed to access the site. These should be placed in a file which (by default) should be called .htpasswd. Like the .htaccess file, this is a file with no name and an 8 letter extension. This can be placed anywhere within you website (as the passwords are encrypted) but it is advisable to store it outside the web root so that it is impossible to access it from the web.

Entering Usernames And Passwords

Once you have created your .htpasswd file (you can do this in a standard text editor) you must enter the usernames and passwords to access the site. They should be entered as follows:

username:password

where the password is the encrypted format of the password. To encrypt the password you will either need to use one of the premade scripts available on the web or write your own. There is a good username/password service at the KxS site which will allow you to enter the user name and password and will output it in the correct format.

For multiple users, just add extra lines to your .htpasswd file in the same format as the first. There are even scripts available for free which will manage the .htpasswd file and will allow automatic adding/removing of users etc.

Accessing The Site

When you try to access a site which has been protected by .htaccess your browser will pop up a standard username/password dialog box. If you don't like this, there are certain scripts available which allow you to embed a username/password box in a website to do the authentication. You can also send the username and password (unencrypted) in the URL as follows:

http://username:password@www.website.com/directory/

Summary

.htaccess is one of the most useful files a webmaster can use. There are a wide variety of different uses for it which can save time and increase security on your website.