$a will out put false, while $b will out put true and what is the reason for this?

These are small aspects but very important a programmer must know. In the first phrase it uses “&&” operator to bind those two expressions which will give the expected answer. but the second one gives an unexpected answer where “and” operator is used.

The reason behind is the “higher precedence” between these 3 operators,
1. &&
2. =
3. and

In the first condition it will first check for the “&&” operation and then for the “=”

But in the second condition it will first look for the “=” operator and then for the “and”.

In order to fix this you can force the precedence by using parenthesis as follows,

echo $b = (isset($one) and isset($two));

More info about “Operator Precedence“

But the simplest way in mysql is,

• SELECT * FROM country ORDER BY id DESC LIMIT 1, 1

plus there are some other methods as well,

• SELECT * FROM country ORDER BY id DESC LIMIT 1 OFFSET 1
• select max(id) from country where id not in(select max(id) from country)
• SELECT min(id) FROM (SELECT DISTINCT id FROM country ORDER BY id DESC LIMIT 2) AS t

• SELECT min([column]) AS [column]
  FROM (
  SELECT TOP 2 [column]
  FROM [Table]
  GROUP BY [column]
  ORDER BY [column] DESC
  ) a

   

• SELECT TOP 1 START AT 2 id from country ORDER BY id

In the above snippet; it will out put the ’2400 is greater’, which is correct. but what if the (int) is removed from the snippet.

Then the answer will be “800 is greater”, which is incorrect.

Therefore in calculations it is very important to do the proper conversions.

The Query parameters or the GET method parameters are handled as follows,

// url is /posts/index?page=1&sort=title
$this->request->query['page'];

// Also access it via array access
$this->request['url']['page'];

The POST method parameters are handled as follows,

$this->request->data['title'];

//if not exist it wil return null
$r = $this->request->data['not.exist'];
//$r == null

Also you must remember if an input name has the name “data”. it will have to remove the ‘data’ prefix.

// An input with a name attribute equal to 'data[Post][title]' is accessible at
$this->request->data['Post']['title'];

final class Class1 {
    // ...
}

class FatalClass extends Class1 {
    // ...
}

$out= new FatalClass();

An Abstract class will never be a final class as an abstract class must be extendable.

 class Fruit {
 private $color;

 public function eat() {
  //chew
 }

  public function setColor($c) {
   $this->color = $c;
  }
 }

 class Apple extends Fruit {
  public function eat() {
   //chew until core
  }
 }

 class Orange extends Fruit {
  public function eat() {
   //peel
   //chew
  }
 }

Now taste an apple

$apple = new Apple();
$apple->eat();

What’s the taste of it? Obviously it’s apple

Now eat a fruit

$fruit = new Fruit();
$fruit->eat();

What’s the taste of it? It doesn’t make any sense. does it? Which means the class fruit should not be Instantiable . This is where the abstract class comes into play

abstract class Fruit {
 private $color;

 abstract public function eat()

 public function setColor($c) {
  $this->color = $c;
 }
}

function MyPow($r, $w){
 if($w==0)
  return 1;
 else
  return MyPow($r, $w-1) * $r;
}

echo MyPow(10, 2);

Also this functionality substitutes by the pow() function in PHP.

1. Data (Node, ETC)
2. Modules
3. Blocks and Menus
4. User Permissions
5. Template

Data
Base of the system is collection of Nodes. – the data pool

Modules
These are functional plugins that are either part of the Drupal core (they ship with Drupal) or they are contributed items that have been created by members of the Drupal community.

Blocks and Menus
This is the next layer where we find blocks and menus. Blocks often provide the output from a module or can be created to display whatever you want, and then can be placed in various spots in your template (theme) layout. Blocks can be configured to output in various ways, as well as only showing on certain defined pages, or only for certain defined users.

User Permissions
Here is the next layer where settings are configured to determine what different kinds of users are allow to work and see.

Template
This is mainly the site theme or the skin. This is made up predominantly of XHTML and CSS, with some PHP variables intermixed

Understanding this flow of information is very important if you are facing A Drupal project targeted interview as the interviewer might test your overall knowledge  of  Drupal CMS by asking this sort of questions.

// similar to print_r(), but dumps to the view and
// is disabled if debug isn't > 0 in config.php
pr($anything); 

// returns the correctly internationalized plural or
// singular depending on locale.
__n($singular, $plural, $count, $return);

If you are working with CakePHP and haven’t figure it out yet, it’s worth looking through basics.php in the API docs.

The E_DEPRECATED error level is used to indicate that a function or feature has been deprecated.

E_USER_DEPRECATED

The E_USER_DEPRECATED level is intended for indicating deprecated features in user code, similarly to the E_USER_ERROR and E_USER_WARNING levels.

class A {
    public function who() {
        echo __CLASS__;
    }
    public function test() {
        $this->who();
    }
}

class B extends A {
    public function who() {
        echo __CLASS__;
    }
}
$obj = new B;
$obj->test();

Out put of the above snippet is? B This is mainly because we have the object instance named as $this is for the class B, though the function is instantiated inside class A. But, If you need the expected output which is “A”, we can call them statically as follows

class A {
    public static function who() {
        echo __CLASS__;
    }
    public static function test() {
        self::who();
    }
}

class B extends A {
    public static function who() {
        echo __CLASS__;
    }
}

B::test();

Out put -> A

Main limitation of self:: or __CLASS__ are resolved using the class in which the function belongs, as in where it was defined. By introducing late static binding this limitation has been resolved as follows,

class A {
    public static function who() {
        echo __CLASS__;
    }
    public static function test() {
        static::who(); // Here comes Late Static Bindings
    }
}

class B extends A {
    public static function who() {
        echo __CLASS__;
    }
}

B::test();

Out put -> B

This is just a quick note about how you must prepare for your technical interview whether it’s a face to face or a written.
Before you prepare for a technical interview you must re-work on your basics in the first place. if you are not sure enough don’t go to the interview. Prepare well for your next interview. It will help you a lot 

For an instance at least work on following aspects,

• Client Server  – > What is client server architecture? Basic requesting methods to the server?
• Sessions  -> What is a session? Where sessions are stored? How session reference is carried in the browser(client) side?
• OOP     -> What is a class? what is overloading? what is overriding and how you do these with examples?
• XML    -> What is xml? and what’s the use of it?
• AJAX -> What is ajax? if you use 3rd party tool at least know the basic functions.
• Frameworks – > Design patterns used? MVC? Explain cakephp, zend etc
• CMS-> At least the knowledge of integrating a template. Joomla, Drupal, Magento

Where is the sessions are stored?

Sessions are stored in server side and it is accessed by a unique id which is known as the session-id where each user/visitor is assigned when they access your website.

How the session-id is propagated within your website?

Basically, there are 2 methods either store it in a cookie or propagated in the URL.

Session security questions will not be asked in an entry level interviews but, if an advanced level candidate who has experience in developing robust and secured application must know about the vulnerabilities.

Leaking out an existing session-id to a third party is very risky if the session is filled with more important information.
Main two methods of vulnerabilities are,
- When the session-id is carrying in URLs
If an external link from your site, a URL with the id might be stored in the external site’s referrer log.

- Active attacker might listen to network traffic
While the session-id flows over the network and if it is not encrypted an active listener might grab it. The best solution is to implement SSL and make it a must for all the users.

Here is a list of php question areas that might be asked in an add-hoc oral technical interview.

First of all they will focus on some more basic questions,
- Difference between GET and POST
- Echo and print
- Language constructors and so on…

Then most likely they would focus on,
- The behaviors of sessions and cookies
- Ways of a session ID can be passed
- Db connection strings and how can it be centralized and stuff like that.
- Difference between normal connection and a persistent connection etc..

Then obviously the interviewer will have to asses on your knowledge in Object Oriented Programming techniques,
- Simply what is a class or object?
- Some definitions on OOP techniques like, Encapsulation, overloading, inheritance.

Also design pattern questions will be asked here.
- Which OOP pattern implements a class that must be instantiated only once in a life span of a script?
- Some more questions on design patterns mostly real world scenarios.
- How design patterns can be used as a mix of more than one pattern?
- Some more discussions related to MVC, Abstract factory, and singleton.

Last but not least they will focus on your knowledge about the security issues, best practices, probably about register global issues and so on. Then the interviewers will focus on more into your CV and about the Frameworks and CMS’s you have been exposed to.

We will be discussing all of above points one by one in later posts stay tuned.

Cheers !