Senior Software Engineer

JIT stands for Just-In-Time. It is used for improving the performance during run time. It does the task of compiling parts of byte code having similar functionality at the same time thereby reducing the amount of compilation time for the code to run. The compiler is basically a translator of source code to machine-executable code.

Working of the JIT Compiler :
1) First, the Java source code (.java) conversion to byte code (.class) occurs with the help of the javac compiler.

2) Then, the .class files are loaded at run time by JVM and with the help of an interpreter, these are converted to machine understandable code.

3) JIT compiler is a part of JVM. When the JIT compiler is enabled, the JVM analyzes the method calls in the .class files and compiles them to get more efficient and native code. It also ensures that the prioritized method calls are optimized.

4) Once the above step is done, the JVM executes the optimized code directly instead of interpreting the code again. This increases the performance and speed of the execution.

The 5 SOLID principles are : 
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.

A stream is a declarative concept for expressing data processing requests. A Stream is a data pipeline that is not connected to Java I/O Streams and represents a succession of data objects and a series of operations on that data. It does not keep any data permanently. java.util.stream.StreamT> is the key interface. Functional Interfaces are accepted, allowing lambdas to be supplied. Streams allow for a fluid user interface or chaining.

PremGen: Before Java 8, class metadata was kept in the PremGen (Permanent-Generation) memory type. PremGen has a fixed size and cannot be resized dynamically. It was a Java Heap Memory that was continuous.
MetaSpace: Java 8's 'MetaSpace' holds the MetaData of classes in native memory. Because it is not a contiguous Heap Memory, it can grow dynamically, allowing it to circumvent size limits. This enhances metadata trash collection, auto-tuning, and de-allocation.

The process of injecting dependent bean objects into target bean objects is called dependency injection.
1) Setter Injection: The IOC container will inject the dependent bean object into the target bean object by calling the setter method.
2) Constructor Injection: The IOC container will inject the dependent bean object into the target bean object by calling the target bean constructor.
3) Field Injection: The IOC container will inject the dependent bean object into the target bean object by Reflection API.

The @SpringBootApplication annotation is equal to using the default characteristics of @Configuration, @EnableAutoConfiguration, and @ComponentScan. Instead of using numerous annotations, Spring Boot allows the developer to use just one. However, as we all know, Spring provides us with loosely linked features that we may employ for each annotation according to our project requirements.

The Runnable interface has a single run method. It represents a unit of computation that has to be run in a separate thread. The Runnable interface does not allow this method to return value or to throw unchecked exceptions.
The Callable interface has a single call method and represents a task that has a value. That's why the call method returns a value. It can also throw exceptions. Callable is generally used in ExecutorService instances to start an asynchronous task and then call the returned Future instance to get its value.

The default port of the tomcat server-id 8080. It can be changed by adding sever.port properties in the application.property file.

Tip 1 : Be sure to do your homework on the organization and its culture before the interview.
Tip 2 : Employers want to understand how you use your time and energy to stay productive and efficient. Be sure to emphasize that you adhere to deadlines and take them seriously.
Tip 3 : Talk about a relevant incident that made you keen on the profession you are pursuing and follow up by discussing your education.