Technical Architect interview @ Xebia

Hi Friends, 

In this post I'm sharing Java Architect interview questions asked in Xebia.

Question 1:

What is distributed transaction? What architectures are available for performing distributed transactions?

Answer:

Simple Transaction:

A transaction is a logically atomic unit of work which may span multiple database queries. They ensure locks over resources they acquire in order to maintain the consistency of the database.

All this is done with the help of ACID properties.

Distributed Transaction:

A distributed transaction would do what a transaction would do but on multiple databases.

In a distributed scenario, the architecture would be split into services like handling service, payment gateway service etc who would house a respective database and all the actions would be performed in the respective databases.

 

One way of doing is the Two phase commit. 

In Two phase commit, we have a controlling node which houses most of the logic and we have a few participating nodes on which the actions would be performed.

 

Prepare Phase:

    In this phase, controlling node would ask all the participating nodes, if they are ready to commit. The participating nodes would then respond in yes or no.

Commit Phase:

    Then, if all the nods have replied in affirmative, the controlling node would ask them to commit, else if one node replies in negative, it'll ask them to rollback.

Drawbacks of Two Phase Commit:

• Whole logic gets concentrated in single node and if that node goes down, the whole system fails.

• The whole system is bound by slowest  node, since any ready node will, have to wait for response from the slower node which is yet to confirm it's status.

Another approach is Saga Pattern:

Saga pattern is one of the ways by which we ensure data consistency in a distributed architecture. But there is absence of atomicity in Saga pattern.

For example , in the e-commerce website, we first do the transaction pertaining to the customer selection. Once that is complete, we start selecting a product and so on. So all these constituent transactions together will be known as a Saga.

A successful Saga looks something like this:

• Start Saga
• Start T1
• End T1
• Start T2
• End T2
• Start T3
• End T3
• End Saga

But things do not go straight. Sometimes, we might not be in position to perform a transaction in the middle of the saga. At that point, the previously successful transactions would've already committed. 

So, apart from not continuing with the Saga, we also need to undo whatever changes we may have already committed. For this, we apply compensatory transactions.

Thus for each transaction Ti, we implement a compensatory transaction Ci, which tries to semantically nullify Ti.

It's not always possible to get back to the same state. e.g. if Ti involved in sending the email, we can't really undo that. So, we send a corrective email which semantically undoes Ti. So a failed saga looks something like this.

• Begin Saga
• Start T1
• End T1
• Start T2
• Abort Saga
• Start C2
• End C2
• Start C1
• End C1
• End Saga

There can be various ways of implementing Saga pattern, but to actually implement it in a scalable manner ,we can introduce a central process aka Saga Execution Controller or SEC.

SEC is merely a process that handles the flow of execution of transactions or compensatory transactions.

It helps us centrally locate the logic of execution.

Another important constituent in order to implement our form of saga pattern is Saga log.

Just like a database log, it's a basic, durable but distributed source of information.Every event that SEC executes is logged in Saga log. A good example of that could be a Kafka logic.

What if  our SEC fails down. The solution for that is , we can launch another SEC and it will start from where the first SEC left off.

Question 2:

How to write custom annotation?

Answer:

Java annotations are mechanism for adding metadata information to our source code.

Annotations were added in java 5.

Annotations offer an alternative to the use of XML descriptors and marker interfaces.

We can attach them to packages, classes, interfaces and methods but they have no effect on the execution of the program.

@interface keyword is used to declare an annotation.

Class level annotation:

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.Type)

public @interface JsonSerializable{

} 

In above code, I have defined a class level annotation. @Target and @Retention are used to define metadata [target and scope respectively].

ElementType.TYPE means, it is applied on types (classes).

RetentionPolicy.RUNTIME means, annotation has runtime visibility,

Field Level annotation:

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.FIELD)

public @interface JsonElement{

    public String key() default "";

}

This annotation declares one String parameter with name key and an empty string as the default value.

Method Level annotation:

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface Init{

}

When creating custom annotation for methods, keep in mind that the methods (on which these annotation are applied) cannot have any parameter and cannot throw any exception.

Now, we can simply apply these annotations on classes, fields and methods as shown below:

@JsonSerializable

public class Student{

    @JsonElement

    public String name;

    public String age;

    @Init

    private void getName(){

        

    }

} 

This getName() method is called before serialization. And only name field be serialized.

And as we have made this method private, so that we can't initialize our object by calling it manually.

Question 3:

What are Asymptotic notations? What is their use?

Answer:

Asymptotic notations are used to calculate running time complexity of an algorithm.

Below are the commonly used asymptotic  notations:

Big Oh notation , O:

The notation O(n) is the formal way to express the upper bound of an algorithm's running time.

It measures the worst case time complexity or the longest amount of time an algorithm can possibly take to complete.  

For example , for a function f(n)

o(f(n)) = {g(n) : there exists c > 0 and n theta such that f(n) <= c.g(n) for all n > n theta. }

Omega Notation:

The notation Omega(n) is the formal way to express the lower bound of an algorithm's running time. It measures the best case time complexity or the best amount of time an algorithm can possibly take to complete.

For example,  for a function f(n):

Theta Notation:

The notation theta(n) is the formal way to express both the lower bound and upper bound of an algorithm's running time.  It is represented as follows:

Question 4:

Write some HTTP error codes with their meaning.

Answer:

1XX : Informational

    

• 100 : Continue

2XX : SUCCESS

• 200 : OK
• 201 : Created
• 202 : Accepted
• 204 : No Content

3XX : Redirection

4XX : Client Error

• 400 : Bad Request
• 401 : Unauthorized
• 402 : Payment Required
• 403 : Forbidden
• 404 : Not Found

5XX : Server Error

• 500 : Internal Server Error
• 501 : Not Implemented
• 502 : Bad Gateway
• 503 : Service Unavailable [Website's server is simply not available]

That's all from this interview.

Thanks for reading!!