Technical Interview: Frequently Asked Questions & Answers

Most of the time, when applying for software development jobs, be prepared to answer the following questions:
1. General Programming Questions:

1. What is the difference between passing parameter by value versus passing it by reference?
2. What is boxing / unboxing?
3. What is implicit conversion?
4. What is explicit conversion?
5. Late Binding vs. Early Binding in VB.NET

2. OO Questions:

1. What are the main concepts of Object Oriented development?
2. What is an Abstract Class?
3. What is an Interface?
4. What is Reflection?
5. What design patterns do you know?
6. What is the difference between value types vs. reference types?

3. SQL Questions:

1. How do you join two tables (SQL)?
2. What are the differences between different types of join?
3. What is UNION?

4. HTML Questions:

1. How do you make a table cell that runs across several columns?
2. How do you make a table cell that spans across multiple rows?

OO Answers:
1. Object-oriented programming (OOP) is a programming paradigm that uses "objects" – data structures consisting of data fields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as data abstraction, encapsulation, modularity, polymorphism, and inheritance.

2. Abstract classes are closely related to interfaces. They are classes that cannot be instantiated, and are frequently either partially implemented, or not at all implemented. One key difference between abstract classes and interfaces is that a class may implement an unlimited number of interfaces, but may inherit from only one abstract (or any other kind of) class. A class that is derived from an abstract class may still implement interfaces. Abstract classes are useful when creating components because they allow you specify an invariant level of functionality in some methods, but leave the implementation of other methods until a specific implementation of that class is needed. They also version well, because if additional functionality is needed in derived classes, it can be added to the base class without breaking code.

An abstract class is denoted in Visual Basic by the keyword MustInherit. In C#, the abstract modifier is used. Any methods that are meant to be invariant may be coded into the base class, but any methods that are to be implemented are marked in Visual Basic with the MustOverride modifier. In C#, the methods are marked abstract. The following example shows an abstract class:

' Visual Basic
Public MustInherit Class WashingMachine

Sub New()

' Code to instantiate the class goes here.

End sub

Public MustOverride Sub Wash
Public MustOverride Sub Rinse (loadSize as Integer)
Public MustOverride Function Spin (speed as Integer) as Long

End Class

// C#
abstract class WashingMachine
{
    public WashingMachine()
   {
         // Code to initialize the class goes here.
    }
    abstract public void Wash();
    abstract public void Rinse(int loadSize);
    abstract public long Spin(int speed);
}
 
In the above example, an abstract class is declared with one implemented method and three unimplemented methods. A class inheriting from this class would have to implement the Wash, Rinse, and Spin methods. The following example shows what the implementation of this class might look like:
 
' Visual Basic
Public Class MyWashingMachine
                 Inherits WashingMachine

Public Overrides Sub Wash()

    ' Wash code goes here

End Sub

Public Overrides Sub Rinse (loadSize as Integer)

' Rinse code goes here

End Sub

Public Overrides Function Spin (speed as Integer) as Long

' Spin code goes here

End Sub

End Class

// C#
class MyWashingMachine : WashingMachine
{
    public MyWashingMachine()
   {
    // Initialization code goes here.
   }

    override public void Wash()
   {
        // Wash code goes here.
    }

    override public void Rinse(int loadSize)
    {
        // Rinse code goes here.
    }

    override public long Spin(int speed)
    {
        // Spin code goes here.
    }
}
 
When implementing an abstract class, you must implement each abstract (MustOverride) method in that class, and each implemented method must receive the same number and type of arguments, and have the same return value, as the method specified in the abstract class.

3. An interface contains only the signatures of methods, delegates or events. The implementation of the methods is done in the class that implements the interface, as shown in the following example:

interface ISampleInterface
{
    void SampleMethod();
}

class ImplementationClass : ISampleInterface
{
    // Explicit interface member implementation:

    void ISampleInterface.SampleMethod()
    {
        // Method implementation.
    }

    static void Main()
   {
        // Declare an interface instance.

        ISampleInterface obj = new ImplementationClass();

        // Call the member.
        obj.SampleMethod();
    }
}

Remarks
 An interface can be a member of a namespace or a class and can contain signatures of the following members:
•Methods
•Properties
•Indexers
•Events

An interface can inherit from one or more base interfaces.
When a base type list contains a base class and interfaces, the base class must come first in the list.

A class that implements an interface can explicitly implement members of that interface. An explicitly implemented member cannot be accessed through a class instance, but only through an instance of the interface, for example:

For more details and code examples on explicit interface implementation, see Explicit Interface Implementation (C# Programming Guide).

Example
 The following example demonstrates interface implementation. In this example, the interface IPoint contains the property declaration, which is responsible for setting and getting the values of the fields. The class Point contains the property implementation.

// keyword_interface_2.cs
// Interface implementation
using System;

interface IPoint
{
// Property signatures:
    int x { get; set; }
    int y { get; set; }
}

class Point : IPoint
{
    // Fields:
    private int _x;
    private int _y;

// Constructor:
public Point(int x, int y)
{
    _x = x;
    _y = y;
}
// Property implementation:
public int x
{
    get
    {
        return _x;
    }
    set
    {
        _x = value;
    }
}

public int y
    {
        get
        {
            return _y;
        }
set
        {
            _y = value;
        }
    }
}

class MainClass
{
    static void PrintPoint(IPoint p)

    {
        Console.WriteLine("x={0}, y={1}", p.x, p.y);
    }
    static void Main()
    {
        Point p = new Point(2, 3);
        Console.Write("My Point: ");
        PrintPoint(p);
    }
}

4. Design Patterns: check this MSDN  resource: http://msdn.microsoft.com/en-us/magazine/cc301852.aspx


SQL Answers:
1 & 2. SQL joins are used to query data from two or more tables, based on a relationship between certain columns in these tables. Different SQL JOINs:
•JOIN: Return rows when there is at least one match in both tables
•LEFT JOIN: Return all rows from the left table, even if there are no matches in the right table
•RIGHT JOIN: Return all rows from the right table, even if there are no matches in the left table
•FULL JOIN: Return rows when there is a match in one of the tables
 
SQL INNER JOIN Keyword
The INNER JOIN keyword return rows when there is at least one match in both tables.

SQL INNER JOIN Syntax
SELECT column_name(s) FROM table_name1
INNER JOIN table_name2 ON table_name1.column_name = table_name2.column_name

SQL LEFT JOIN Keyword
The LEFT JOIN keyword returns all rows from the left table (table_name1), even if there are no matches in the right table (table_name2).

 SQL LEFT JOIN Syntax

SELECT column_name(s) FROM table_name1
LEFT JOIN table_name2 ON table_name1.column_name=table_name2.column_name

PS: In some databases LEFT JOIN is called LEFT OUTER JOIN.

SQL RIGHT JOIN Keyword
The RIGHT JOIN keyword Return all rows from the right table (table_name2), even if there are no matches in the left table (table_name1).

SQL RIGHT JOIN Syntax
SELECT column_name(s) FROM table_name1
RIGHT JOIN table_name2 ON table_name1.column_name = table_name2.column_name

PS: In some databases RIGHT JOIN is called RIGHT OUTER JOIN.

SQL FULL JOIN Keyword
The FULL JOIN keyword return rows when there is a match in one of the tables.

SQL FULL JOIN Syntax
SELECT column_name(s) FROM table_name1
FULL JOIN table_name2 ON table_name1.column_name = table_name2.column_name

3. UNION
The UNION operator is used to combine the result-set of two or more SELECT statements.

Notice that each SELECT statement within the UNION must have the same number of columns. The columns must also have similar data types. Also, the columns in each SELECT statement must be in the same order.

Note: The UNION operator selects only distinct values by default. To allow duplicate values, use UNION ALL.

SQL UNION Syntax
SELECT column_name(s) FROM table_name1
UNION
SELECT column_name(s) FROM table_name2

SQL UNION ALL Syntax
SELECT column_name(s) FROM table_name1
UNION ALL
SELECT column_name(s) FROM table_name2

Note: The column names in the result-set of a UNION are always equal to the column names in the first SELECT statement in the UNION.