Difference between compiler and interpreter

A Compiler and Interpreter both carry out the same purpose – convert a high level language (like C, Java) instructions into the binary form which is understandable by computer hardware. They are the software used to execute the high level programs and codes to perform various tasks. Specific compilers/interpreters are designed for different high level languages. However both compiler and interpreter have the same objective but they differ in the way they accomplish their task i.e. convert high level language into machine language. Through this article we will talk about the basic working of both and distinguish the basic difference between compiler and interpreter.

 

Compiler

A compiler is a piece of code that translates the high level language into machine language. When a user writes a code in a high level language such as Java and wants it to execute, a specific compiler which is designed for Java is used before it will be executed. The compiler scans the entire program first and then translates it into machine code which will be executed by the computer processor and the corresponding tasks will be performed.  

Shown in the figure is basic outline of the compilation process, here program written in higher level language is known as source program and the converted one is called object program.

 

Interpreter

Interpreters are not much different than compilers. They also convert the high level language into machine readable binary equivalents. Each time when an interpreter gets a high level language code to be executed, it converts the code into an intermediate code before converting it into the machine code. Each part of the code is interpreted and then execute separately in a sequence and an error is found in a part of the code it will stop the interpretation of the code without translating the next set of the codes.  

Outlining the basic working of the interpreter the above figure shows that first a source code is converted to an intermediate form and then that is executed by the interpreter.

 

The main differences between compiler and interpreter are listed below:

·         The interpreter takes one statement then translates it and executes it and then takes another statement. While the compiler translates the entire program in one go and then executes it.

·         Compiler generates the error report after the translation of the entire page while an interpreter will stop the translation after it gets the first error.

·         Compiler takes a larger amount of time in analyzing and processing the high level language code comparatively interpreter takes lesser time in the same process.

·         Besides the processing and analyzing time the overall execution time of a code is faster for compiler relative to the interpreter.

In the field of computers, the instructions given by the user are normally of high level language, whereas the computer will understand the instructions only in the binary format, the language of a computer is known as machine language. The sole purpose of the compiler and interpreter is to convert the user given high level language into machine level language so as to make the computer understand and executed the users driven instruction set. “If both the interpreter and compiler are used for sole purpose then what is the significance of each, for this reason the current report if aimed at exploring the difference between a compiler and interpreter”. A compiler will translate the high level language input given by the user into the machine language, i.e. in the binary codes, whereas an interpreter also converts the high-level language into machine level language but the interpreter will initially generate an intermediate code and then convert the high level language to machine level language.

The following context doles out brief description on the differences among the compiler and interpreter

Difference between compiler and interpreter:

Even though the compiler and interpreter are used for converting the high level language to machine language, there exist few variations between the compiler in the style and functionalities in converting the languages.

Compiler is a unique program that runs the instructions that are written in a certain programming language and convert them into the machine code that a computer can understand. The interpreter just does the same work as of the compiler, but the major variation is that, it converts the high level language into an intermediate code which is executed by the processor.  Normally a developer compose the instructions set by using any kind of programming language such as C, Java, Pascal, Python etc. The instruction written by the programmer is referred as the source code. The programmer must initiate the compiler or interpreter that is pertained to the language used for writing source code. Interpreter investigates and runs each line of source code in sequence, without considering the whole program at once. Nevertheless, programs shaped by compilers run greatly faster than the same instructions executed by an interpreter.

Basic differences between Compiler and Interpreter:

• Compiler translates the high level instruction into machine language, but the interpreter translates the high level instruction into an intermediate code.
• The compiler executes the entire program at a time, but the interpreter executes each and every line individually.
• Compiler reports the list of errors that are caused during the process of execution, but the interpreter quits translating soon after finding an error, the progression of the other lines of the program will be done after refining the error.
• Autonomous executable file is generated by the compiler while interpreter is compulsory for an interpreter program.

Differences on the basis of Various characteristics:

• In a compiler the analyzing and processing time of the program is more, while an interpreter spends less time for the program analyzing and processing.
• The resulting code of the compiler is in the form of machine code or binary format, in case of interpreter the resulting code is in the form of the intermediate code.
• In case of compiler, the resulting code is executed by the computer hardware, in an interpreter; another program interprets the resulting code.
• The execution of the program is fast in the compiler; in an interpreter the program execution speed is comparatively slow.

Differences on the basis of programming:

• The compiler will verify syntax of program, whereas the interpreter verifies the keywords of a program.
• The compiler will verify the entire program at a time, but the interpreter verifies the program concurrently in the editor.
• The execution of the program in the interpreter is done line by line but the compiler executes the program on the whole.

Drupal links

http://drupal.org/node/171194

Drupal Subject

http://www.anilsagar.com/content/drupal-7-tutorial-part-14-drupal-7-file-system-structure-explained

http://websule.com/tutorials/drupal-basics/drupal-technology-stack

online jobs

<a href="http://www.onlinejobsfree.com/?id=1161537"><img src="http://www.onlinejobsfree.com/mem/images/300-

Differences between PHP4 and PHP5

Differences between PHP4 and PHP5:

Here's a quick overview of what has changed between PH4 and PHP5. PHP5 for the most part is backwards compatible with PHP4, but there are a couple key changes that might break your PHP4 script in a PHP5 environment. If you aren't already, I stronly suggest you start developing for PHP5. Many hosts these days offer a PHP5 environment, or a dual PHP4/PHP5 setup so you should be fine on that end. Using all of these new features is worth even a moderate amount of trouble you might go through finding a new host! Note: Some of the features listed below are only in PHP5.2 and above. Object ModelThe new OOP features in PHP5 is probably the one thing that everyone knows for sure about. Out of all the new features, these are the ones that are talked about most! Passed by ReferenceThis is an important change. In PHP4, everything was passed by value, including objects. This has changed in PHP5 -- all objects are now passed by reference. PHP Code: $joe = new Person();$joe->sex = 'male'; $betty = $joe;$betty->sex = 'female'; echo $joe->sex; // Will be 'female'   The above code fragment was common in PHP4. If you needed to duplicate an object, you simply copied it by assigning it to another variable. But in PHP5 you must use the new clone keyword. Note that this also means you can stop using the reference operator (&). It was common practice to pass your objects around using the & operator to get around the annoying pass-by-value functionality in PHP4. Class Constants and Static Methods/Properties You can now create class constants that act much the same was as define()'ed constants, but are contained within a class definition and accessed with the :: operator. Static methods and properties are also available. When you declare a class member as static, then it makes that member accessible (through the :: operator) without an instance. (Note this means within methods, the $this variable is not available) Visibility Class methods and properties now have visibility. PHP has 3 levels of visibility: Public is the most visible, making methods accessible to everyone and properties readable and writable by everyone. Protected makes members accessible to the class itself and any subclasses as well as any parent classes. Private makes members only available to the class itself. Unified Constructors and DestructorsPHP5 introduces a new unified constructor/destructor names. In PHP4, a constructor was simply a method that had the same name as the class itself. This caused some headaches since if you changed the name of the class, you would have to go through and change every occurrence of that name. In PHP5, all constructors are named __construct(). That is, the word construct prefixed by two underscores. Other then this name change, a constructor works the same way. Also, the newly added __destruct() (destruct prefixed by two underscores) allows you to write code that will be executed when the object is destroyed. Abstract ClassesPHP5 lets you declare a class as abstract. An abstract class cannot itself be instantiated, it is purely used to define a model where other classes extend. You must declare a class abstract if it contains any abstract methods. Any methods marked as abstract must be defined within any classes that extend the class. Note that you can also include full method definitions within an abstract class along with any abstract methods. InterfacesPHP5 introduces interfaces to help you design common APIs. An interface defines the methods a class must implement. Note that all the methods defined in an interface must be public. An interface is not designed as a blueprint for classes, but just a way to standardize a common API. The one big advantage to using interfaces is that a class can implement any number of them. You can still only extend on parent class, but you can implement an unlimited number of interfaces. Magic Methods There are a number of "magic methods" that add an assortment to functionality to your classes. Note that PHP reserves the naming of methods prefixed with a double-underscore. Never name any of your methods with this naming scheme! Some magic methods to take note of are __call, __get, __set and __toString. These are the ones I find most useful. Finality You can now use the final keyword to indicate that a method cannot be overridden by a child. You can also declare an entire class as final which prevents it from having any children at all. The __autoload FunctionUsing a specially named function, __autoload (there's that double-underscore again!), you can automatically load object files when PHP encounters a class that hasn't been defined yet. Instead of large chunks of include's at the top of your scripts, you can define a simple autoload function to include them automatically. PHP Code: function __autoload($class_name) {      require_once "./includes/classes/$class_name.inc.php"; }   Note you can change the autoload function or even add multiple autoload functions usingspl_autoload_register and related functions. Standard PHP LibraryPHP now includes a bunch of functionality to solve common problems in the so-named SPL. There's a lot of cool stuff in there, check it out! For example, we can finally create classes that can be accessed like arrays by implementing the ArrayAccess interface. If we implement the Iterator interface, we can even let our classes work in situations like the foreach construct. Miscellaneous Features Type Hinting PHP5 introduces limited type hinting. This means you can enforce what kind of variables are passed to functions or class methods. The drawback is that (at this time), it will only work for classes or arrays -- so no other scalar types like integers or strings. To add a type hint to a parameter, you specify the name of the class before the $. Beware that when you specify a class name, the type will be satisfied with all of its subclasses as well. PHP Code: function echo_user(User $user) {     echo $user->getUsername(); }   If the passed parameter is not User (or a subclass of User), then PHP will throw a fatal error. ExceptionsPHP finally introduces exceptions! An exception is basically an error. By using an exception however, you gain more control the simple trigger_error notices we were stuck with before. An exception is just an object. When an error occurs, you throw an exception. When an exception is thrown, the rest of the PHP code following will not be executed. When you are about to perform something "risky", surround your code with a try block. If an exception is thrown, then your following catch block is there to intercept the error and handle it accordingly. If there is no catch block, a fatal error occurs. PHP Code: try {     $cache->write(); } catch (AccessDeniedException $e) {     die('Could not write the cache, access denied.'); } catch (Exception $e) {    die('An unknown error occurred: ' . $e->getMessage()); }   E_STRICT Error Level There is a new error level defined as E_STRICT (value 2048). It is not included in E_ALL, if you wish to use this new level you must specify it explicitly. E_STRICT will notify you when you use depreciated code. I suggest you enable this level so you can always stay on top of things. Foreach Construct and By-Reference Value The foreach construct now lets you define the 'value' as a reference instead of a copy. Though I would suggest against using this feature, as it can cause some problems if you aren't careful: PHP Code: foreach($array as $k => &$v) {     // Nice and easy, no working with $array[$k] anymore     $v = htmlentities($v); } // But be careful, this will have an unexpected result because // $v will still be a reference to the last element of the $array arrayforeach($another_array as $k => $v) { }   New Functions PHP5 introduces a slew of new functions. You can get a list of them from the PHP Manual. New Extensions PHP5 also introduces new default extensions. SimpleXML for easy processing of XML data DOM and XSL extensions are available for a much improved XML-consuming experience. A breath of fresh air after using DOMXML for PHP4! PDO for working with databases. An excellent OO interface for interacting with your database. Hash gives you access to a ton of hash functions if you need more then the usual md5 or sha1. Compatibility IssuesThe PHP manual has a list of changes that will affect backwards compatibility. You should definately read through that page, but here is are three issues I have found particularly tiresome: array_merge() will now give you warnings if any of the parameters are not arrays. In PHP4, you could get away with merging non-arrays with arrays (and the items would just be added if they were say, a string). Of course it was bad practice to do this to being with, but it can cause headaches if you don't know about it. As discussed above, objects are now passed by references. If you want to copy a object, make sure to use the clone keyword. get_*() now return names as they were defined. If a class was called MyTestClass, then get_class() will return that -- case sensitive! In PHP4, they were always returned in lowercase. __________________

PHP OOPs concepts

In the earlier tutorials we have witnessed keywords like public, private and protected. These are nothing but access specifiers. So, lets understand what access specifiers are.

Definition of Access Specifiers
Access specifiers specify the level of access that the outside world (i.e. other class objects, external functions and global level code) have on the class methods and class data members. Access specifiers can either be public, private or protected.

Why do we need Access specifiers
Access specifiers are used as a key component of Encapsulation and Data Hiding. By using either of the access specifiers mentioned above i.e. public, private or protected you can hide or show the internals of your class to the outside world.

Explanation of each access specifier

1. Private
2. Protected
3. Public

1. Private
A private access specifier is used to hide the data member or member function to the outside world. This means that only the class that defines such data member and member functions have access them. Look at the example below:

class Customer {
 private $name;
 
 public function setName($name) {
  $this->name = $name;
 }
 
 public function getName() {
  return $this->name;
 }
}
 
$c = new Customer();
$c->setName("Sunil Bhatia");
echo $c->name; //error, $name cannot be accessed from outside the class
               //$name can only be accessed from within the class
 
echo $c->getName(); //this works, as the methods of the class have access
                    //to the private data members or methods

In the above example, echo $c->name will give you an error as $name in class Customer has been declared private and hence only be accessed by its member functions internally. Therefore, the following line echo $c->getName() will display the name.

2. Public
A public access specifier provides the least protection to the internal data members and member functions. A public access specifier allows the outside world to access/modify the data members directly unlike the private access specifier. Look at the example below:

class Customer {
 public $name;
 
 public function setName($name) {
  $this->name = $name;
 }
 
 public function getName() {
  return $this->name;
 }
}
 
$c = new Customer();
$c->setName("Sunil Bhatia");
echo $c->name;  // this will work as it is public.
$c->name = "New Name" ; // this does not give an error.

In the above example, echo $c->name will work as it has been declared as public and hence can be accessed by class member functions and the rest of the script.

3. Protected
A protected access specifier is mainly used with inheritance. A data member or member function declared as protected will be accessed by its class and its base class but not from the outside world (i.e. rest of the script). We can also say that a protected data member is public for the class that declares it and it’s child class; but is private for the rest of the program (outside world). Look at the example below:

 
class Customer {
 protected $name;
 
 public function setName($name) {
  $this->name = $name;
 }
 
 public function getName() {
  return $this->name;
 }
}
 
class DiscountCustomer extends Customer {
 
 private $discount;
 
 public function setData($name, $discount) {
  $this->name = $name; //this is storing $name to the Customer
         //class $name variable. This works
         // as it is a protected variable
 
  $this->discount = $discount;
 }
}
 
$dc = new DiscountCustomer();
$dc->setData("Sunil Bhatia",10);
echo $dc->name; // this does not work as $name is protected and hence
  // only available in Customer and DiscountCustomer class

In the above example, echo $dc->name will not work work $name has been defined as a protected variable and hence it is only available in Customer and DiscountCustomer class.

You will learn more about inheritance later in this tutorial series. You should revisit this tutorial and read more on the protected section again when you understand inheritance better.

Important Note of Access Specifier in PHP5
In PHP5, access specifiers are public by default. This means that if you don’t specify an access specifier for a data member or method then the default ‘public’ is applicable.

Feel free to write comments if you need more examples or if you need to ask a question on PHP5 Class. You can also subscribe to my notification service to be informed as an when a new tutorial article goes online. Subscribe Below

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

1. PHP5 Tutorial – Learn to create a PHP5 Class
2. PHP5 Tutorial – Learn to Create a PHP5 Class Object
3. PHP5 Tutorial – Defining Attributes of a PHP5 Class
4. PHP5 Tutorial – Defining Methods of a PHP5 Class
5. PHP5 Tutorial – Creating a PHP5 Constructor __construct()
6. PHP5 Tutorial OOPS – Creating a PHP5 Destructor __destruct()
7. PHP5 Tutorial OOPS – PHP5 Class Access Specifiers – public, private and protected
8. PHP5 Tutorial – Magic Methods – __toString() method
9. PHP5 Tutorial – Magic Methods – __get() and __set()
10. PHP5 Tutorial – Magic Methods – __isset() and __unset()
11. PHP5 Tutorial – Magic Methods – __call() method
12. PHP5 Tutorial – Magic Methods – __autoload() method
13. PHP5 Tutorial – Magic Methods – __sleep() and __wakeup()
14. PHP5 Tutorial – Magic Methods – __clone() method

Differences between wp_query and get_posts

• query_posts() is overly simplistic and problematic way to modify main query of a page by replacing it with new instance of the query. It is inefficient (re-runs SQL queries) and will outright fail in some circumstances (especially often when dealing with posts pagination). Any modern WP code should use more reliable methods, like making use ofpre_get_postshook, for this purpose. TL;DR don't use query_posts() ever;
• get_posts() is very similar in usage and accepts same arguments (with some nuances, like different defaults), but returns array of posts, doesn't modify global variables and is safe to use anywhere;
• WP_Query class powers both behind the scenes, but you can also create and work with own object of it. Bit more complex, less restrictions, also safe to use anywhere.

The basic difference is that query_posts() is really only for modifying the current Loop. Once you're done it's necessary to reset the loop and send it on its merry way. This method is also a little easier to understand, simply because your "query" is basically a URL string that you pass to the function, like so:

query_posts('meta_key=color&meta_value=blue'); 

On the other hand, wp_query is more of a general purpose tool, and is more like directly writing MySQL queries than query_posts() is. You can also use it anywhere (not just in the Loop) and it doesn't interfere with any currently running post queries.

I tend to use wp_query more often, as it happens. Really, it's going to come down to your specific case.