Senior Application Developer

The SOLID principle is an acronym of the five principles which is given below :

1) Single Responsibility Principle (SRP)
2) Open/Closed Principle
3) Liskov’s Substitution Principle (LSP)
4) Interface Segregation Principle (ISP)
5) Dependency Inversion Principle (DIP)

Uses of SOLID design principles :

1) The SOLID principle helps in reducing tight coupling.
2) Tight coupling means a group of classes are highly dependent on one another which we should avoid in our code.
3) Opposite of tight coupling is loose coupling and our code is considered as a good code when it has loosely-
coupled classes.
4) Loosely coupled classes minimize changes in your code, helps in making code more reusable, maintainable,
flexible and stable.

Explaining the 5 SOLID principles one by one :

1) Single Responsibility Principle : This principle states that “a class should have only one reason to change” which
means every class should have a single responsibility or single job or single purpose.
Use layers in your application and break God classes into smaller classes or modules.

2) Open/Closed Principle : This principle states that “software entities (classes, modules, functions, etc.) should be
open for extension, but closed for modification” which means you should be able to extend a class behavior, without
modifying it. Using this principle separates the existing code from the modified code so it provides better stability,
maintainability and minimizes changes as in your code.

3) Liskov’s Substitution Principle : According to this principle “Derived or child classes must be substitutable for their
base or parent classes“. This principle ensures that any class that is the child of a parent class should be usable in
place of its parent without any unexpected behavior.

4) Interface Segregation Principle : This principle is the first principle that applies to Interfaces instead of classes in
SOLID and it is similar to the single responsibility principle. It states that “do not force any client to implement an
interface which is irrelevant to them“. Here your main goal is to focus on avoiding fat interface and give preference to
many small client-specific interfaces.

5) Dependency Inversion Principle : Two key points are here to keep in mind about this principle
a) High-level modules/classes should not depend on low-level modules/classes. Both should depend upon
abstractions.
b) Abstractions should not depend upon details. Details should depend upon abstractions.

If you are a user, and you have a problem statement, you don't want to know how the components of the software work, or how it's made. You only want to know how the software solves your problem. Abstraction is the method of hiding unnecessary details from the necessary ones. It is one of the main features of OOPs. 
For example, consider a car. You only need to know how to run a car, and not how the wires are connected inside it. This is obtained using Abstraction.

Interface and abstract class both are special types of classes that contain only the methods declaration and not their implementation. But the interface is entirely different from an abstract class. The main difference between the two is that, when an interface is implemented, the subclass must define all its methods and provide its implementation. Whereas when an abstract class is inherited, the subclass does not need to provide the definition of its abstract method, until and unless the subclass is using it.

Also, an abstract class can contain abstract methods as well as non-abstract methods.

Classloader is a subsystem of JVM which is used to load class files. Whenever we run the java program, it is loaded
first by the classloader. There are three built-in classloaders in Java.

1) Bootstrap ClassLoader: This is the first classloader which is the superclass of Extension classloader. It loads the
rt.jar file which contains all class files of Java Standard Edition like java.lang package classes, java.net package
classes, java.util package classes, java.io package classes, java.sql package classes, etc.


2) Extension ClassLoader: This is the child classloader of Bootstrap and parent classloader of System classloader. It
loads the jar files located inside $JAVA_HOME/jre/lib/ext directory.


3) System/Application ClassLoader: This is the child classloader of Extension classloader. It loads the class files from
the classpath. By default, the classpath is set to the current directory. You can change the classpath using "-cp" or "-
classpath" switch. It is also known as Application classloader.

String objects in Java are immutable by definition. This signifies that the String object's state cannot be changed once
it has been created. As a result, if you try to update the value of that object rather than the values of that object, Java
creates a new string object.

Because String objects are often cached in the String pool, Java String objects are immutable. Because String literals
are frequently shared among numerous clients, one client's action may have an impact on the others. It improves the
application's security, caching, synchronization, and performance by doing so.

JVM is platform dependent because it takes java byte code and generates byte code for the current operating
system. So Java software is platform dependent but Java language is platform independent because different
operating system have different JVMs.

Some of the famous pre-defined functional interfaces from previous Java versions are Runnable, Callable,
Comparator, and Comparable. While Java 8 introduces functional interfaces like Supplier, Consumer, Predicate, etc.
Please refer to the java.util.function doc for other predefined functional interfaces and its description introduced in
Java 8.

Runnable : use to execute the instances of a class over another thread with no arguments and no return value.

Callable : use to execute the instances of a class over another thread with no arguments and it either returns a value
or throws an exception.

Comparator : use to sort different objects in a user-defined order.

Comparable : use to sort objects in the natural sort order.

It encapsulates optional values, i.e., null or not-null values, which helps in avoiding null checks, which results in
better, readable, and robust code. It acts as a wrapper around the object and returns an object instead of a value,
which can be used to avoid run-time NullPointerExceptions.

The Spring Framework supports five scopes. They are :

1) Singleton : This provides scope for the bean definition to single instance per Spring IoC container.
2) Prototype : This provides scope for a single bean definition to have any number of object instances.
3) Request : This provides scope for a bean definition to an HTTP-request.
4) Session : This provides scope for a bean definition to an HTTP-session.
5) Global-session : This provides scope for a bean definition to an Global HTTP-session.

The last three are available only if the users use a web-aware ApplicationContext.

The Spring container is able to autowire relationships between the collaborating beans. That is, it is possible to let
Spring resolve collaborators for your bean automatically by inspecting the contents of the BeanFactory.
Different modes of bean auto-wiring are:

1) no : This is default setting which means no autowiring. Explicit bean reference should be used for wiring.

2) byName : It injects the object dependency according to name of the bean. It matches and wires its properties with
the beans defined by the same names in the XML file.

3) byType : It injects the object dependency according to type. It matches and wires a property if its type matches with
exactly one of the beans name in XML file.

4) constructor : It injects the dependency by calling the constructor of the class. It has a large number of parameters.

5) autodetect : First the container tries to wire using autowire by constructor, if it can’t then it tries to autowire by
byType.

It is a combination of @Controller and @ResponseBody, used for creating a restful controller. It converts the
response to JSON or XML. It ensures that data returned by each method will be written straight into the response
body instead of returning a template.

The @SpringBootApplication annotation is equivalent to using @Configuration, @EnableAutoConfiguration,
and @ComponentScan with their default attributes. Spring Boot enables the developer to use a single annotation
instead of using multiple. But, as we know, Spring provided loosely coupled features that we can use for each
annotation as per our project needs.

setMaxResults() the function works similar to LIMIT in SQL. Here, we set the maximum number of rows that we want
to be returned. This method is implemented by all database drivers.

setFetchSize() works for optimizing how Hibernate sends the result to the caller for example: are the results buffered,
are they sent in different size chunks, etc. This method is not implemented by all the database drivers.

Concurrency strategies are the mediators responsible for storing and retrieving items from the cache. While enabling
second-level cache, it is the responsibility of the developer to provide what strategy is to be implemented to decide for
each persistent class and collection.

Following are the concurrency strategies that are used:

1) Transactional: This is used in cases of updating data that most likely causes stale data and this prevention is most
critical to the application.

2) Read-Only: This is used when we don't want the data to be modified and can be used for reference data only.

3) Read-Write: Here, data is mostly read and is used when the prevention of stale data is of critical importance.

4) Non-strict-Read-Write: Using this strategy will ensure that there wouldn't be any consistency between the database
and cache. This strategy can be used when the data can be modified and stale data is not of critical concern.

Microservice architectures consist of the following components :

1) Clients: Different users send requests from various devices.
2) Identity Provider: Validate a user's or client's identity and issue security tokens.
3) API Gateway: Handles the requests from clients.
4) Static Content: Contains all of the system's content.
5) Management: Services are balanced on nodes and failures are identified.
6) Service Discovery: A guide to discovering the routes of communication between microservices.
7) Content Delivery Network: Includes distributed network of proxy servers and their data centers.
8) Remote Service: Provides remote access to data or information that resides on networked computers
and devices.

The following problems can be solved with spring cloud : 

1) Complicated issues caused by distributed systems: This includes network issues, latency problems, bandwidth problems, and security issues. 

2) Service Discovery issues: Service discovery allows processes and services to communicate and locate each other within a cluster. 

3) Redundancy issues: Distributed systems can often have redundancy issues. 

4) Load balancing issues: Optimize the distribution of workloads among multiple computing resources, including computer clusters, central processing units, and network links. 

5) Reduces performance issues: Reduces performance issues caused by various operational overheads.

Tip 1 : The cross questioning can go intense some time, think before you speak.
Tip 2 : Be open minded and answer whatever you are thinking, in these rounds I feel it is important to have opinion.
Tip 3 : Context of questions can be switched, pay attention to the details. It is okay to ask questions in these round,
like what are the projects currently the company is investing, which team you are mentoring. How all is the work
environment etc.