Software engineering

Question 1: Design a chess game using OOP concepts?

Question 2: What data structure do you use for a game like chess? How would you
go about coding a game of checkers?

DBMS vs. RDBMS

Question 3: I was given a function and asked what are all the things that could go
wrong with it?
Ans: access modifiers, return type, arguments, function of the function, requirement of the
function.

Linked List implementation
Question 4: Singly, doubly Linked List Insert, Delete and reverse etc.

Question 5: What is encapsulation?

Ans: The encapsulation is the inclusion within a program object of all the resources need
for the object to function - basically, the methods and the data. In OOP the encapsulation is
mainly achieved by creating classes, the classes expose public methods and properties. The
class is kind of a container or capsule or a cell, which encapsulate the set of methods,
attribute and properties to provide its indented functionalities to other classes. In that
sense, encapsulation also allows a class to change its internal implementation without
hurting the overall functioning of the system. That idea of encapsulation is to hide how a
class does it but to allow requesting what to do.

In order to modularize/ define the functionality of a one class, that class can uses
functions/ properties exposed by another class in many different ways. According to Object
Oriented Programming there are several techniques, classes can use to link with each other
and they are named association, aggregation, and composition. There are several other
ways that an encapsulation can be used, as an example we can take the usage of an
interface. The interface can be used to hide the information of an implemented class.
IStudent myStudent = new LocalStudent();
IStudent myStudent = new ForeignStudent();
According to the example (Assuming LocalStudent and ForeignStudent are implemented by
the IStudentinterface), we can see how LocalStudent and ForeignStudent are hiding their,
localize implementing information through the IStudent interface.

Question 6: What's the difference in encapsulation and inheritance?

Encapsulation is the mechanism that binds together data structure (attributes) and
behavior (operations) of an object into a single unit. It keeps the internal implementation
details of the object hidden from other objects. In other words, encapsulation works as a
protective sheet that prevents code and the data from being misused by other code outside
the sheet. By the use of the encapsulation mechanism, the implementation of an object can
be changed without having any side effect on the applications that use it. In Java, the basis
of encapsulation is the class. It defines the code and data that will be shared by a group of
instances of the class (called objects).
Inheritance is a process by which objects of a class acquire the properties of the objects of
another class. It supports the concept of hierarchical classification. It not only allows
objects to be reused, but also allows the creation of new objects by extending the existing
ones. By using the inheritance, a generic class can be created that can then be inherited by
other more specific classes. In Java terminology, a class that is inherited is called a
superclass, and the class that inherits another class is called a subclass. A subclass inherits
all the instance variables (attributes) and methods (operations) defined in the superclass.
In Java, a class is declared to inherit another class by using the extends keyword.

Question 7: What is database normalization?

Question 8: Make a binary tree where the nodes are the letters in "Cerner".

Question 9: Given a method signature for a method that would search and replace
text in a string. If you were writing unit tests what would you test for?

Question 10: Given a String reversal program, explain the output.

Question 11: Question about unit testing. How to create unit test cases?

In computer programming, unit testing is a method by which individual units of source
code, sets of one or more computer program modules together with associated control
data, usage procedures, and operating procedures, are tested to determine if they are fit for
use.
One can view a unit as the smallest testable part of an application. In procedural
programming a unit could be an entire module but is more commonly an individual
function or procedure. In object-oriented programming a unit is often an entire interface,
such as a class, but could be an individual method. Unit tests are created by programmers
or occasionally by white box testers during the development process.
Ideally, each test case is independent from the others: substitutes like method stubs, mock
objects, fakes and test harnesses can be used to assist testing a module in isolation. Unit
tests are typically written and run by software developers to ensure that code meets its
design and behaves as intended. Its implementation can vary from being very manual
(pencil and paper) to being formalized as part of build automation.

Question 12: If a user reports that an application is slow, what steps would you
take?
Ans: user is true, problem persists, full domain or only user.

Question 13: What are scopes in programming languages and their uses?
Ans: Variable scopes public private and in general access modifiers.

The scope of a variable in a program is the lines of code in the program where the variable
can be accessed. Two different types of scope have been used in programming
languages: static scope and dynamic scope. Most modern programming languages such as
Pascal, C++ and Java use static scope. Some languages such as APL, Snobol4 and early
versions of LISP use dynamic scope.

The converse of scope is referencing environment. The referencing environment of a
procedure is the set of all the variables whose scope extends to the procedure. The local
referencing environment of a procedure consists of all the variables declared within the
procedure, and includes any formal parameters of the procedure. The non-local
referencing environment consists of all the variables not declared in the procedure, but
whose scope extends to the procedure.

The concept of scope applies not only to variable names but also to the names of
procedures. The scope of the name of a procedure determines all the procedures/functions
in a program that can call the procedure.

1) Static Scope

The static scope of a variable is the most immediately enclosing block, excluding any
enclosed blocks where the variable has been re-declared. Therefore, the static scope of a
variable in Pascal is the procedure in which the variable is declared, excluding any
procedures defined inside this procedure that declare another variable by the same name.
The static scope of a variable in a program can be determined by simply studying the text of
the program. Static scope is not affected by the order in which procedures are called during
the execution of the program.

Example:
What is the scope of the variable x declared in the procedure compute() in the following
program?

program main
var y: Real;

procedure compute()
var x : Integer;

procedure initialize()
var z: Real;
begin {initialize}
...
end {initialize}

procedure transform()
var x: Real;
begin {transform}
...
end {transform}

begin {compute}
...
end {compute}
begin {main}
...
end {main}

Answer:
The procedure in which the variable is declared iscompute(). Therefore, compute() is in
the scope of x.
The procedure initialize() is defined within compute(). Since initialize() does not re-
declare x, initialize() is within the scope of x declared in compute().
The procedure transform() is defined within compute(). Since transform() does re-
declare x, transform() is not within the scope of x declared in compute().

Program main() is also an enclosing block (procedure) ofx. But, since it is not
the immediately enclosing procedure, i.e., it is not the procedure in which x is
declared, main() is not in the scope of x declared incompute().

Pragmatics:

Note that the concept of scope is essential to understanding programs. In the above
example, you would not be able to correctly answer the following questions if you did not
understand the concept of scope:
1. If transform() procedure prints the value of x, which variable would it be referencing?
2. If initialize() procedure prints the value of x, which variable would it be referencing?
3. If main() program attempts to use the value of x, would it be legal?
Can you answer these questions?

Algorithms to determine Static Scope:

The structure of a Pascal program, in particular, the order in which procedure definitions
are nested in the program can be graphically depicted as a tree. This tree is called the static
tree of the program. It is quite convenient to use the static tree of a Pascal program to
determine the static scope of a variable in the program.

Algorithm to draw the static tree of a Pascal program:
1. Draw the main() program as the root node of the tree.
2. Identify all the procedures/functions directly defined in main(). Draw them as child
nodes of main() node.
3. Repeatedly carry out step 2 for all the leaf nodes of the tree, until there are no more
nested procedures in the program.
In the Pascal program presented earlier, compute() is the only procedure defined directly
in main(). Hence, it is the only child of main(). The procedures initialize() and
transform() are defined within compute() and are its children. The static tree of the
program is shown below.

Algorithm to determine the static scope of a variable v declared in a procedure p()
using the static tree of the program:
1. Identify the sub-tree of the static tree with procedurep() as its root.
2. In this sub-tree, identify any descendant nodes (i.e., procedures/functions) that re-
declare the variable v. Eliminate the entire sub-trees with these nodes as root.
The remaining nodes in the sub-tree identified in Step 1 are in the scope of the
variable v declared in procedurep().

2) Dynamic Scope

The dynamic scope of a variable extends to all the procedures called thereafter during
program execution, until the first procedure to be called that re-declares the variable.
Therefore, in order to determine the dynamic scope of a variable, we must first know the
sequence in which procedures are called during execution of the program. Unlike static
scope, dynamic scope cannot be determined merely by studying the text of a program.
Pascal uses static scope, not dynamic scope. For purposes of discussing dynamic scope, we
will assume that the language we are considering is a Pascal-like language, and not Pascal
itself. However, using the same Pascal syntax for all the modules in the courseware will
help us focus on the concept of scope in this module.

Example:

What is the scope of the variable x declared in the procedure compute() in the following
program, assuming that procedures are called in the following
order: main()calls compute(), which in turn calls transform(), which in turn
calls initialize()?

program main
var y: Real;

procedure compute()
var x : Integer;

procedure initialize()
var x: Real;
begin {initialize}
...
end {initialize}

procedure transform()
var z: Real;
begin {transform}
...
end {transform}

begin {compute}
...
end {compute}
begin {main}
...
end {main}

Answer:
The procedure in which the variable is declared iscompute(). Therefore, compute() is in
the scope of x.
Procedure compute() calls the procedure transform(). Since transform() does not re-
declare x, transform() is within the scope of x declared in compute().
Procedure transform() in turn calls procedureinitialize(). Since initialize() does re-
declare x, initialize() is not within the scope of x declared incompute().
Program main() is not called by/after compute(), but rather, before it.
Therefore, main() is not in the scope of declared in compute().

Pragmatics:

Note that the concept of scope is essential to understanding programs. In the above
example, you would not be able to correctly answer the following questions if you did not
understand the concept of scope:
1. If transform() procedure prints the value of x, which variable would it be referencing?
2. If initialize() procedure prints the value of x, which variable would it be referencing?
3. If main() program attempts to use the value of x, would it be legal?
Can you answer these questions?

Algorithm to determine Dynamic Scope:

In order to determine the dynamic scope of a variable in a program, it is convenient to use a
directed graph of the order in which procedures are called during the execution of the
program. The directed graph for the earlier program is shown below:

Algorithm to determine the dynamic scope of a variable v declared in a procedure
p() using a directed graph of procedure calls:
1. Identify the sub-graph of the directed graph that begins with the procedure p().
2. In this sub-graph, identify the first descendant node (i.e., procedure/function) that re-
declares the variable v. Eliminate the entire sub-graph that begins with this node.
The remaining nodes in the sub-graph identified in Step 1 are in the dynamic scope of the
variable v declared in procedure p().



Question 14: Were the customers unhappy about your work anytime?

Question 15: Design a traffic signal using Java?

Question 16: Describe a situation where you have difficulties with your team
members.
Ans:

Question 17: Describe a situation where you have difficulties with your team
members.
Biggest mistake in IT/programming. How did you fix it?
Ans:

Question 18: Describe a situation where you have difficulties with your team
members.

Question 19: What is the difference between a Set and a List?
Ans: List is an ordered sequence of elements whereas Set is a distinct list of elements which
is unordered. You have to compare concrete implementations (for example HashSet with
ArrayList); because the abstract interfaces Set/List don't really tell you anything about
performance.

Here are few note worthy differences between List and Set in Java. Remember that both of
them are used to store objects and provides convenient API to insert, remove and retrieve
elements, along with to support Iteration over collection.

1) Fundamental difference between List and Set in Java is allowing duplicate
elements. List in Java allows duplicates while Set doesn't allow any duplicate. If you
insert duplicate in Set it will replace the older value. Any implementation of Set in Java will
only contains unique elements.

2) Another significant difference between List and Set in Java is order. List is an
Ordered Collection while Set is an unordered Collection. List maintains insertion order
of elements, means any element which is inserted before will go on lower index than any
element which is inserted after. Set in Java doesn't maintain any order. Though Set provide
another alternative called SortedSet which can store Set elements in specific Sorting order
defined by Comparable and Comparator methods of Objects stored in Set.

3) Set uses equals () method to check uniqueness of elements stored in Set, while List uses
compareTo () method to implement natural sorting order of elements. In order for an
element to behave properly in Set and SortedSet, equals and compareTo must be consistent
to each other.

4) Popular implementation of List interface in Java includes ArrayList, Vector and
LinkedList. While popular implementation of Set interface includes HashSet, TreeSet and
LinkedHashSet.

When to use List and Set in Java
Another good follow-up question is "when do you use List and Set in Java", which can
also be answered based on properties of List and Set we have learn here. These differences
between Set and List also teach us when to use Set and when to prefer List. It is pretty clear
that if you need to maintain insertion order or object and you collection can contain
duplicates than List is a way to go. On the other hand if your requirement is to maintain
unique collection without any duplicates than Set is the way to go.

Important point to note is that both List and Set are derived from Collection Interface. In
short, main difference between List and Set in Java is that List in an ordered collection
which allows duplicates while Set is an unordered collection which doesnt.

Question 20: What type of job would you like within Software Engineering field?
Ans: Code, test, analysis,

Question 21: Describe a scenario where you tried to troubleshoot and you failed
Ans:


Question 22: Describe a scenario where you tried to troubleshoot and you
succeeded

All long-lasting tasks should be run in separate thread, not in UI thread. You call
getFileFromUrl(..) from onCreate(..) method. This cause hangings.
I recommend you not to do any time consuming task in onCreate(..) method. In general an
activity won't be shown till onCreate(..) is finished. In case of strings, use string buffer if
appending is necessary, thus creating short lived temp objects. Virtual method calls are
expensive c++ is gets inline in java directly access the variable.
Know And Use The Libraries

Question 23: What is inheritance?

Ans: Inheritance is the capability of a class to use the properties and methods of another
class while adding its own functionality.
Ability of a new class to be created, from an existing class by extending it, is
called inheritance.
public class Exception
{
}
public class IOException : Exception
{
}
The new class (IOException), which is called the derived class or subclass, inherits the
members of an existing class (Exception), which is called the base class or super-class. The
class IOException can extend the functionality of the class Exception by adding new types
and methods and by overriding existing ones.

Just like abstraction is closely related with generalization, the inheritance is closely related
with specialization. It is important to discuss those two concepts together with
generalization to better understand and to reduce the complexity.

One of the most important relationships among objects in the real world is specialization,
which can be described as the is-a relationship. When we say that a dog is a mammal, we
mean that the dog is a specialized kind of mammal. It has all the characteristics of any
mammal (it bears live young, nurses with milk, has hair), but it specializes these
characteristics to the familiar characteristics of canis domesticus. A cat is also a mammal. As
such, we expect it to share certain characteristics with the dog that are generalized in
Mammal, but to differ in those characteristics that are specialized in cats.

The specialization and generalization relationships are both reciprocal and hierarchical.
Specialization is just the other side of the generalization coin: Mammal generalizes what is
common between dogs and cats, and dogs and cats specialize mammals to their own
specific subtypes.

Similarly, as an example you can say that both IOException and SecurityException are of
type Exception. They have all characteristics and behaviors of an Exception, That mean
the IOException is a specialized kind of Exception. A SecurityException is also an Exception.
As such, we expect it to share certain characteristic with IOException that are generalized in
Exception, but to differ in those characteristics that are specialized in SecurityExceptions. In
other words, Exception generalizes the shared characteristics of
both IOException and SecurityException, while IOException and SecurityException specialize
with their characteristics and behaviors.
In OOP, the specialization relationship is implemented using the principle called
inheritance. This is the most common and most natural and widely accepted way of
implement this relationship.

Question 24: What are your 3 biggest achievements so far?










Question 25: How would you go about designing a program that determines
whether or not a number is prime?
Java code:

import java.io.*;

class PrimeNumber
{
public static void main(String[] args) throws Exception
{
int i;
Buffered Reader bf = new BufferedReader(new InputStreamReader (System.in));
System.out.println (Enter number :);
int num = Integer.parseInt(bf.readLine());
System.out.println(Prime number: );
for (i=1; i<num; i++)
{
for(j=2; j<i; j++)
{
int n = i%j;
if (n==0)
{
break;
}
}
if (i==j)
{
System.out.println(Prime number: + +i);
}
}
}

Question 26: If there was anything you wanted to change about a programming
language, what would it be?

What is the biggest mistake you made in a past job.

Question 27: Tell me about OOP concepts. Explain some of the ideas behind Object
Oriented programming

Ans: OOP is a design philosophy. It stands for Object Oriented Programming. Object-
Oriented Programming (OOP) uses a different set of programming languages than old
procedural programming languages (C, Pascal, etc.). Everything in OOP is grouped as self
sustainable "objects". Hence, you gain re-usability by means of four main object-oriented
programming concepts.
In order to clearly understand the object orientation, lets take your hand as an example.
The hand is a class. Your body has two objects of type hand, named left hand and right
hand. Their main functions are controlled/ managed by a set of electrical signals sent
through your shoulders (through an interface). So the shoulder is an interface which your
body uses to interact with your hands. The hand is a well architected class. The hand is
being re-used to create the left hand and the right hand by slightly changing the properties
of it.

What is an Object?
An object can be considered a "thing" that can perform a set of related activities. The set of
activities that the object performs defines the object's behavior. For example, the hand can
grip something or a Student (object) can give the name or address.
In pure OOP terms an object is an instance of a class.

A class is simply a representation of a type of object. It is the blueprint/ plan/ template that
describe the details of an object. A class is the blueprint from which the individual objects
are created. Class is composed of three things: a name, attributes, and operations.

public class Student
{
}
According to the sample given below we can say that the student object,
named objectStudent, has created out of the Student class.
Student objectStudent = new Student();

In the software world, though you may not have realized it, you have already used classes.
For example, the TextBoxcontrol, you always used, is made out of the TextBox class, which
defines its appearance and capabilities. Each time you drag a TextBox control, you are
actually creating a new instance of the TextBox class.

Additionally to identify a class correctly, you need to identify the full list of leaf level
functions/ operations of the system (granular level use cases of the system). Then you can
proceed to group each function to form classes (classes will group same types of functions/
operations). However a well defined class must be a meaningful grouping of a set of
functions and should support the re-usability while increasing expandability/
maintainability of the overall system.

In software world the concept of dividing and conquering is always recommended, if you
start analyzing a full system at the start, you will find it harder to manage. So the better
approach is to identify the module of the system first and then dig deep in to each module
separately to seek out classes.

A software system may consist of many classes. But in any case, when you have many, it
needs to be managed. Think of a big organization, with its work force exceeding several
thousand employees (lets take one employee as a one class). In order to manage such a
work force, you need to have proper management policies in place. Same technique can be
applies to manage classes of your software system as well. In order to manage the classes
of a software system, and to reduce the complexity, the system designers use several
techniques, which can be grouped under four main concepts named Encapsulation,
Abstraction, Inheritance, and Polymorphism. These concepts are the four main gods
of OOP world and in software term, they are called four main Object Oriented Programming
(OOP) Concepts.

1) Encapsulation:
The encapsulation is the inclusion within a program object of all the resources need for the
object to function - basically, the methods and the data. In OOP the encapsulation is mainly
achieved by creating classes, the classes expose public methods and properties. The class is
kind of a container or capsule or a cell, which encapsulate the set of methods, attribute and
properties to provide its indented functionalities to other classes. In that sense,
encapsulation also allows a class to change its internal implementation without hurting the
overall functioning of the system. That idea of encapsulation is to hide how a class does it
but to allow requesting what to do.

In order to modularize/ define the functionality of a one class, that class can uses
functions/ properties exposed by another class in many different ways. According to Object
Oriented Programming there are several techniques, classes can use to link with each other
and they are named association, aggregation, and composition.
There are several other ways that an encapsulation can be used, as an example we can take
the usage of an interface. The interface can be used to hide the information of an
implemented class.
IStudent myStudent = new LocalStudent();
IStudent myStudent = new ForeignStudent();
According to the example (Assuming LocalStudent and ForeignStudent are implemented by
the IStudentinterface), we can see how LocalStudent and ForeignStudent are hiding their,
localize implementing information through the IStudent interface.

2) Abstraction

Abstraction is an emphasis on the idea, qualities and properties rather than the particulars
(a suppression of detail). The importance of abstraction is derived from its ability to hide
irrelevant details and from the use of names to reference objects. Abstraction is essential in
the construction of programs. It places the emphasis on what an object is or does rather
than how it is represented or how it works. Thus, it is the primary means of managing
complexity in large programs.

While abstraction reduces complexity by hiding irrelevant detail, generalization reduces
complexity by replacing multiple entities which perform similar functions with a single
construct. Generalization is the broadening of application to encompass a larger domain of
objects of the same or different type. Programming languages provide generalization
through variables, parameterization, generics and polymorphism. It places the emphasis on
the similarities between objects. Thus, it helps to manage complexity by collecting
individuals into groups and providing a representative which can be used to specify any
individual of the group.
Abstraction and generalization are often used together. Abstracts are generalized through
parameterization to provide greater utility. In parameterization, one or more parts of an
entity are replaced with a name which is new to the entity. The name is used as a
parameter. When the parameterized abstract is invoked, it is invoked with a binding of the
parameter to an argument.

Abstract
Abstract classes, which declared with the abstract keyword, cannot be instantiated. It can
only be used as a super-class for other classes that extend the abstract class. Abstract class
is the concept and implementation gets completed when it is being realized by a subclass.
In addition to this a class can inherit only from one abstract class (but a class may
implement many interfaces) and must override all its abstract methods/ properties and
may override virtual methods/ properties.

Interface
In summary the Interface separates the implementation and defines the structure, and this
concept is very useful in cases where you need the implementation to be interchangeable.
Apart from that an interface is very useful when the implementation changes frequently.
Some say you should define all classes in terms of interfaces, but I think recommendation
seems a bit extreme.

Interface can be used to define a generic template and then one or more abstract classes to
define partial implementations of the interface. Interfaces just specify the method
declaration (implicitly public and abstract) and can contain properties (which are also
implicitly public and abstract). Interface definition begins with the keyword interface. An
interface like that of an abstract class cannot be instantiated.
If a class that implements an interface does not define all the methods of the interface, then
it must be declared abstract and the method definitions must be provided by the subclass
that extends the abstract class. In addition to this an interfaces can inherit other interfaces.

A class and an interface are two different types (conceptually). Theoretically
a class emphasis the idea of encapsulation, while an interface emphasis the idea of
abstraction (by suppressing the details of the implementation). The two poses a clear
separation from one to another. Therefore it is very difficult or rather impossible to have
an effective meaningful comparison between the two, but it is very useful and also
meaningful to have a comparison between an interface and an abstract class.

1. Interface definition begins with a keyword interface so it is of type interface
2. Abstract classes are declared with the abstract keyword so it is of type class

3. Interface has no implementation, but they have to be implemented.
4. Abstract classs methods can have implementations and they have to be extended.

5. Interfaces can only have method declaration (implicitly public and abstract) and
fields (implicitly public static)
6. Abstract classs methods cant have implementation only when declared abstract.
7. Interface can inherit more than one interfaces
8. Abstract class can implement more than one interfaces, but can inherit only one
class

9. Abstract class must override all abstract method and may override virtual methods
10. Interface can be used when the implementation is changing

11. Abstract class can be used to provide some default behavior for a base class.
12. Interface makes implementation interchangeable

13. Interface increase security by hiding the implementation
14. Abstract class can be used when implementing framework

15. Abstract classes are an excellent way to create planned inheritance hierarchies and
also to use as non-leaf classes in class hierarchies.

3) Inheritance

According to the above example the new class (IOException), which is called the derived
class or subclass, inherits the members of an existing class (Exception), which is called the
base class or super-class. The class IOException can extend the functionality of the class
Exception by adding new types and methods and by overriding existing ones.
Just like abstraction is closely related with generalization, the inheritance is closely related
with specialization. It is important to discuss those two concepts together with
generalization to better understand and to reduce the complexity.
One of the most important relationships among objects in the real world is specialization,
which can be described as the is-a relationship. When we say that a dog is a mammal, we
mean that the dog is a specialized kind of mammal. It has all the characteristics of any
mammal (it bears live young, nurses with milk, has hair), but it specializes these
characteristics to the familiar characteristics of canis domesticus. A cat is also a mammal. As
such, we expect it to share certain characteristics with the dog that are generalized in
Mammal, but to differ in those characteristics that are specialized in cats.
The specialization and generalization relationships are both reciprocal and hierarchical.
Specialization is just the other side of the generalization coin: Mammal generalizes what is
common between dogs and cats, and dogs and cats specialize mammals to their own
specific subtypes.
Similarly, as an example you can say that both IOException and SecurityException are of
type Exception. They have all characteristics and behaviors of an Exception, That mean
the IOException is a specialized kind of Exception. ASecurityException is also an Exception.
As such, we expect it to share certain characteristic with IOException that are generalized in
Exception, but to differ in those characteristics that are specialized in SecurityExceptions. In
other words, Exception generalizes the shared characteristics of
both IOException and SecurityException, while IOExceptionand SecurityException specialize
with their characteristics and behaviors.
In OOP, the specialization relationship is implemented using the principle called
inheritance. This is the most common and most natural and widely accepted way of
implement this relationship.

4) Polymorphism

Polymorphisms is a generic term that means many shapes. More
precisely Polymorphisms mean the ability to request that the same operations be
performed by a wide range of different types of things.
At times, I used to think that understanding Object Oriented Programming concepts have
made it difficult since they have grouped under four main concepts, while each concept is
closely related with one another. Hence one has to be extremely careful to correctly
understand each concept separately, while understanding the way each related with other
concepts.
In OOP the polymorphisms is achieved by using many different techniques named method
overloading, operator overloading and method overriding,

Method Overloading
The method overloading is the ability to define several methods all with the same name.

Operator Overloading
The operator overloading (less commonly known as ad-hoc polymorphisms) is a specific
case of polymorphisms in which some or all of operators like +, - or == are treated as
polymorphic functions and as such have different behaviors depending on the types of its
arguments.

Method Overriding
Method overriding is a language feature that allows a subclass to override a specific
implementation of a method that is already provided by one of its super-classes.
A subclass can give its own definition of methods but need to have the same signature as
the method in its super-class. This means that when overriding a method the subclass's
method has to have the same name and parameter list as the super-class's overridden
method.

Question 28: Some basic questions regarding data types and their usage.

Tell me about yourself

Why do u want to work at Cerner? young crowd, relaxed environment for developers

What was the challenging work in your career



Question 29: What is a deadlock?
Deadlock is defined as the permanent blocking of a set of processes that compete for
system resources, including database records and communication lines. Unlike some other
problems in multiprogramming systems, there is no efficient solution to the deadlock
problem in the general case. Deadlock occurs when a set of processes are in a wait state,
because each process is waiting for a resource that is held by some other waiting process.
Therefore, all deadlocks involve conflicting resource needs by two or more processes.

Two general categories of resources can be distinguished:
Reusable: something that can be safely used by one process at a time and is not depleted
by that use.
Processes obtain resources that they later release for reuse by others.
E.g., CPU, memory, specific I/O devices, or files.
Consumable: these can be created and destroyed. When a resource is acquired by a
process, the resource ceases to exist.
E.g., interrupts, signals, or messages.

One other taxonomy again identifies two types of resources:
Preemptable: These can be taken away from the process owning it without ill effect
(needs save/restore). E.g., memory or CPU.
Non-preemptable: Cannot be taken away from its current owner without causing the
computation to fail. E.g., printer or floppy disk.
Deadlocks occur when sharing reusable and non-preemptable resources.
Four conditions that must hold for a deadlock to be possible:
Mutual exclusion: processes require exclusive control of its resources (not sharing).
Hold and wait: process may wait for a resource while holding others.
No preemption: process will not give up a resource until it is finished with it.
Processes irreversible: unable to reset to an earlier state where resources not held.
These can lead to Circular wait. Each process in the chain holds a resource requested by
another.

Question 29: Name a team project you have completed and some of the difficulties that
came with it.

Question 30: If you can change some features of your favorite programming language,
what are they?

Question 31: Explain the differences between searching through a linked list vs. a
binary tree?
Binary Trees
Medium complexity to implement (assuming you can't get them from a library)
Inserts are O(logN)
Lookups are O(logN)



Linked lists (unsorted)
Low complexity to implement
Inserts are O(1)
Lookups are O(N)

Hash tables
High complexity to implement
Inserts are O(1) on average
Lookups are O(1) on average

Question 32: What were the most difficult task you came across in any of your projects
at your current workplace or during masters

Question 33: Explain to me an incident where you ran into a significant problem in a
project you were working on, whether it was for a college course or for a job that you
had during college, and also explain how you overcame that problem.

Question 34: Explain to me your largest achievement in a college course you were
taking or at a job you had while you were in college.

Question 35: What is your process when tackling a research project?

Question 36: How do you go about finding the root cause of any issue?

Question 37: What do you ultimately want your career to take you?

Question 38: What was your greatest achievement?

Question 39: Name a time when a coworker didn't follow through with a task and how
did you overcome that?

Question 40: If you were to have a choice between Systems Engineer and Software
Engineer, which one would you pick?

Question 41: How would you get someone resistant to change to adapt to new
technology?

Question 42: Describe a situation where the requirements of a project changed, but the
deadline did not. How did resolve this?

Question 43: Give me an example of a situation where you had to deliver bad news to a
superior.

Question 44: Describe the approach you took in a situation where you were required
to teach something to one of your peers.

Question 45: Print a string Foo if a number is divisible by 5 ,Bar if divisible by 7 ,Foo
Bar if divisible by 35 continue this process till number 75.

Question 46: Name a time you were involved in a sensitive situation and how you
handled it.

Question 47: Tell me about a time you had a conflict with a coworker or manager, and
what was the not result.

Question 48: Tell me a time when you had to deal with ambiguity on a project?

Question 49: Tell about a time where you had to solve a problem with little resources?
What did you do and how did it work out?

Question 50: Tell me about a time when you had two conflicting tasks and how you
went about solving it?

Question 51: Tell me about a time you had to work with little direction. //break the
problem into components and that thing wont be new / knowledge management portal
/ approach not the solution

Question 52: Tell me about a time you disagreed with a team members decision.

Question 53: What was a time you underachieved on a project job?

Question 54: Describe a time when you had to do something out of the ordinary to
achieve a goal for your team.

Question 55: How do you make your work environment very enjoyable?

Question 56: if i want to develop my skills, how do i develop myself how can i?

Question 57: what kind of knowledge management portal do you use?