. . .

LD refers to Little Dinosaur.

Pilot Training Questions

Mock

Self - Introduction

requirements:

Prepare a fluent self-introduction and a detailed summary of work/project experience.
Familiarize yourself thoroughly with your resume.Be ready to elaborate on your roles, achievements, and
technologies/tools you used.

Hey there! I’m Michael Hu.

I’ve been working as a Java backend developer for over ten years now, and I have experience building scalable,
high-performance systems to solve real business problems.

I’m good at Java and Spring Boot. I used them to design and run backend systems stably. And I used them to create many
RESTful APIs. These APIs have detailed documentation, and I used these APIs, to make many different micro services
communicate with each other in a distributed environment.

For security, I use Spring Security, OAuth2, JWT to implement authentication and authorization, to make sure
everything is secure.
For data processing, I also work with Apache / əˈpætʃi / Kafka for real-time data processing, to build
event-driven architectures that handle high-throughput data streams and scalable messaging systems.
For database, I mainly use MySQL and MongoDB and redis, I’ve got plenty of experience with Hibernate and JPA for
data persistence. (I design complex schemas, optimize queries, and ensure data integrity)
For cloud platforms, I worked with many AWS services. I use EC2 to deploy and manage virtual servers, ECS to orchestrate / ˈɔːrkɪstreɪt / Microservices in
containers,RDS to
handle relational databases, S3 to handle scalable storage, I use CloudWatch to track performance, monitor logs, metrics, and system health.

Work/Project Summary

requirements: Prepare 1-2 examples of past projects or jobs where you made a significant impact. Use the STAR
method (Situation, Task, Action, Result) to structure your responses. DO NOT READ, we can tell!

Project 1: Russell Investments - Backend Developer (Nov 2022 - Present, Seattle, WA)
- Situation: First, let me talk about the company I’m currently working for. its name is Russell Investments, it’s a fintech company,
  - I’m a senior backend java developer there.I’m mainly responsible for developing and maintaining the core backend modules related to financial data processing and system integration and optimizing the performance of critical backend components to ensure the stability and efficiency of our fintech applications.
  - Because the number of financial transactions was growing very fast, but their old backend couldn’t keep up with new features and increasing user activity, so we needed a stronger backend system.
- Task: So I used springboot/kafka/redis/mysql/aws services/kubernetes to build a scalable microservices-based backend, and optimize the database-related parts and enhance security.
- Action(unnecessary, should skip): So I had to take some actions to finish my task. so First,(根据从处理数据一点点到部署的顺序记忆)
  - to handle scalability, I used springboot to developed a modular microservices architecture and designed plenty of RESTful APIs. Each service handled a specific function, like user management, poll management, and data analysis.
  - to handle security, I used Spring Security and OAuth2 for authentication and authorization.
  - to handle data processing, I used Kafka to make data analysis much faster.
  - to handle database, I used Redis caching to reduce database load and speed up responses. I also optimized
    database queries by adding indexes, removing redundant joins.
  - to handle storage, I integrated AWS RDS to enhance data management. , integrating third-party analysis
    tools.
  - to handle deployment, I used Docker and Kubernetes to handle it.
- Result: as the result, The new microservices architecture made the system more flexible and easier to maintain. and the platform also became more scalable and efficient, like: because our API response times improved by 30%, so now our system handled 20% more daily transactions, and user engagement went up by 25% . and yeah, that is almost what I did.

15 behavioral questions

1. Why did you leave your last job?

Personal experience:
- Because I wanted something more challenging and a job that fit my career plans better. I wanted to find a
  place where I can use my skills to really make a difference.
- That’s why I’m really excited about this job at your company. I researched your company and your project, Your
  company’s job description is a total match for my work experience. I can really get things done. And there’s
  also new stuff to learn.
- For example, I really like Kafka. in this new job, I’ll have the opportunity to deeply explore Kafka, so i think This new job seems super suitable for me, I’m really excited about it.
- and I really think I can use the stuff from my old company to help your project succeed.

2. Describe a major conflict within or outside your team and how you handled it, or how you dealt with a difficult team member.

General approach: Usually, I first figure out what’s causing the issue, then have a one-on-one chat to talk
with the team member. We consider the goals and find a way to reach a compromise, especially when deciding on
different approaches.I will also try my best to understand his idea. We will discuss and keep it transparent and try to choose the best solution. It does not matter who comes up with that solution, because our goal is to make best product for customers.If we cannot really agree on each other, we will escalate to manager and let manager decides, we should all agree on the final decision.
Personal experience: for example, At my previous company, I remember once I disagreed with a frontend
developer on the API design. He wanted something simple, but I knew we needed something more scalable. And then we discussed it, his idea is easier to implement and easier to use, but it’s not scalable; however, my idea is more complicated to implement but it’s more scalable. so After discussing the issue and considering the advantages and disadvantages, we found a compromise, that is, I create a simple version that the frontend can use right away, and also supported optional parameters to let the frontend get extra data. as the result, it worked well, and both of us were happy about it.

3. Describe a time when you had difficulty completing a task or making progress.

Personal experience:
- ST: I remember when I was At my previous company, I had trouble dealing with slow database queries for our inventory system.
- A: first I used explain to inspect those slow queries, and then I checked JOIN types and their efficiency, and then I reviewed index usage, finally I found some unoptimized joins. so I researched MySQL optimizations, and I asked for some advice from some database experts. then I created indexes on frequently joined columns, changed some LEFT JOINs to INNER JOINs .This way, we stop getting data we don’t need..
- R: As the result, the query execution time was reduced by 50%. inventory lookups became much faster.. This whole thing really helped me understand more about databases optimization. i feel it was a great experience to me because I gained all the SQL experiences.

4. If your manager asks you to change something that you think is already good enough, how would you handle it?

General approach: Usually, I listen to my manager’s reasons and then I share my view and show some data to
support it. If needed, I think we could come up with a compromise …
Personal experience: for example, I remember once I used Memcache to do the caching. but my manager wanted to
switch to use Redis. So we discussed it, I thought Memcache’s data structure was pretty simple so it’s very easy to use and it fully met our needs at that time. We just needed to cache some key - value values then. But he told me that our project will become more complicated, and Redis had more features and it was more powerful to handle future changes and redis had better performance. so we ran some tests to compare their performance and we found that redis was better, and we found that Redis was also better than Memcache in many other ways. like:
- for data processing, redis can handle different kinds of data, like lists, sets, and hashes. but Memcache can only deal with key - value pairs.
- for data persistence, redis can store data on the disk, but memcache can not.
so finally, we decided to use redis to handle changes in the future, because redis is way better than Memcache.

5. Why do you want to join our team?

Same as 1.

6. Are you familiar with Agile `/ ˈædʒ(ə)l /` processes and Waterfall methodology `/ ˌmeθəˈdɑːlədʒi /`?

General approach: Agile works in an iterative / ˈɪtəreɪtɪv/ way. It breaks work into small cycles. This way,
you can get feedback all the time and make changes as you go. Waterfall is different. It’s sequential. That means
you have to follow the steps one by one.
Personal experience: In my experience, Agile is really good for projects that are fast - paced and need to be flexible. for example, At my previous company, we used Scrum. We had two - week sprints and daily stand - up meetings. This helped us change things fast based on what users said. But for smaller projects where everything is clearly defined, like a school project, I use Waterfall, When you have a clear plan from the beginning to the end,it’s easier to get the work done. Both methods are useful in their own ways, but I like Agile better because itcan adapt to different situations.

7. What does a typical day look like for you?

We follow Agile methodology, we have 2 weeks sprint.
- So at beginning of each sprint, we have a planning meeting which we sit together to discuss all the tickets we need to work in in the whole sprint, and after that we have grooming meeting which is for developers to get familiar their own tickets.
- Then in each day, we have daily standup meeting in the morning at around 10am when we discuss our progress on each ticket and any blockers (need to wait on others work) we have. After meeting, we go back to work on our tickets and sometimes, we have meeting with business team to discuss the detailed problems, we also have design meetings for each big stories and we also have developer meetings to discuss our common issues.
- AT the end of each sprint, we have retrospective/retro meeting to review what we have done.
- Percentage of daily time: 60-70% on coding including development and test cases, 10-20% on meetings, 10-20% on leading junior people or system design meeting

8. What do you think are the most important factors for a successful team ?

General approach: Good communication, clear goals, trust, and a positive learning attitude are key for a team to succeed.Some points to mention:
- Good team culture, nice working environment
- Good skills and new technologies used in the team
- You feel you can grow in the team, someday you may become a senior or leading some juniors
- You feel being important to the project, you can make contributions and be needed by others as well.

9. If you are working on a sprint and your manager suddenly assigns you a new task that needs to be finished as soon as possible, what would you do?

General approach: This is really normal for me. First I will connect with manager to get an idea on the
priority / praɪˈɔːrəti / of the task, and reorganize my priorities. ( in the middle say something like gotta
be a reason manager made the choice)
Personal experience: for example, I remember once I was working on a ticket to implement a new API
endpoint, suddenly manager assigned a new ticket for me, it’s related to the production issue, which was about
the delays in order processing, and the manager thought I have the ability to do that. Finally, manager is
really happy about how quickly I solved the issue.

10. Tell me something about yourself that is not on your resume.

Personal experience: I like to develop some productivity tools, like shell tool, I once developed a zshell
plugin that can search everything very quickly with the key tab, and I once developed a chrome plugins, which can
show the table of content for the web pages, so we can navigate to the chapter whatever we want very quickly, it’s
very helpful to read the long technical articles, and I introduced these tools to my team members, which helped
them complete their work more efficiently and also enhanced my coding skills.

11. Tell me about a difficult project or challenge you faced and how you handled it.

same as 3

Personal experience:
- Situation: I remember once I made a mistake and let some sensitive user data show up in an API. It was a
  security issue.
- Task: I needed to quickly solve the problem to protect user data and make sure this kind of thing didn’t
  happen again in the future.
- Action: I took some actions to fix the security problem. I reproduced it in our local environment, I added checks and controls to limit data access
  to those who could access the data. Then I held a meeting and made a presentation about this problem. and we
  discussed how to prevent this kind of problem from happening again in the future.
- Result: After that, I’m always careful about user data and always review my code before I push my code. our code review process became better and we added stricter security checks and more
  reviews.

13. Do you have on-call experience, and are you comfortable with overnight on-call duties?

Personal experience: this is very normal for me, I’m totally comfortable with overnight on-call duties. I
remember when I was at my REI, I was on call during busy times. and there was a problem with the database, I fixed
it quickly and got the service running again.

14. Do you know what pair programming is, and what are your thoughts on it?

It’s like There are two developers and they are working together for tickets and they will share the idea to each other who is each other and they will learn something from each other.
its advantages is like:
- Good to learn from the leader and good for new members to get familiar with project
- Good to trigger new ideas, when you discuss, new ideas come out more often then you just think by yourself
and the disadvantage is like:
- Bad: coding is very slow.
as for Work independent: I am experienced, so I can solve most of the tickets just by working on my own.
But I also did pair programming with team members, like when we have Demo or Design meetings, or when I do knowledge transfer for some new team members, I do pair programming to help them.

15. If you are mentoring a junior colleague and they propose a new idea to the team, how would you handle it?

General approach: Usually, I listen to the idea, I think about it if it’s a good solution, and I help them
show it to the team.
Personal experience: I remember many years ago ,once I was mentoring a junior colleague ; and he came out with an idea that we should use a new API testing tool named postman to replace our old API tester, I checked how it would work with our project, and and it’s much easier to
integrate into our CI/CD workflow. I encouraged them to show it to the team, and the team agreed to use the idea.as the result, it was very popular and we all like that very much

16. Describe your code review process. What do you focus on during a code review?

General approach: Usually, I focus on making code easy to read, and check if it has security risk and some
performance problems, and make sure it follows our coding standards.
- Syntax error
- Possible duplicate logic
- Method possibilities to split to reusable methods.
- Make sure having unit test that covers the part
- Check performance improvements, like try to improve the time and space complexity.
- Check performance, like try to use cache or eliminate duplicate database calls.
Personal experience: For example, when I was doing a code review, I found variable names that were not clear,
or a security problem like some colleagues didn’t check the access permissions in their APIs, or some performance
issues like redundant for loops to search something. We fixed those things, and the code became better and more secure.

Leetcode

Arrays
- Two sum: https://leetcode.com/problems/two-sum/description/
- Contains Duplicate: https://leetcode.com/problems/contains-duplicate/description/
- Group Anagram: https://leetcode.com/problems/group-anagrams/description/
- Best Time to Buy and Sell Stock: https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/
- Top K Frequent Elements: https://leetcode.com/problems/top-k-frequent-elements/description/
- Longest Consecutive Sequence: https://leetcode.com/problems/longest-consecutive-sequence/description/
Two Pointer
- Valid Palindrome: https://leetcode.com/problems/valid-palindrome/description/
- 3Sum: https://leetcode.com/problems/3sum/description/
Binary Search
- Binary Search: https://leetcode.com/problems/binary-search/description/
- Search in Rotated Sorted Array: https://leetcode.com/problems/search-in-rotated-sorted-array/description/
- Koko Eating Bananas: https://leetcode.com/problems/koko-eating-bananas/description/
Sliding Window
- Longest Substring Without Repeating
  Characters: https://leetcode.com/problems/longest-substring-without-repeating-characters/description/
Linked List
- Reverse Linked List: https://leetcode.com/problems/reverse-linked-list/description/
- Merge Two Sorted Lists: https://leetcode.com/problems/merge-two-sorted-lists/description/
- Linked List Cycle: https://leetcode.com/problems/linked-list-cycle/description/
- Copy List with Random Pointer: https://leetcode.com/problems/copy-list-with-random-pointer/description/
Stack & Queue
- Valid Parentheses: https://leetcode.com/problems/valid-parentheses/description/
- Min Stack: https://leetcode.com/problems/min-stack/description/
- Implement Queue using Stacks: https://leetcode.com/problems/implement-queue-using-stacks/description/
DFS & BFS
- Number of Islands: https://leetcode.com/problems/number-of-islands/description/

Rest API

User Info
- Given URL: https://jsonplaceholder.typicode.com/users
- You need to write a REST api to call the given URL and return a user with its “name, username, zipcode”
- for example, if user id is 1, you should return a JSON file with username “Bret”, email “Sincere@april.biz” and
  zipcode “92998-3874”
  - HINT: use “Rest Template”
- Result: OPEN a webbrowser and enter: http://localhost:8080/user/1 should return the correct result.
- Follow-up: id only 1-10, how to handle /user/11 → print in the page “Invalid ID”
- Solution
Movie
- https://jsonmock.hackerrank.com/api/movies/search/?Title=waterworld
- GIVEN Above URL. Write a MVC with rest api to fetch this URL and then create new rest APIs to:
  - Show all movies
  - Show all movies sort by year
  - Fetch a particular movie based on its imdbID.
  - Hint: have multiple pages
- Solutions
  - look at this URL date, it has multiple pages, each page has 10 movies, we need to fetch all pages to get a
    full list of movies and then filter to find the particular movie by imdbID
  - each movie has Title, Year, imdbID three fields, we need to create a model to match them
  - need org.json.simple to parse the json object from the given URL
Build a POST API /greetings with below requirements
- Create a POST API /greetings
- INPUT – json array: [{“name”:”john doe”, “work”: “engineer”}, {“name”:”jane who”, “work”: “manager”}]
- OUTPUT - json: {“data”: [“Hello john the engineer”, “Hello jane the manager”], “timestamp”: “$
  {requested_timestamp}”
- Use postman to call the API and pass input, it should return the correct response.

Top100

my own answer

“id”: 40,
- “question”: “If you have error, but it is not showing in log, how do you debug and find it.”,
- “answer”:
  - When you have an error that is not showing in the log, here are some steps you can take to debug and find it:
    1. Review the code: Look for any obvious mistakes, such as incorrect variable names, missing parentheses, or logical errors in the algorithm. Check for any recently made changes that could have introduced the error.
    2. Add additional logging statements: Insert print statements or use a logging library to output relevant variable values, function calls, and program flow information at various points in the code.
    3. Use a debugger: If available, use a debugger tool. You can set breakpoints at specific lines of code and then step through the program execution.
    4. Check the environment: Verify that the runtime environment is set up correctly.
    5. Test in isolation: If possible, isolate the code that is causing the problem and test it in a simpler, controlled environment.
    6. Check for external factors: Consider if there are any external factors that could be causing the error, such as network issues, database problems, or interactions with other services.
    7. Review stack traces and error messages: Even if the error is not showing in the regular log, check if there are any other sources of error information, such as stack traces that might be printed to the console or in other log files.
    8. Use error handling and assertions: Add more comprehensive error handling and assertions to your code.
    9. Ask for help: If you are still unable to find the error, reach out to colleagues or online communities for assistance.
- “keyword”: “System”,
- “frequency”: 4,

“id”: 448,

“question”: “What is proxy design pattern”,

“answer”:

The Proxy Design Pattern is a structural design pattern that provides a surrogate or placeholder for another object to control access to it.
usage: It is used to control access to the real object, add additional functionality, or provide a more efficient way of accessing the object. Here’s a detailed explanation:
Subject: This is an interface that defines the common interface for the RealSubject and Proxy.
RealSubject: This is the actual object that the proxy represents.

Proxy: This is the object that controls access to the RealSubject. It has a reference to the RealSubject and implements the Subject interface.

interface Image {
    void display();
}

class RealImage implements Image {
    private final String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }

    private void loadFromDisk() {
        System.out.println("Loading " + fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying " + fileName);
    }
}

class ProxyImage implements Image {
    private RealImage realImage;
    private final String fileName;

    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

Explanation:

Interface Image:
- interface Image defines the display() method that both RealImage and ProxyImage will implement.
RealSubject RealImage:
- RealImage implements Image.
- The RealImage constructor loads the image from disk when an instance is created.
- The display() method displays the image.
Proxy ProxyImage:
- ProxyImage also implements Image.
- ProxyImage holds a reference to RealImage.
- In the display() method of ProxyImage, if realImage is not instantiated, it creates a RealImage instance.
- Then, it calls the display() method of RealImage.

“keyword”: “Java”,
“frequency”: 4,

“id”: 450,
- “question”: “What is kafka dead letter queue and how do you handle it?”,
- “answer”:
  - A Kafka dead - letter queue (DLQ) is a special topic in a Kafka cluster that is used to store messages that cannot be successfully processed for some reason. Here’s an overview of what it is and how to handle it:
  - Purpose: The main purpose of a DLQ is to prevent messages from being lost when they encounter processing failures. Instead of discarding the messages, they are sent to the DLQ for further analysis and possible re - processing.
  - How Messages End Up in the DLQ: Messages can end up in the DLQ due to various reasons, such as application - level errors (e.g., incorrect message format, missing required fields), network issues, or problems with the processing logic. When a consumer fails to process a message after a certain number of retries, the message is typically redirected to the DLQ.
  - Monitoring and Analysis:
    - Monitor DLQ Size: Regularly check the size of the DLQ to identify any unusual spikes. A growing DLQ may indicate a problem with the message processing pipeline.
    - Inspect Messages: Examine the messages in the DLQ to determine the cause of the processing failures. This can involve looking at the message payload, headers, and any error messages associated with the failed processing attempts.
  - Error Resolution:
    - Fix Application Bugs: If the errors are due to bugs in the consumer application, fix the code and redeploy the application.
    - Data Correction: If the messages in the DLQ contain incorrect data, correct the data either manually or through an automated process.
  - Message Re - processing:
    - Manual Re - processing: For critical or complex messages, you may choose to re - process them manually. This allows for careful inspection and ensures that the processing is done correctly.
    - Automated Re - processing: Set up a mechanism to automatically re - process messages from the DLQ. This can be a separate consumer that reads from the DLQ and attempts to process the messages again, perhaps with some additional error - handling logic.
  - Configuration and Tuning:
    - Retry Policies: Review and adjust the retry policies for your consumers. Determine the appropriate number of retries and the delay between retries based on the nature of your application and the expected failure scenarios.
    - DLQ Topic Configuration: Configure the DLQ topic with appropriate settings, such as retention policies and replication factors. Ensure that the DLQ has enough storage to handle the potentially large number of messages.
  - Handling a Kafka dead - letter queue effectively requires a combination of monitoring, error resolution, message re - processing, and proper configuration to ensure the reliability and integrity of the message processing system.
- “keyword”: “Kafka”,
- “frequency”: 4,
“id”: 159,
- “question”: “How does microservices communicate with each other?”,
- “answer”: null,
- “keyword”: “Microservice”,
- “frequency”: 0,
“id”: 290,
- “question”: “Explain CAP theorem and which database use them”,
- “answer”:
  - The CAP theorem, also known as Brewer’s theorem, is a key concept in distributed systems. It says that in a distributed system, it’s impossible to have all three of the following qualities at the same time:
    - Consistency: All nodes in the system see the same data at the same time. In a consistent system, a read operation will always return the most recent write.
    - Availability: Every request received by a non - failed node in the system must get a response. The system is always available to handle requests, even when there are failures.
    - Partition tolerance: The system can still work even if there are network partitions. Network partitions happen when the network is split into parts that can’t talk to each other.
  - In practice, distributed systems have to make choices between these three qualities. Different databases make different choices based on their design goals and what the applications they serve need.
  - For MySQL, it aims to provide high consistency and availability. It uses techniques like data replication and a shared - nothing architecture to achieve these. But when there are network partitions, it may have to make some trade - offs between availability and consistency, depending on how it’s set up and the specific failure situation. In general, MySQL leans more towards consistency and availability, sacrificing some partition tolerance.
  - MongoDB is a NoSQL database that focuses on high availability and partition tolerance. It can handle a large amount of data across multiple nodes in a distributed environment. It replicates data across nodes to ensure availability and can continue to operate even when there are network partitions. However, it sacrifices strong consistency. The data may not be exactly the same across all nodes at the same time, but it provides eventual consistency, which means that over time, the data will become consistent.
  - Redis is an in - memory data store that is often used for caching and real - time applications. It emphasizes high availability and consistency. It usually runs on a single node or in a cluster with replication for high availability. It provides strong consistency for operations within a single node. But in a distributed setup, if there are network issues, it may face challenges in maintaining all three CAP properties. It sacrifices partition tolerance to some extent to ensure consistency and availability for typical use cases.
  - In summary, different databases make different trade - offs based on the CAP theorem to meet the specific needs of different applications.
- “keyword”: “NoSQL”,
- “frequency”: 0,
“id”: 162,
- “question”: “Design a Employee Voting system according to the requirements”,
- “answer”: null,
- “keyword”: “OOD”,
- “frequency”: 0,
“id”: 166,
- “question”: “Basic principles of the OOP”,
- “answer”: null,
- “keyword”: “OOP”,
- “frequency”: 0,
“id”: 316,
- “question”: “SQL how to delete duplicate rows, only keep unique rows”,
- “answer”:
  CREATE TABLE temp_table AS
  SELECT DISTINCT * FROM your_table;
  DROP TABLE your_table;
  ALTER TABLE temp_table RENAME TO your_table;
- “keyword”: “SQL”,
- “frequency”: 0,

“id”: 449,

“question”: “What to lazy loading a spring bean”,
“answer”:

Lazy - loading a Spring bean means that the bean is instantiated only when it’s first needed, rather than during the application context startup.
How to achieve it:

XML configuration:

In traditional XML - based Spring configuration, you can use the lazy - init attribute. For example:
<bean id="myBean" class="com.example.MyBeanClass" lazy - init="true"/>
Here, the myBean bean will be lazily initialized. When the application context starts, this bean won’t be instantiated immediately. It will be created when it’s first requested from the application context, such as when it’s injected into another bean or retrieved using ApplicationContext.getBean("myBean").

Java - based configuration:

In Java - based configuration classes (using @Configuration), you can use the @Lazy annotation.

Suppose you have a configuration class like this:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
@Configuration
public class AppConfig {
    @Bean
    @Lazy
    public MyBeanClass myBean() {
        return new MyBeanClass();
    }
}

The MyBeanClass bean (represented by the myBean method) will be lazily loaded.
The main advantage of lazy - loading is that it can speed up the application startup time, especially when you have a lot of beans and not all of them are needed immediately. However, the first access to a lazy - loaded bean may take a bit longer because the bean needs to be instantiated and initialized at that time.,

“keyword”: “Spring Core”,
“frequency”: 4,

“id”: 447,

“question”: “How to do cache in spring boot and how to refresh the cache”,
“answer”:

Caching in Spring Boot:

Add Dependency: In your pom.xml if you use Maven, add the Spring Cache Starter dependency.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring - boot - starter - cache</artifactId>
</dependency>

Enable Caching: In your main application class, add the @EnableCaching annotation.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

Cache Methods: Use @Cacheable on methods you want to cache.

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class YourService {
    @Cacheable("yourCacheName")
    public String getData(String key) {
        // Some time - consuming operation
        return "Data for " + key;
    }
}

Refreshing the Cache:

@CacheEvict: Use @CacheEvict to remove entries from the cache.

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;

@Service
public class YourService {
    @Cacheable("yourCacheName")
    public String getData(String key) {
        // Some time - consuming operation
        return "Data for " + key;
    }

    @CacheEvict(value = "yourCacheName", allEntries = true)
    public void refreshCache() {
        // This method will clear the entire cache named 'yourCacheName'
    }
}

This setup allows you to cache method results in Spring Boot and refresh the cache when needed.

“keyword”: “Spring Boot”,
“frequency”: 4,
“top”: true

Misc

“id”: 353,
- “question”: “When you API request or Frontend page loading slowly, how do you handle it?”,
- “answer”: “
  Key things:
  1. For large dataset request, you can use Pagination. Just like google search, you can split your data into batches, each request only fetch fixed amount of rows.
  2. Use cache instead of database visit, Frontend: cache the visited page data. Backend: in-memory java cache for monolithic application, distributed cache, redis, for microservices.
  3. Other tools can help improve read performance, like elasticsearch can boost the search.
  4. Database side: Optimize the SQL, use Sql tuning tools, like the Oracle explain plan. Add proper index (non-cluster index) on some frequently visited columns.
  “,
- “keyword”: “Performance”,
- “frequency”: 0,
- “top”: true

“id”: 298,

“question”: “Key Difference: Soap vs Rest”,

“answer”:
SOAP (Simple Object Access Protocol) and REST (Representational State Transfer) are both architectural styles used for data exchange over a network. They have several differences in design concepts, usage scenarios, etc. Here is a detailed introduction for you:

Protocol Characteristics
- SOAP: It is an XML-based protocol with a strict message format specification. It uses XML to describe the structure and content of messages. A SOAP message consists of parts such as Envelope, Header, and Body. This strict format makes message parsing and validation more standardized.
- REST: It is not a protocol but an architectural style. It doesn’t have a strict message format requirement. Usually, it uses various methods of the HTTP protocol (such as GET, POST, PUT, DELETE) to operate on resources. The message format can be XML, JSON, etc. However, due to its lightweight and simplicity, JSON is more widely used in RESTful APIs.
Data Transmission
- SOAP: Since XML is used for data transmission, the tags and structure of XML will increase the size of the data, resulting in relatively low transmission efficiency. However, the self-descriptiveness of XML makes SOAP messages clearer and easier to understand.
- REST: The JSON data format is relatively concise, small in size, and has high transmission efficiency. In the mobile Internet and scenarios with high performance requirements, the advantages of REST are more obvious.
Service Discovery
- SOAP: It usually uses WSDL (Web Services Description Language) to describe the interface and operations of the service. Clients can understand the functions and invocation methods of the service through WSDL. WSDL is an XML-based document that describes in detail the input and output parameters and operation methods of the service.
- REST: There is no specific service description language. Usually, API documentation is used to describe the interface and usage methods of the service. The design of RESTful APIs pays more attention to the use of resource URIs and HTTP methods, making the semantics of the interface more intuitive.
Error Handling
- SOAP: It has a dedicated error handling mechanism and passes error information through SOAP Fault. SOAP Fault contains the error code, description, and detailed information, enabling the client to accurately understand the cause of the error.
- REST: It usually uses HTTP status codes to represent errors. For example, 404 indicates that the resource was not found, and 500 indicates an internal server error, etc. Although HTTP status codes can provide basic error information, for some complex error scenarios, additional error descriptions may need to be added in the response body.
Security
- SOAP: It supports a variety of security mechanisms, such as WS-Security, which can encrypt, sign, and other operations on messages to ensure the security and integrity of messages. In addition, SOAP can be integrated with enterprise-level security systems, such as LDAP, Kerberos, etc.
- REST: It mainly relies on the security mechanisms of the HTTP protocol, such as HTTPS to ensure the security of data transmission. In terms of authentication, RESTful APIs usually use methods such as OAuth and JWT for identity authentication and authorization.

Usage Scenarios

SOAP: It is suitable for enterprise-level application scenarios with high requirements for security, transactionality, and reliability, such as the financial and telecommunications industries. In these scenarios, the accuracy and integrity of data are of great importance, and the strict specifications and security mechanisms of SOAP can meet these needs.
REST: It is more suitable for Internet applications, mobile applications, and other scenarios with high requirements for performance and development efficiency. The simplicity and flexibility of RESTful APIs enable developers to quickly build and iterate services.

Example Code Comparison

SOAP Example (Python)

import requests
from zeep import Client

# Create a SOAP client
client = Client('http://www.example.com/service?wsdl')

# Invoke the service method
result = client.service.SomeMethod(param1='value1', param2='value2')
print(result)

REST Example (Python)

import requests

# Send a GET request
response = requests.get('http://www.example.com/api/resource')
if response.status_code == 200:
    data = response.json()
    print(data)

In conclusion, both SOAP and REST have their own advantages and disadvantages. When choosing which architectural style to use, a comprehensive consideration should be made according to specific application scenarios and requirements.

“keyword”: “Rest”,
“frequency”: 0,
“top”: true

“id”: 354,
- “question”: “How do you implement security for your application or microservices”,
- “answer”: “
  Principles:
  For Authentication
  - Basic Authentication: use username and password authentication. the password should be encrypted. common encryption algorithm: BCrypt, SHA256, RSA.
  - JWT Token: When the first time user login with username and password, backend will create a JWT token which contains the user info, the token will be stored in the frontend cookie. Every single request will carry this token, backend will validate this token to decide if user is authenticated. A token usually has a expiration time.
  - Asymmetric key pairs: this is used for something like AWS command portal validation. It create a private key on server side and give public key to the client side. client with public key should be able to match with the private key on the server side.
  - OAuth2: this is like 3rd party SSO (single sign on). Like for some applications, you can login with google or facebook. The application is pre-registered with the 3rd party, when a user login, it sends a request to 3rd party authentication server and gets a token, and once got the token, it will use that token to call the 3rd party authorization server to get the user role. [Learn more]
  For Authentication:
  - OAuth2 is a authorization method.
  - For other authentication, we can have AntMatcher to match the routes/paths and use hasRole to allow particular role to access it.
  Implementations:
  \t\tIn spring, we can override the WebSecurityConfigureAdaptor class, it is part of the security filter chain and it contains configure method, we will need to override the configure method and override the UserDetails object and UserDetailService class.
  
  “,
- “keyword”: “Security”,
- “frequency”: 0,
- “top”: true
“id”: 451,
- “question”: “What is micro frontend/ micro UI and how micro frontend communicate with each other”,
- “answer”: “
  1. micro frontend is just like microservcie in backend, it splits the frontend into multiple module based applications
  TO communicate
  1. Use parameter based URL to carry data
  2. Use events, one module emit events, another module subscribe to the events
  3. Use shared data store, like NgRx.
  “,
- “keyword”: “Angular”,
- “frequency”: 5,
- “top”: true
“id”: 30,
- “question”: “Can you talk about CI/CD?”,
- “answer”: “
  KeyPoints:
  1. CICD is continuous integration and continuous deployment. In the project, we usually use Jenkins with its pipeline scripts to implement CICD.
  2. The script contains multiple parts. The stages parts list each stage and the steps inside. For example, stage one is checkout and steps in this stage are like using git clone to checkout the code from repository and then use maven to package it etc. Another part of the script is post part which handles different result. For example, what to do when the build is success or failure, what to do when the test cases failed etc.
  3. CICD usually starts from when the code is pushed to the target branch, and then it includes checkout and package the code, deploy the jar/war, run the test cases and send reports etc. It could cover from dev to QA/Staging environment, but usually does not cover production.
  “,
- “keyword”: “CICD”,
- “frequency”: 5,
- “top”: true
“id”: 235,
- “question”: “How to use docker in the Spring Boot?”,
- “answer”: “
  Docker is a container with flexible memory management and has dockerHub that you can upload or download images
  To use with Spring boot, 1) include docker dependency 2) add a Dockerfile
  “,
- “keyword”: “Docker”,
- “frequency”: 2,
- “top”: true
“id”: 347,
- “question”: “ElasticSearch why do you use it”,
- “answer”: “
  Elastic Search is an engine to make search data very faster. It is usually put between backend application and database, it works like a cache or a database. Some people think it is a databse, but it is actually defined to only optimize search.
  ElasticSearch use index to cache out all the fields you want to search, just like the database Non-Cluster Index.
  For example, you have JSON:
```
Product{\n   id : 234323423434,\n   name : a complete guide to java,\n   description : This is a book as a complete description to java, it is mainly focused on java, spring, java 8, jdbc, spring framework. the author is intended to help any one with no or strong experience in java or any programming language, I am very long..,\n   many other fields\n}\n
```
  You can add the fields or the description texts as the index so you can search any text match in the name or description. It is very fast.
  “,
- “keyword”: “ElasticSearch”,
- “frequency”: 3,
- “top”: true
“id”: 41,
- “question”: “Git command you used in the project”,
- “answer”: “
  There are 2 common repositories working with git: Github and Bitbucket
  - Clone from repository as new project: git clone URL
  - Steps to commit change to remote repository: git add (files), git commit (-m message), git push
  - get remote data: git pull or git fetch (git fetch just read remote repository, git pull is git fetch + push to current local branch)
  - rebase and merge: git rebase, git merge
  - create a branch: git checkout branchName
  - delete a branch: git branch -d branchName
  - to override current branch with remote: git reset –hard remoteHead
  “,
- “keyword”: “Git”,
- “frequency”: 2,
- “top”: true
“id”: 370,
- “question”: “difference git merge and rebase”,
- “answer”: “
  Suppose you have 2 branches: f1 and f2 bot derived from main branch and both have some commits. now you are on f1 and you want the commits from f2.
  Merge: combine all commits from f1 and f2 as a new commit and put on f1. so merge will create a new commit.
  Rebase: your f1 is based on main, rebase is to let your f1 branch based on f2. it will make f2 as the new base for f1.
  link: https://www.atlassian.com/git/tutorials/merging-vs-rebasing
  “,
- “keyword”: “Git”,
- “frequency”: 2,
- “top”: true
“id”: 209,
- “question”: “How do you use cache in your whole project?”,
- “answer”: “
  Also refer to the problem of how do you improve performance
  Cache can be used directly based on different applications.
  Frontend, you can cache the page out, you can also cache the data out, so the whole page will be cached.
  Backend
  - Inside Java, you can use java native cache, just like static hashmap can cache data as key-value entries
  - For application level or microservices, you can use distributed cache, like Redis or MemCached.
  “,
- “keyword”: “System”,
- “frequency”: 3,
- “top”: true
“id”: 237,
- “question”: “Ways to connect to database”,
- “answer”: “
  1. JDBC - the basic way to connect to database, use statement/preparedStatement/callableStatement to run SQL direclty, use RestSet to host data. JDBC is the core for all other connections
  2. Hibernate - ORM framework. Use ORM so you dont need to write statement, SQL and ResultSet. Use Session and SessionFactory to do CRUD. Has 3 types of cache.
  3. Spring Data JPA - build on top of Java JPA. Use ORM framework as internal mapping tools and Use Naming Convention to do CRUD.
  “,
- “keyword”: “System”,
- “frequency”: 4,
- “top”: true
“id”: 40,
- “question”: “If you have error, but it is not showing in log, how do you debug and find it.”,
- “answer”: null,
- “keyword”: “System”,
- “frequency”: 4,
- “top”: true
“id”: 240,
- “question”: “What kind of test experience do you have?”,
- “answer”: “
  Unit test: Junit, mockito, powermock – test each method, this is method level. The way to write unit test is to define a hard code input and call the target method and then verify if the result is correct using assert.
  Automation test: Selenium, Cucumber, TestNG
  Regression test: is to make sure the new part of code does not break the existing functions
  Integration test: is to make sure the new parts interacts/works well with the other parts.
  End to End test: is to make sure the entire workflow works from beginning to end.
  
  Regression/Integration/End2End tests are just different type of tests, they are mostly implemented by Selenium and Cucumber or TestNG.
  “,
- “keyword”: “Test”,
- “frequency”: 5,
- “top”: true

“id”: 245,

“question”: “Cucumber and its annotations / How cucumber works, give an example”,

“answer”: “

When they ask what test framework have you done, always mention Junit/Mockito and Selenium/Cucumber

Cucumber aims to create tests cases that both business team and developers can understand. Business team knows the requirements but does not know how to write test cases, developer team knows how to write test cases but not very familiar with the requirements. Cucumber uses Gherkins language with feature file and step definitions script to connect them.

Feature file defines test scenarios like below, it uses keyword like scenario, given, when, and, then:

Feature: Login Functionality\n  Scenario: Successful login with valid credentials\n    Given the user is on the login page\n    When the user enters a valid username and password\n    And clicks the login button\n    Then the user should be redirected to the dashboard page\n

The step definitions file uses annotations like @Given @When @Then to write test cases. @Given is for given conditions, @When is for input @Then is for result.

For example for login, @Given is user is at the login page, @When is a method when user enters the credentials and click login, @Then will be a method to verify the user enters homepage.

these annotations use brackets to include the feature file steps

\n    @Given(the user is on the login page)\n    public void the_user_is_on_the_login_page() {\n        System.setProperty(webdriver.chrome.driver, /path/to/chromedriver);\n        driver = new ChromeDriver();\n        driver.get(https://example.com/login);\n    }\n\n\n    @When(the user enters a valid username and password)\n    public void the_user_enters_a_valid_username_and_password() {\n        driver.findElement(By.id(username)).sendKeys(validUsername);\n        driver.findElement(By.id(password)).sendKeys(validPassword);\n    }\n\n\n    @When(clicks the login button)\n    public void clicks_the_login_button() {\n        driver.findElement(By.id(loginButton)).click();\n    }\n\n\n    @Then(the user should be redirected to the dashboard page)\n    public void the_user_should_be_redirected_to_the_dashboard_page() {\n        String expectedUrl = https://example.com/dashboard;\n        String actualUrl = driver.getCurrentUrl();\n        Assert.assertEquals(actualUrl, expectedUrl);\n        driver.quit();\n    }\n}\n\n\n

“,

“keyword”: “Test”,
“frequency”: 5,
“top”: tru

Java

“id”: 43,
- “question”: “Abstract class vs. Interface. When to use abstract class and when to use interface?”,
- “answer”: “
  Abstract Class: 1) still a class, so you can only extend one abstract class. 2) Have both concrete method and abstract method.
  Interface: 1) you can implement many interfaces 2) Only has abstract method. 3) In java 8, interface can have default and static method
  Usage:
  Most of the places, interfaces are preferred, but if you need some common method to inherit automatically, you can use abstract class.
  
  FOLLOW UP:
  since java 8 allows default and static method in interface, what is the essential difference between abstract class and interface?
  A: abstract class can have fields, the fields can hold value and track the status of the object itself. Interface cannot have fields, it can only have constants.
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 44,
- “question”: “New feature of Java 8. Give an example of how you use them in your project”,
- “answer”: “
 Top of java 8 features:
 - Functional interface: is an interface that only has ONE abstract method. We can use lambda expression to implement that method
 - Lambda expression: () -> {}. It is to implement functional interface and anonymous class. You can pass a lambda function to a method as argument
 - Optional: to prevent NullPointerException in runtime. for example, Optional<Employee>, it has methods like isPresent(), isEmpty(), get(), orElse() etc.
 - Default method in interface:
 - Why need it: When a interface has 10 children classes, all children classes need the same method, before java 8, you need to implement this same method in every child class, but with default method, you just write it once as default method in interface, all children will automatically inherit it.
 - If a class implements 2 interfaces and both interfaces has same default method, then there will be exception because the class does not know which on to use, the class then has to override them.
 - Stream API: a group of methods to handle collections easily. like, filter, map, flatmap, sorted, reduce, groupingBy, joining etc.
 - Intermediate operator vs terminator operator
 - flatmap vs map
 - Java Date Time API update: new date time API has default timezone, so developer does not need to set it.
 “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 46,
- “question”: “Types of Exceptions and how do you deal with exceptions in your project?”,
- “answer”: “
  - Java Exception hierarchy:
  throwable – error + exception.
  error is like system error which can NOT be handled by program, like OutOfMemoryError, StackOverflowError etc.
  Exception – compile/checked exception + runtime/unchecked exception. Checked exception can be handled using try catch block, like the SQLException, Thread InterrupttedException; Unchecked exception happens in runtime, like NullPointerException, IndexOutOfBoundException etc.
  - self defined exception: Just extend the java Exception class and define your own constructor and message
  - How to deal with exception
  - Java: use Try/Catch/Finally block or use Throws on method level.
  - Spring: use @ExceptionHandler @ControllerAdvice on the controller level to catch exception in whole application
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 47,
- “question”: “Generics and how do you use generics in your project?”,
- “answer”: “
 Generics is used to prevent the error when converting data from one type to another type or just to make a method work for multiple type of data.
```
public V getFirstElement(List<T> list) {\n    return list.isEmpty() ? null : list.get(0);\n}\n
```
 Usually T is used to present Type and V is used to represent Value.
 With generics, we can 1) make sure the type is safe at compile time. 2) make a method or class work for different type of data.
 “,
- “keyword”: “Java”,
- “frequency”: 3,
- “top”: true
“id”: 48,
- “question”: “Java OOP 4 principles, and explain each of them”,
- “answer”: “
  PIEA:
  Polymorphism: 2 types, static polymorphism/overload and dynamic polymorphism/override. overload is you have 2 methods in the same class, they have SAME method name but different type or numbers of parameters . They can have different access modifier too (they are basically just 2 different methods happening to have the same name).
  Override: 2 methods with same method signature(method name, parameters) in Parent and Child class, but different implementations. The child method must have same or broader access modifier than parent method.
  Inheritance: One class can only inherit one parent class, one class can implement many interfaces
  Encapsulation: This is about who can access your method or fields, Access modifer: Public, Private, Protected, Default.
  Abstraction: abstract class and interfaces.
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 49,
- “question”: “If java 8 allows default method in interface, so what is the real difference between interface and abstract class?”,
- “answer”: “
  abstract class can have regular fields which can host the data, but interface cannot, interface can only have constants.
  “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 52,
- “question”: “Serialization, What is Serializable and SerialVersionUID?”,
- “answer”: “
  Serialization is to convert the java object into byte stream so you can save it to file system or database or send across network.
  To implement serialization, just implement serializable interface. private and final fields can be serialized, but static field cannot, because static field does not go with objects.
  When a serialVersionUID is presented, it is used to match the byte stream with current java object, if they match, the object can be de-serialized, otherwise, exception will be thrown.
  “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 53,
- “question”: “HashMap: how does it work internally, what is hash collision”,
- “answer”: “
  VERY IMPORTANT!!!
  HashMap has 2 key important methods, equals() and hashcode()
  Think there is a list of buckets, each bucket is identified by a hashcode.
  When you call get(key), the key will first be passed to hashcode() method and a hashcode is returned, Use this hashcode, you can locate the corresponding bucket. Inside that bucket, it is a tree structure of all key-value pairs that share the same hashcode. so to find the target key-value pair, the equals() method will be called, and once found, the value will be returned.
  Hash collision: all the key-value pair that shares the same hashcode stays in same bucket, that is called hash collision. It is preferred in hashmap, because if there is NO hash collsion, each key-value pair will stay in one bucket, then there will be too many buckets, causing too much memory. If all entries in one bucket, then it is hard to search the target. The hash collision makes the time complexity of hashmap to O(1) because of hashing.
  Why hashmap use Tree structure in bucket: Previously it is a list, but then changed to tree, because tree has left node smaller than root and root smaller than right. So the search is O(logn), much faster than list.
  
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 59,
- “question”: “What is the Functional Interface? Java 8 built in functional interface?”,
- “answer”: “
  Function interface is in java 8, it can only contain Single Abstract Method. You can use lambda to implement it.
  Java built-in function interface:
  Consumer: the method takes input but NO output. Example: System.out.println(input)
  Supplier: the method takes NO input but HAS output. Example: RandomNumberGenerator.
  Predicate!: the method return boolean type, true or false, it is widely used in stream().filter(predicate) to filter out collections
  Function: the method takes INPUT and RETURN output. it is used to convert data, like stream().map(function)
  Binary Operator: the method has 2 input and 1 same type output: like int add(int a, int b)
  there are other types, but you only need to anser, the top 4.
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true

“id”: 67,

“question”: “Implement a singleton”,

“answer”: “

REMEMBER THIS:

import java.io.Serializable;\n\n\npublic class Singleton implements Cloneable, Serializable {\n\n\n    private static Singleton instance;\n\n\n    private Singleton() {}\n\n\n    public static Singleton getInstance() {\n        if (instance == null) {\n            synchronized (Singleton.class) {\n                if (instance == null) {\n                    instance = new Singleton();\n                }\n            }\n        }\n        return instance;\n    }\n\n\n    @Override\n    protected Object clone() throws CloneNotSupportedException {\n        throw new CloneNotSupportedException(Cloning of Singleton is not allowed.);\n    }\n\n\n    protected Object readResolve() {\n        return getInstance();\n    }\n}\n\n\n

“,

“keyword”: “Java”,
“frequency”: 5,
“top”: true

“id”: 68,
- “question”: “Do you know about the Executor Service and Future?”,
- “answer”: “
  Executor Service has thread pool. It can be used run multi threads in parallel.
  Thread Pool:
  - Fixed Thread Pool: create fixed number of threads no matter you will use it or not
  - Cached Thread Pool: create threads based on needs, if new task is coming and no threads available, it will create new thread. If a thread idle for some time, it will be terminated.
  - Scheduled Thread Pool: can be used to set delays and schedule tasks
  - Fork Join Pool: It uses a work-stealing algorithm, the tasks are break into many small pieces. If some threads are done with their tasks, they can steal other threads task to run. This will have better performance.
  When the task has return (callable tasks)
  Use Future object to host the return. The tasks are like async process, they are submitted, and later on, if there is a return comes back, the return will be stored in Future object.
  Future has method like get() to get result or isDone() to check if task is completed.
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true

“id”: 69,

“question”: “Explain the Factory design pattern”,

“answer”: “

A factory is a method that if you pass an input, it can return the corresponding objects:

REAL PROJECT Example:

Credit card payment, if enter MasterCard, will return mastercard payment object, if enter Visa, will return visa payment etc.
Database Connection, if pass in oracle, will return oracle connection object, if pass mysql, will return mysql payment object.

Example:

public interface DatabaseConnection {\n    void connect();\n}\npublic class MySqlConnection implements DatabaseConnection {\n    @Override\n    public void connect() {\n        // Implementation details for connecting to MySQL\n    }\n}\n\npublic class PostgreSqlConnection implements DatabaseConnection {\n    @Override\n    public void connect() {\n        // Implementation details for connecting to PostgreSQL\n    }\n}\npublic class DatabaseConnectionFactory {\n    //driver method takes dbType and will get the corresponding type\n    public static DatabaseConnection createDatabaseConnection(String dbType) {\n        if (dbType.equalsIgnoreCase(MySQL)) {\n            return new MySqlConnection();\n        } else if (dbType.equalsIgnoreCase(PostgreSQL)) {\n            return new PostgreSqlConnection();\n        }\n        // Handle other database types or throw an exception for unknown types\n        throw new IllegalArgumentException(Unsupported database type: + dbType);\n    }\n}\n\n\n\n\n

“,

“keyword”: “Java”,
“frequency”: 4,
“top”: true

“id”: 70,
- “question”: “What design patterns did you worked on before?”,
- “answer”: “
  Singleton, Factory + One more (You pick the 3rd one, You need to know how to explain and how to write it)
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true

“id”: 71,

“question”: “How to custom an Exception?”,

“answer”: “

Just extend the Exception class

public class CustomException extends Exception {\n    \n    String message;\n\n    public CustomException(String message) {\n        super(message);\n        //other logic if needed.\n    }\n}\n

“,

“keyword”: “Java”,
“frequency”: 4,
“top”: true

“id”: 78,
- “question”: “What is Optional?”,
- “answer”: “
 Optional is introduced in java 8, to prevent null pointer exception.
 For example, if you have employee.getAddress().getCity(), in runtime, if employee is null, getAddress() will throw exception.
 Wen can use Optional<Employee>, optional has method like ifPresent(), isPresent(), get(), orElse() etc.
 “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 90,
- “question”: “ArrayList vs LinkedList, which one to choose?”,
- “answer”: “
  Structural: Arraylist has index and get(index) method. LinkedList: has only header and next pointer.
  For TIME complexity,
  if you know the index of target element in arraylist, arraylist is best O(1), if you dont know index, arraylist and linkedlist are the same O(n)
  For Space complexity,
  ADD element ArrayList is O(n) because you have to shift all elements after. But linkedlist is O(1) because you just change the pointer.
  
  “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 92,
- “question”: “Java 8: Intermediate operator and terminal operator in stream api”,
- “answer”: “
  Intermediate operator:
  - refer to operators that return another stream which can be appended by another operator. like stream().map(), the map is an intermediate operator because we can chain it with more operations.
  - Example: filter, map, sorted
  Terminal operator:
  - refer to final operators in stream api. We cannot append more operations after terminal operator.
  - Example: forEach, collect, count, findAny
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 95,
- “question”: “How do you create a thread?”,
- “answer”: “
  There are 2 ways: extend the Thread class or Implement the Runnable interface
  “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 104,
- “question”: “How does thread communicate/interact/share data with each other?”,
- “answer”: “
  Communicate/Interact:
  1. Wait() and Notify() method: wait() method will let current thread pause and release lock to other threads, this current thread will only be waken up and get lock if other threads call notify() or notifyAll().
  2. Executor service in java concurrent package can interact threads, like the WorkStealingPool use join and fork to interact between threads to improve performance. CompletableFuture also can chain threads.
  If asking how to share data between threads:
  1. Let threads visit same data memory, like same object, same database table, same file or cache
  2. Use message queues. one thread sending data, another thread consume data
  “,
- “keyword”: “Java”,
- “frequency”: 3,
- “top”: true
“id”: 106,
- “question”: “What are the meaning of thread methods: join, wait, sleep, yield”,
- “answer”: “
  JOIN: to let current thread wait until another thread finishes. So it is used to let threads run in order.
  WAIT: wait is to RELEASE lock and let other threads run. this thread will resume only when other threads call notify(), notifyAll()
  SLEEP: this thread will NOT RELEASE the lock, it lets current thread to sleep for given time and then it will restart by itself. Different from wait method, the sleep will not release lock and will resume by itself.
  YIELD: if some threads share the same priority, yield method is to hold current thread and let others run first.
  “,
- “keyword”: “Java”,
- “frequency”: 3,
- “top”: true
“id”: 117,
- “question”: “What is ConcurrentModificationException and how to handle it?”,
- “answer”: “
  ConcurrentModificationException is thrown when you have multiple threads try to modify the NON-thread-safe java collections, like ArrayList, HashSet, HashMap etc.
  To handle:
  1. When modify collection, like remove element, using Iterator instead of for loop.
  2. Use thread safe collection, like CopyOnWriteArrayList, ConcurrentHashMap, CopyOnWriteHashSet etc.
  “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 118,
- “question”: “Relationship between equals() and hashcode()”,
- “answer”: “
  In HashMap, when you do a get(key) call, first key is passed to hashcode() to locate a bucket, and then inside bucket, call equals() to find the entry.
  HashCode() and Equals() should use exactly the same object fields.
  1. If two objects are equal according to the equals() method, they must have the same hash code (equal objects must produce equal hash codes).
  2. However, the reverse is not necessarily true: two objects with the same hash code may or may not be equal.
  “,
- “keyword”: “Java”,
- “frequency”: 3,
- “top”: true
“id”: 119,
- “question”: “How to make class immutable?”,
- “answer”: “
  Immutable means it cannot be changed. So we should prevent all ways to change a class and its object
  - make class final, public final class ..so we cannot extend and modify it
  - make fields private, so we cannot modify it directly from outside
  - Do NOT provide setter method.
  - in the get method, don’t return fields directly, return copy of the fields.
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 121,
- “question”: “What is the deadlock? How to FIND it? How to avoid it?”,
- “answer”: “
  Deadlock is when you have 2 threads, Thread1 is waiting Thread2 to release lock on an object while Thread2 is waiting for Thread1 to release lock on an object. They are waiting on each other.
  To find:
  use Thread dump, thread dump is like to take a snapshot/photos of all current threads, so it will show if there are deadlocks.
  JProfiler/FastThread/JStack are all tools can show thread dump.
  To prevent:
  1) For all shared objects/resources by both threads should be combined as a whole entity and should be locked together.
  2) Set global orders for the shared objects, so that threads will only lock them in same order.
  “,
- “keyword”: “Java”,
- “frequency”: 3,
- “top”: true
“id”: 132,
- “question”: “What is fail-fast and fail-safe?”,
- “answer”: “
  Fail-Fast: detects the possible failures before it happens. Like when you loop element of HashMap and try to remove it. It will fail fast with ConcurrentModificationException
  Fail-safe: Use the data structure that can handle ConcurrentModificationException by itself, so it will not throw exception, like when loop and remove elements from ConcurrentHashMap.
  “,
- “keyword”: “Java”,
- “frequency”: 3,
- “top”: true
“id”: 135,
- “question”: “Map vs. FlatMap”,
- “answer”: “
  In Java 8 stream api.
  Map is to convert data, it takes a function as input.
  FlatMap is Map + Flat. It can handle 2 dimensional matrix, and apply Map on each row and then Flat each row result into a final 1 dimensional array.
  “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 139,
- “question”: “why using static and why not?”,
- “answer”: “
  What: static is a keyword to make sure there is only 1 copy of the resource. like static field, static method or static inner class
  For What: static resources can be shared across whole applications, like use static block so initalize some global data. Static method can be used as helper or util methods, we can just call Class.StaticMethod so we dont need to create instances.
  Why Not: Static object will not be garbage collected. They will stay in memory forever. Too many static objects can cause memory leak.
  “,
- “keyword”: “Java”,
- “frequency”: 3,
- “top”: true
“id”: 296,
- “question”: “Difference: Synchronized, ThreadLocal, Volatile, AtomicInteger”,
- “answer”: “
  Synchronized: it is to make resource thread safe in multi-threading environments, can be used on block of code OR method. If we have Employee object and it contains another address object and updateEmployee() method. If we put synchronized on the method, it will lock the whole employee object. If we use synchronized(address) in the code, it will only lock the address field, will not lock whole employee object, So the synchronized block has better performance.
  ThreadLocal: If a variable is defined as ThreadLocal, then when a thread gets this variable, it will gets its own copy, so when this thread update this variable, it only updates its own copy, the other copies used by other threads will not be affected.
  Volatile: If a variable is volatile, it is kept at a core main memory. All threads will only read and update this main copy. They will not have their own copy. All threas share exactly the same main copy. It guarantees that if one thread updates the value, the other threads will get that updated value because there is only 1 copy.
  AtomicInteger: AtomicInteger/AtomicBoolean/AtomicReference etc: the ‘atomic’ is to make sure the operations on the variable is a single operation and cannot be splitted further. It is typically used as a Global Counting and prevent thread race conditions.
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 303,
- “question”: “How does string works? Why is String immutable in Java?”,
- “answer”: “
  String is immutable in java, means once you create a string object, you cannot change it anymore. If you want to use mutable string, use StringBuilder instead.
  
  How string memory works:
```
String s1 = abc;\nString s2 = new String(abc);\nString s3 = abc;\nString s4 = new String(abc);\nString s5 = abc.intern();\n
```
  In memory, there is a constant pool which only stores the quoted string, like abc, it will not have duplicates in this constant pool. So when we create s1, it goes to constant pool. S2 is created by new String() constructor, whenever we call this constructore, we create a separate copy in the heap memory, not in the constant pool. For intern() method, it will check if the constant pool has a copy, it will use it, if not, it will create one copy in the constant pool,.
  So s1 == s3 == s5 != s2 != s4
  
  Why is string immutable:
  1. So we can use it in many places, like as Map key.
  2. We can use it for security reasons, like store passwords or keys
  3. It will be thread safe, multi-thread cannot change the value.
  4. We can use for caching and hashing.. like as the Cache key or used in other APIs.
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 330,
- “question”: “New features in java 11 and 17”,
- “answer”: “
  Java 11
  1. Local variable in lambda expression. Not you can use var to define local variables in java 11.
  2. New Garbage Collector: like Epsilon (for testing) and ZGC for low-latency and large heap system.
  Java 17:
  1. Sealed Class: Use sealed keyword to control which class can be subclass of this class. Use permits keyword to allow subclass.
```
sealed class Shape permits Circle, Rectangle, Triangle {\n    // Common methods and properties for all subclasses\n    abstract double calculateArea();\n}\n
```
  1. Hidden Class: which can not be seen by java reflection.
  2. Text Blocks: allow you to use text like long strings.
  “,
- “keyword”: “Java”,
- “frequency”: 3,
- “top”: true
“id”: 343,
- “question”: “Suppose when you have Employee class to store data, when do you use list or map”,
- “answer”: “
  1) List can have duplicates and it is just to store all information. Map is key value pair, key must be unique
  2) In application, if you just want to show all employees in json format, you can use list; but if you want to show list of employee Ids and if you click the Ids it will display the whole employee json, so it is like you need a id –> employee association, then you can use map.
  “,
- “keyword”: “Java”,
- “frequency”: 2,
- “top”: true
“id”: 344,
- “question”: “Difference: Arraylist vs LinkedList, when to use which”,
- “answer”: “
  READ:
  - ArrayList: is usually faster because it has index. It can be O(1), or worst O(n) if you dont know index
  - LinkedList: is slower because you have to traverse from header, so it is always O(n)
  ADD/REMOVE
  - ArrayList: is usually slower because when you add element, you have to shift all elements after it. So it is O(n)
  - LinkedList: is faster because you just change the pointer, O(1)
  INTERNAL IMPLEMENTATION:
  - ArrayList: implemented by dynamic Array, Need less space because it only need to store value and index
  - Linkedlist: double linkedlist, with value and pointers. Need more space to store, value, left and right pointer
  WHICH ONE:
  - If your app need more READ, less ADD/REMOVE, then linkedlist is good
  USE CASE:
  - ArrayList: for example to store a list of objects
  - Linkedlist: to store object where you just need previous or next value, like browser history or stack.
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 364,
- “question”: “Difference future vs completableFuture”,
- “answer”: “
  When you submit a task to executor service, it returns a future.
  CompletableFuture is advanced version of future.
  1) It has method like thenApply, thenCombine etc. so you can build thread chain.
  2) it has handle and whenComplete method, which you can handle exception with it.
  “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 371,
- “question”: “JDK vs JRE vs JVM”,
- “answer”: “
  JDK is for developer to write java code, it can compile the java code to binary class code and also it has debug mode.
  JRE is a java running environment, if you want to run java application, you have to have JRE installed.
  JVM: java virtual machine, is to mange java memory, like heap, stack, metaspace etc.
  “,
- “keyword”: “Java”,
- “frequency”: 2,
- “top”: true

“id”: 373,

“question”: “How do you implement a deadlock”,

“answer”: “

public class ThreadLock\n{\n    final static String R1 = Hello Welcome to Pilot!;\n    final static String R2 = Visit Pilot!;\n\n\n    public static void main(String[] args)\n    {\n    \t    // creating thread T1\n \t    Thread T1 = new Thread(){\n                // implementing run method\n \t\tpublic void run(){\n\n\n \t            // thread T1 locking the R1 resource\n \t\t    synchronized (R1){\n \t\t        System.out.println(Thread T1 locked -&gt;&nbsp; &nbsp;Resource R1);\n\n\n \t\t        // thread T1 locking the R2 resource\n \t\t\tsynchronized (R2){\n \t\t\t    System.out.println(Thread T1 locked -&gt; Resource R2);\n \t\t        }\n \t\t    }\n \t\t}\n \t    };\n\n\n \t    // creating thread T2\n \t    Thread T2 = new Thread(){\n \t\t// implementing run method\n \t\tpublic void run(){\n\n\n \t\t    // thread T2 locking the R2 resource\n \t\t    synchronized (R2){\n \t\t        System.out.println(Thread T2 locked -&gt; Resource R2);\n\n\n \t\t\t// thread T2 locking the R1 resource\n \t\t\tsynchronized (R1){\n \t\t\t        System.out.println(Thread T1 locked -&gt; Resource R1);\n \t\t\t}\n \t\t    }\n \t\t}\n \t};\n\n\n \t// starting both the threads\n \tT1.start();\n \tT2.start();\n    }\n}\n\n\n

“,

“keyword”: “Java”,
“frequency”: 4,
“top”: true

“id”: 374,

“question”: “Synchronized method vs Synchronized block”,

“answer”: “

public class UserService{\n    private Address address;\n    private String username;\n\n    public static synchronized void lockUserServiceClass(){\n       //synchronized method is to lock whole object, but since this method is static, it only stays in the class\n       //so static synchronized will lock the class, not the created objects/instances\n    }\n\n    public synchronized void lockUserServiceInstance(){\n       //this method will lock the entier userService Instance\n    }\n\n    public void lockBlock(){\n       synchronized(address){\n         //here only lock the address object, not the whole instance, performance is best\n       }\n    }\n}\n

“,

“keyword”: “Java”,
“frequency”: 3,
“top”: true

“id”: 454,
- “question”: “What is Java 17 new feature - sealed class？”,
- “answer”: “
  Java sealed class defines who can extend this class, so it adds more restrictions on class inheritance.
  Key things:
  1. it uses sealed and permits to define who can extend this sealed class
  2. the permitted children classes HAVE TO be in the same package as parent class
  3. Children classes MUST be decorated with one of three keywords: sealed, non-sealed, final..
  4. the sealed child class can be further extended by permitted children
  5. the non-sealed child class can be extended by another class
  6. the final child class cannot be extended by any children class
```
public sealed class Vehicle permits Truck, Sedan, SUV {…}\n\n//same package\nsealed class Truck extends Vehicle permits PickupTruck {…}\nnon-sealed class Sedan extends Vehicle {…}\nfinal class SUV extends Vehicle {…}\n
```
  “,
- “keyword”: “Java”,
- “frequency”: 5,
- “top”: true
“id”: 455,
- “question”: “What is difference between synchronized and ReentrantLock?”,
- “answer”: “
  Java has two types of locks, implicit and explicit. Synchronized is implicit lock which java controls everything, as a developer, we just add synchronized keyword. ReentrantLock is explicit lock which we have more control on the locked object.
  Things we can do with ReentrantLock:
  - TryLock – a thread can try lock object, if it returns true, it will acquire lock, otherwise, it will keep waiting
  - Fair Lock – if there are many threads waiting, for Fair lock, the longest waiting thread will get the lock, FIFO order. ReentrantLock rl = new ReentrantLock(true);
  - Lock Interrupt – thread can try to interrupt the lock
  - access count – It can count how many times a thread has gain access. Count can increase and decrease, when it decrease to 0 means the thread unlocked the object.
```
class Test\n{\n    private static int count = 0; \n  \n    private static ReentrantLock lock = new ReentrantLock();\n\n    public static void increment()\n    {\n        lock.lock();  //lock it\n        try \n        {\n            count++;\n        }\n      \n      finally\n         { \n            lock.unlock();  //need to release the lock\n         }\n    }\n
```
  “,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true
“id”: 448,
- “question”: “What is proxy design pattern”,
- “answer”: null,
- “keyword”: “Java”,
- “frequency”: 4,
- “top”: true

Kafka

“id”: 143,
- “question”: “Did you use Kafka in your project? How does it work?”,
- “answer”: “
  Kafka has 3 parts, Producer, Cluster/Broker, Consumer (!DO NOT READ AS CUSTOMER!)
  Producer send message (has topic) to broker
  Broker has topics, each topic has several partitions, the messages are send to these partitions.
  Consumer belongs to one consumer group, they will read the message from partition.
  “,
- “keyword”: “Kafka”,
- “frequency”: 5,
- “top”: true
“id”: 149,
- “question”: “Talk about Kafka and Zookeeper”,
- “answer”: “
  In Early version of Kafka, Zookeeper is like manager, it managers the metadata, like which broker is the leader and the offset tracking.
  In new Kafka version, it uses Raft consensus algorithm for leader election. So it does not need Zookeeper.
  “,
- “keyword”: “Kafka”,
- “frequency”: 3,
- “top”: true
“id”: 334,
- “question”: “How to prevent data loss in kafka”,
- “answer”: “
  There are 3 parts of Kafka, all 3 parts need to prevent data loss.
  Producer: when producer sends message to broker, the broker will send a status back to producer if the message is received, if not received, producer will keep sending the same message again and again.
  Broker: Each partition has K replications/backups, there is a parameter ACKS (acknowledgement), ACKS = 0 means broker will not tell if the message is received, so if there broker is down, then it is lost. ACKS = 1 means if the message is received by leader partition, but not yet received by replications, it will tell producer the message is received, so when ACKS = 1 and the leader broker is down, the message will be lost. ACKS = ALL means only when all replications of partitions receive the message and then the producer will be notified. ACKS = 0/1 could cause message loss, but ACKS = ALL will slow down performance.
  Consumer: enable.auto.commit is a configuration that let consumer auto commit the offset, once auto commit, the message is considered read by consumer successfully. But if the consumer has some error, it may cause the read failure. so we can set enable.auto.commit = false and manually commit the offset.
  “,
- “keyword”: “Kafka”,
- “frequency”: 5,
- “top”: true
“id”: 335,
- “question”: “How to keep message order in Kafka”,
- “answer”: “
  Key: message in one partition is consumed in order. So to make message in order, we just need to send them to same partition. In kafka, each message has an id, if you don’t give id, kafka will assign auto generated id, Kafka use hashing to convert this id to hashcode which is corresponding the partition. (just like hashmap hashcode and bucket). So to make message in order, we need to assign same message ID to them, like if it is order message, we can use order id, if it is like transaction messages, we can use transaction id.
  “,
- “keyword”: “Kafka”,
- “frequency”: 5,
- “top”: true
“id”: 336,
- “question”: “How to prevent duplicate message in kafka”,
- “answer”: “
  Kafka has consumer and producer. To prevent duplicate, we should try on both side [reference]
  Producer:
  - Kakfa has many producers and each producer can send many messages, to make each message unique, we need to assign producer an ID and each message an ID, so the producer ID + message ID combination will be unique.
  Consumer:
  - enable.auto.commit should be set to false. enable.auto.commit = true means kafka will auto commit the offset even if consumer failed to process the message, this could cause message loss.
  - Consumer has 2 ways to prevent duplicate messages, 1) it can check the message unique id, if found that id is already processed, it will ignore it. 2) it can make its opreation idempotent, just like put, update once and twice will yield same results.
  One more thing, if each message is sent only once, but the consumer is down, then we could have message lost, so we need to configure auto.offset.reset, this is a parameter to decide when consumer is down, whether we should restart reading from last failed position (latest - default) or beginning of the partition (earliest).
  “,
- “keyword”: “Kafka”,
- “frequency”: 5,
- “top”: true
“id”: 345,
- “question”: “Kafka how to let two consumers read the same message”,
- “answer”: “
  Put them in different consumer group.
  In kafka, consumers in same group can only read different partitions - that is why the number of consumers cannot be more than number of partitions in each group. But consumer in different group can read the same partition.
  “,
- “keyword”: “Kafka”,
- “frequency”: 2,
- “top”: true
“id”: 359,
- “question”: “How to implement security to kafka. Kafka Security”,
- “answer”: “
  1. Broker authentication: Add authentication for kafka broker, only authenticated applications can connect to kafka brokers.
  - We can use SASL (Simple authentication and security layer) to implement it, SASL supports secure authenticaiton like PLAIN, SCRAM. SASL is a tool to add security to many network protocols, like LDAP, SMTP, IMAP etc.
  1. Data Encryption: Add encryption to broker so that data sent in and out of kafka brokers are encrypted.
  - We can use SSL/TLS to encrypt data. To add SSL certificate to kafka. We can first use openSSL to create a certificate and then use keytool to create a truststore and add the certificate to it. We also need to configure kafka to use the SSL certificate like security.portocol=SSL
  1. Maintain a Access Control List (ACL) to specify which user or group can access which topic or partition.
  “,
- “keyword”: “Kafka”,
- “frequency”: 4,
- “top”: true
“id”: 450,
- “question”: “What is kafka dead letter queue and how do you handle it?”,
- “answer”: null,
- “keyword”: “Kafka”,
- “frequency”: 4,
- “top”: true

Microservice

“id”: 146,
- “question”: “How can you make services communicate with each other? -> Tools like Spring Cloud to setup microservice or use message queue like Kafka”,
- “answer”: “
  There are two ways to communicate between services, sync and async
  Sync: RestTemplate/RestClient – when service 1 call rest api of service 2, service 1 will have wait for the return from service 2, so this is sync communication.
  Async: message queue like Kafka – service 1 as producer sends message to kafka cluster, service 2 as consumer subscribes from kakfa cluster.
  “,
- “keyword”: “Microservice”,
- “frequency”: 5,
- “top”: true
“id”: 152,
- “question”: “How to use the Zuul Gateway API? / How does the Zuul Gateway API work?”,
- “answer”: “
  Zuul API Gateway is to distribute the traffic do a particular service.
  For example, Amazon has 3 services, order service is at localhost:8070, payment service is at localhost:8080, delivery service is at localhost: 8090. You don’t want to expose all 3 different addresses to customers. So you add one API Gateway like at localhost:9000. Customers only access to API Gateway. API will redirect to different services based on the URL. For example, localhost:9000/order will be redirected to order service, localhost:9000/payment will be redirected to payment service, localhost:9000/delivery will be redirected to delivery service.
  To set API Gateway, we need Zuul gateway server, all the other services should register the zuul gateway server in their application.properties.
  “,
- “keyword”: “Microservice”,
- “frequency”: 4,
- “top”: true
“id”: 153,
- “question”: “How to manage the entire transaction across different microservices? How to rollback?”,
- “answer”: “
  Saga Pattern
  Saga Orchestration Pattern is a design pattern to manage global transaction across multiple microservices based on message queue.
  For example, if you make one order which involves Order Service, Payment Service and Delivery Service as one transaction. In saga orchestration pattern, you will need one command center service, like Command Service which works as a communication center for all the services.
  When order service is completed, it sends a completion message to command center, the command center received and send a message to payment service, the payment service will process payment and send complete message to command service, the command service received payment completion message and send message to delivery service and once delivery is done, it tells command service and command service will mark the entire transaction as completed.
  When there is error, the transaction will be rolled back in reverse order. For example, if delivery service failed, it sends failure message to command service, the command service will tell payment service to rollback payments, once payment service completes the rollback and tells the command service, the command service will ask the order service to rollback. It goes this way until the entire transaction is rolled back.
  “,
- “keyword”: “Microservice”,
- “frequency”: 5,
- “top”: true
“id”: 191,
- “question”: “How to communicate between microservices”,
- “answer”: “
  Sync: use RestTemplate or FeignClient
  Async: use message queue, like Kafka, ActiveMQ, RabbitMQ etc
  “,
- “keyword”: “Microservice”,
- “frequency”: 5,
- “top”: true
“id”: 157,
- “question”: “Suppose you have two Eureka servers, how does each application know which Eureka server it is registered to?”,
- “answer”: “Every application doesn’t register only to a single Eureka server. It registers with all the servers that are configured. And these servers replicate data between each other. You can check the logs, look at the Eureka dashboards, or query the registration status in your code to find out which server the app initially registered with.”,
- “keyword”: “Microservice”,
- “frequency”: 0,
- “top”: true
“id”: 158,
- “question”: “What is the circuit breaker?”,
- “answer”: “A circuit breaker is a design pattern used in distributed systems to handle failures gracefully and prevent cascading failures. It’s a kind of protection. When a service is failing, it stops requests to that service for a while, giving the service time to fix itself. and it usually has three status, like 1. Closed: Requests go as usual, but we watch for failures. If too many failures happen, it turns to Open.2. Open: Requests don’t even try the service and just fail right away. After a break, it changes to Half - Open. 3. Half - Open: We let a few test requests through. If they work, it goes back to Closed. If not, it stays Open. “,
- “keyword”: “Microservice”,
- “frequency”: 0,
- “top”: true
“id”: 159,
- “question”: “How does microservices communicate with each other?”,
- “answer”: null,
- “keyword”: “Microservice”,
- “frequency”: 0,
- “top”: true

Database

“id”: 352,
- “question”: “How do you decide which database to choose, SQL or NoSQL”,
- “answer”: “
  Several Main difference
  - 1. SQL: only have pre-defined structure schema/data, it is table based.
  - 1. NOSQL: unstructure data, like MongoDB can store PDF/audio/video/text/json data easily. Cassandra is column based, you can easily expand the columns
  - 2. SQL: based on ACID rules, designed to handle transactions.
  - 2. NOSQL: based on CAP theorem, not good for transactions.
  - 3. SQL: traditional database with SQL, not designed for big data
  - 3. NOSQL: designed for big data, have partitions.
  “,
- “keyword”: “NoSQL”,
- “frequency”: 0,
- “top”: true
“id”: 290,
- “question”: “Explain CAP theorem and which database use them”,
- “answer”: null,
- “keyword”: “NoSQL”,
- “frequency”: 0,
- “top”: true
“id”: 376,
- “question”: “What is sharding in MongoDB?”,
- “answer”: “
  Sharding is to split the dataset into multiple partitions. For example, if you have data from 1 to 10 million, you can store the id from 1 to 1 million as first shard, 1 million to 2 million as 2nd shard etc.
  “,
- “keyword”: “NoSQL MongoDB”,
- “frequency”: 4,
- “top”: true
“id”: 377,
- “question”: “How replication works in MongoDB”,
- “answer”: “
  To prevent the data loss, MongoDB set replication of the nodes.
  like if you have 20 shards, the 1st shard is in Virginia, MongoDB can make 2 replications (copies) of this node and put them in Ohio and California so if Virginia server is down, the other 2 replications will back up.
  “,
- “keyword”: “NoSQL MongoDB”,
- “frequency”: 1,
- “top”: true
“id”: 162,
- “question”: “Design a Employee Voting system according to the requirements”,
- “answer”: null,
- “keyword”: “OOD”,
- “frequency”: 0,
- “top”: true
“id”: 166,
- “question”: “Basic principles of the OOP”,
- “answer”: null,
- “keyword”: “OOP”,
- “frequency”: 0,
- “top”: true
“id”: 31,
- “question”: “Different type of Joins”,
- “answer”: “
  Supposed you have table A 100 records, table B 50 records, they match by 20 records
  1. Inner/Equi Join: the match part (like: where a.id = b.ta_id), should be 20 records
  2. Left Join : match plus remaining of left side table, if A left join B, then return 100, if B left join A, then return 50
  3. Right Join, match plus remaining of right side table. A left join B = B right join A
  4. Full Outer Join: match plus remaining of A and B, 20 + 80 + 30 = 130
  5. Cross Join: Each row of A join Each row of B: 100 * 50 = 5000
  6. Self Join: A self Join A, treat as 2 tables, A1, A2, so A self join is like A1 join A2
  “,
- “keyword”: “SQL”,
- “frequency”: 5,
- “top”: true
“id”: 33,
- “question”: “Write a query: find the most popular product of one month”,
- “answer”: “
  Analysis:
  most popular –> appear most times –> max count –> find count and order, GROUP BY always needed for aggregate function
```
SELECT p.name, count()\nFROM product p\nWHERE p.month = ‘GivenMonth’\nGROUP BY p.name.  //group by name –count by name, field must appear in select caluse\nORDER BY count() DESC //order in desc of count\nLIMIT 1 // just find top1\n
```
  “,
- “keyword”: “SQL”,
- “frequency”: 0,
- “top”: true
“id”: 35,
- “question”: “Is the primary key unique? Difference between the primary key and unique key”,
- “answer”: “
  Primary Key must be Unique. Unique key may not be primary key
  For example, User table, UserID is primary key, it must be unique. UserEmail and SSN are also unique, but it is not primary key
  “,
- “keyword”: “SQL”,
- “frequency”: 2,
- “top”: true
“id”: 38,
- “question”: “Explain the ACID concepts”,
- “answer”: “
  ACID is the design principle for SQL relational database.
  A: atomicity: means every transaction to database should be atomic, should be as a whole operation. If there is any failure inside, the whole transaction should rollback.
  C: Consistency. Data should be consistent. It should not violate any rules of the database constraints.
  I: Isolation, it refers to the isolation level, like READ_COMMITTED, READ_UNCOMMITED. The READ_COMMITTED level means you can only read the data that is already committed.
  D: durability: when there is system crash or node failure, the data should still be available.
  “,
- “keyword”: “SQL”,
- “frequency”: 5,
- “top”: true
“id”: 39,
- “question”: “What kind of database did you use and how do you communicate with the DB”,
- “answer”: “
  Ways to communicate with database: JDBC, JPA, HIBERNATE, MYBATIS etc
  “,
- “keyword”: “SQL”,
- “frequency”: 5,
- “top”: true
“id”: 355,
- “question”: “Find the 2nd largest salary in employee table”,
- “answer”: “
 SOLUTION 1 (best for highest, 2nd highest, not good for 3rd, 4th etc, need to understand subquery)
```
SELECT MAX(salary) FROM employee WHERE salary < (SELECT MAX(salary) FROM employee);\n
```
 SOLUTION 2: (best for Kth highest. need to understand OFFSET, LIMIT)
```
SELECT DISTINCT salary FROM employee ORDER BY salary DESC OFFSET 1 LIMIT 1\n
```
 “,
- “keyword”: “SQL”,
- “frequency”: 0,
- “top”: true
“id”: 356,
- “question”: “Find employee whose salary is higher than its own manager (only given employee table which contains employee id and its manager id)”,
- “answer”: “
  Employee (id, name, salary, managerId)
  KEY: we need to get employee salary and manager salary from same table, it is SELF JOIN, when do SELF join, we can always treat Employee as 2 tables, employee and manager
```
SELECT emp.name\nFROM employee emp\nJOIN employee mgr\nON emp.managerId = mgr.id\nWHERE emp.salary > mgr.salary;\n
```
  “,
- “keyword”: “SQL”,
- “frequency”: 0,
- “top”: true
“id”: 316,
- “question”: “SQL how to delete duplicate rows, only keep unique rows”,
- “answer”: null,
- “keyword”: “SQL”,
- “frequency”: 0,
- “top”: true

SpringBoot

“id”: 12,
- “question”: “How do you config for multiple environments?”,
- “answer”: “
  1. In spring boot, we can define different profiles for different environments, like DEV, QA/Staging, PROD etc.
  2. We can have application-dev.propeties, application-staging.properties, application-prod.applications, when we run the application, we just need to set the active profile to corresponding env.
  3. In microservice, we can also use Config Server, which we can config the different profiles and put them in server hardware or in code repository and use active profile to refer to it. The benefit is we can track the version of the files.
  “,
- “keyword”: “Spring Boot”,
- “frequency”: 5,
- “top”: true
“id”: 196,
- “question”: “Why do you use Spring Boot? / Benefits of Spring Boot”,
- “answer”: “
  Top 1 question in spring boot.
  Spring boot has many benefits, the top 4 are like:
  1. Embedded Server: spring boot has Web starter which contains the tomcat or Jetty server, you dont need to deploy the application, it is auto-deployed by one click or one command line. You just run your whole application with server together as a JAR file
  2. Auto Configuration: Spring boot has auto configuration, as long as you put the properties there, spring boot will auto setup everything. Example, if you have Data Source entries in the application.properties file, Spring boot will try to auto connect the database for you.
  3. Dependency Management: Spring boot wraps up related dependencies into starters, like the Web Starter contains json, rest api, mvc model, server etc. You don’t need to add them to POM.XML separately, also you dont need to worry about the version conflicts in the dependencies.
  4. Actuator: Spring boot provides actuator which has many endpoints to tell the status of the spring boot application. Like: /info is to tell the status, /health summarizes the health status of our application. /metrics details metrics of our application. This might include generic metrics as well as custom ones.
  Disadvantage:
  Spring boot wrap too many things in the box, so many things are in under the cover.
  “,
- “keyword”: “Spring Boot”,
- “frequency”: 5,
- “top”: true
“id”: 220,
- “question”: “How to start a Spring Boot project?”,
- “answer”: “
  Several Steps in order:
  1. Go to spring initializer, fill information like Java Version, Build Tool Maven, enter project name description, Package type as Jar or War
  2. Choose Starters, like Web Stater, Spring Data Starter, Security Starter etc
  3. generate the project and download the zipfile
  4. Unzip and import into IDE as new project.
  “,
- “keyword”: “Spring Boot”,
- “frequency”: 5,
- “top”: true
“id”: 228,
- “question”: “What does @SpringBootApplication mean?”,
- “answer”: “
  3 Key Things included in this application
  @ComponentScan: will scan all beans at current level or lower level, this is why the @SpringBootApplication is on top of a main class that is higher than all other classes, so that it can scan all beans
  @AutoConfiguration: will let spring boot auto configure. For example, if you have put datasource in the application.properties, spring boot will auto connect for you. If you dont want auto configuration, use Excludes=XXX.Class to exclude that particular configuration
  @Configuration: means this is a configuration class.
  
  “,
- “keyword”: “Spring Boot”,
- “frequency”: 5,
- “top”: true
“id”: 234,
- “question”: “For Spring Boot, how do I use another server such as WebLogic instead of the embedded Tomcat server?”,
- “answer”: “
  Some configurations needed:
  1. add Exclusions in POM.XML to exclude the embedded tomcat and jetty server
  2. need to add JNDI in the application.properteis for the new server (such as weblogic)
  3. the main class needs to extend the SpringBootServletInitializer
  4. Change package in POM.XML from JAR to WAR.
  “,
- “keyword”: “Spring Boot”,
- “frequency”: 4,
- “top”: true
“id”: 350,
- “question”: “Difference between Spring boot and Spring”,
- “answer”: “
  1. Spring boot use starter to manager dependencies, like Web Starter has MVC, REST, JSON, TOMCAT, IOC etc all included in one web starter. You dont need to worry about dependency conflicts.
  2. Spring boot has tomcat in web starter by default, so you dont need to package and deploy to tomcat. You can just run it directly or package it as JAR file and run it everywhere.
  3. Spring boot put everything in annotation by default, you dont need to write a lot code as in Spring.
  4. Spring boot add auto configuration, like if you put datasource in application.properties file, it will auto connect for you. You dont need to write the java connection code.
  5. Spring boot provide actuator which you can use to measure the metrics of the applications, like /info, /heath etc to tell the metrics, it is very useful in microservice environments.
  “,
- “keyword”: “Spring Boot”,
- “frequency”: 0,
- “top”: true
“id”: 447,
- “question”: “How to do cache in spring boot and how to refresh the cache”,
- “answer”: “
  We can use @Cachable on a method to make the returned object
  “,
- “keyword”: “Spring Boot”,
- “frequency”: 4,
- “top”: true

SpringCore

“id”: 174,
- “question”: “Spring Annotation you used in your project?”,
- “answer”: “
  @Controller, @RestController, @RequsetMapping @GetMapping @PutMapping @PostMapping @DeleteMapping
  @PathVariable @RequestParam
  @Autowired, @Qualifier
  @Service @Repository @Componenet
  
  “,
- “keyword”: “Spring Core”,
- “frequency”: 5,
- “top”: true
“id”: 176,
- “question”: “What is IoC/Dependency Injection?”,
- “answer”: “
  That is the most basic module of spring. Without spring, if you want to use another bean in one class, you have to create instance by yourself by calling the constructor. But with spring, you dont need to do that, you just use @component or @bean and other spring annotations to let spring manage the beans for you, so spring has a bucket called bean factory, it manages all the beans there for you, if you need to inject a bean, you just use @autowired, spring will find the instance and wire it for you. So you are giving the control of creating instance to spring, that is why it is also called inversion of control.
  
  “,
- “keyword”: “Spring Core”,
- “frequency”: 5,
- “top”: true
“id”: 177,
- “question”: “What is AOP and how do you implement AOP in the project?”,
- “answer”: “
  AOP - Aspect oriented programming, is to interfere with main application execution.
  Aspect: @Aspect is to mark a class as AOP class which contains AOP annotations and methods
  Pointcut: an expression to find all the main application package or methods to apply AOP. like execution(* com.example.CalculatorService.*(..)) means find all methods in CalculatorService package.
  Advise: when to apply the AOP logic, @before, @after @around @afterThrowing etc.
  
  Purpose of AOP: 1)exception handling 2) logging
  “,
- “keyword”: “Spring Core”,
- “frequency”: 3,
- “top”: true
“id”: 180,
- “question”: “Spring bean annotation, bean life cycle and bean scope”,
- “answer”: “
  Annotations:
  - @Component @Bean @Controlelr @Service @Configuration etc
  Bean lifecycle
  - Bean instantiated –> dependency injected –> init() –> custom operation –> destory()
  Bean Scope:
  - Singleton (DEFAULT): only one instance per whole applcation/container
  - Prototype: create a new instance whenever you need to INJECT this bean
  - session: one instance per user session
  - request: one instance per user request-response cycle.
  EXTRA: Does spring has thread scope? – NO: if you need, create by yourself.
  “,
- “keyword”: “Spring Core”,
- “frequency”: 5,
- “top”: true
“id”: 184,
- “question”: “Spring Bean scope and explain the request scope”,
- “answer”: “
  Singleton: DEFAULT scope, only one instance per application.
  Prototype: create new instance whenever you use @Autowired to inject
  Request: create new instance per user request response cycle
  Session: create one new instance per one user session
  “,
- “keyword”: “Spring Core”,
- “frequency”: 5,
- “top”: true
“id”: 186,
- “question”: “Different ways of DI”,
- “answer”: “
  Constructor based, Setter based, Field based
  Assume you have Bean A and Bean B. A depends on B and B also depends on A.
  Constructor based: when you start spring application, spring will create bean and inject the dependencies. So in this case, when create Bean A, it will need Bean B to inject, so it will create Bean B, and then it finds Bean B will need Bean A. So Bean A and Bean B are waiting for each other. It will throw BeanCurrentlyInCreation exception.
  Setter based: the dependency is only injected when it is used. Spring will first create Bean A and Bean B, but will not inject to each other until B is used in methods inside A. so there will be no exceptions
  Field Based: it is based on java reflection, so it will not throw exception either.
  “,
- “keyword”: “Spring Core”,
- “frequency”: 4,
- “top”: true
“id”: 193,
- “question”: “When there is circular dependency, use which type of Injection? / Setter based Injection vs. Constructor based”,
- “answer”: “
  Circular Dependency: when 2 beans are dependent for each other. Bean A and B, A is injected into B and B is also injected into A.
  Constructor based: the beans are injected when initialized. So when you create bean A, it will try to create bean B so it can be injected, but while it tries to create bean B, it needs bean A. So using constructor based, it will throw BeanCurrentlyInCreationException.
  Setter Based: Dependencies are only injected when they are used, they are not injected when spring initialize the ApplicationContext. So this will not throw the exception.
  
  “,
- “keyword”: “Spring Core”,
- “frequency”: 4,
- “top”: true
“id”: 218,
- “question”: “How to inject bean when there are two beans with same type?”,
- “answer”: “
  Use @Qualifier. Like if you have an interface and 2 children, you can use @Qualifier to decide which one to inject
  “,
- “keyword”: “Spring Core”,
- “frequency”: 5,
- “top”: true
“id”: 365,
- “question”: “How does spring inject singleton bean into prototype bean?”,
- “answer”: “
  If spring inject the real prototype into singleton bean, then singleton bean will not be singleton anymore.
  To solve it, spring create a proxy for the protype bean, so it actually just inject the proxy once. When proxy is called during runtime, spring will decide if create a new instance based on the real bean scope.
  “,
- “keyword”: “Spring Core”,
- “frequency”: 4,
- “top”: true
“id”: 449,
- “question”: “What to lazy loading a spring bean”,
- “answer”: null,
- “keyword”: “Spring Core”,
- “frequency”: 4,
- “top”: true

“id”: 319,

“question”: “How to configure multiple database using JPA”,

“answer”: “

Each database is connected by its own datasource(driver, url, username, password). We need to list them in application.properties and use them to create different dataSource beans, so JPA can use these beans.

— in Application.properties:\nspring.datasource.jdbcUrl = [url]\nspring.datasource.username = [username]\nspring.datasource.password = [password]\n\nspring.second-datasource.jdbcUrl = [url]\nspring.second-datasource.username = [username]\nspring.second-datasource.password = [password]\n\n    @Bean\n    @ConfigurationProperties(prefix=spring.datasource)\n    public DataSource firstDataSource() {\n        return DataSourceBuilder.create().build();\n    }\n\n    @Bean\n    @ConfigurationProperties(prefix=spring.second-datasource)\n    public DataSource secondDataSource() {\n        return DataSourceBuilder.create().build();\n    }\n\n\n

“,

“keyword”: “Spring JPA”,
“frequency”: 4,
“top”: true

SpringRest

“id”: 178,
- “question”: “Http status code you ever met”,
- “answer”: “
  2XX: success
  - 200: Success
  - 201: Resource created successfully
  - 202: Accepted: the request is accepted, but not processed yet.
  - 204: No Content: request is success, nothing to return
  3XX: the requested resources have been moved, client needs to do a redirect.
  - 301: resource is permanently moved.
  - 302: resource is not found - temporary moved to another location
  - 308: permanently redirected to a new location
  4XX: client side error
  - 400: Bad Request
  - 401: Unauthorized
  - 403: Forbidden
  - 404: Not found
  - 405: Method not Allowed
  5XX: server side error
  - 500: Internal server error
  - 502: Bad Gateway
  - 503: Service Unavailable
  - 504: Gateway timeout
  “,
- “keyword”: “Spring Rest”,
- “frequency”: 5,
- “top”: true
“id”: 187,
- “question”: “Explain MVC and the order of each components”,
- “answer”: “
  Request –> security –> controller –> service –> repository –> response
  Security: handles request authentication and authorization
  controller: handles request, contains the mapping, endpoint, methods, return type etc.
  service: for business logic
  repository: crud operation with database tables
  “,
- “keyword”: “Spring Rest”,
- “frequency”: 5,
- “top”: true
“id”: 197,
- “question”: “Different types of request mapping/rest api/http methods”,
- “answer”: “
  CRUD METHODS: C - POST, R - GET, U - PUT, D - DELETE
  PUT vs POST:
  1. PUT is to update, it is idempotent (means, if you do PUT 2 times with same data, you get the same results)
  2. POST is to create new object, if you do POST 2 times, you create 2 objects, so it is not idempotent.
  Can you write create object or update object in GET request?
  \tYES. the methods are contracts in REST api, it is just to limit how you call the rest api, the detailed logic has to be implemented by yourself, so you can write any logic you want, but it is not good idea to write post or put logic inside get method.
  
  “,
- “keyword”: “Spring Rest”,
- “frequency”: 5,
- “top”: true
“id”: 226,
- “question”: “How to handle controller exceptions? How spring handles exception?”,
- “answer”: “
  @ExceptionHandler can handle exceptions at controller level. @ControllerAdvice + @ExceptionHandler together can handle exceptions in all exceptions.
  “,
- “keyword”: “Spring Rest”,
- “frequency”: 5,
- “top”: true
“id”: 229,
- “question”: “How do you create a controller?”,
- “answer”: “
 @RestController
 @RequestMapping(/user)
 public class UserController{
 @Autowired
 private UserRepository userRepository
 
 @GetMapping(`) public ResponseEntity<List<User>> getAllUsers(){ try{ List<User> users = userRepository.findAll(); return ResponseEntity.status(HttpStatus.OK).body(users); }catch(Exception e){ return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build(); } } @GetMapping(/{id}`)
 public ResponseEntity<User> getUser(@PathVariable int id){
 try{
 User user = userRepository.findById(id);
 return ResponseEntity.status(HttpStatus.OK).body(user);
 }catch(Exception e){
 return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
 }
 }
 
 }
 “,
- “keyword”: “Spring Rest”,
- “frequency”: 5,
- “top”: true
“id”: 232,
- “question”: “What is difference between path variable and query param?”,
- “answer”: “
  PathVariable is a MUST-HAVE parameter in URL. Query Param is more like for optional parameters.
  “,
- “keyword”: “Spring Rest”,
- “frequency”: 4,
- “top”: true
“id”: 236,
- “question”: “What will happen after clicking the URL?”,
- “answer”: “
  How is application deployed?
  \tFor example, when you deploy amazon application to amazon.com, the application is deployed on a server with a static URL, that static URL is mapped to the domain name amazon.com, the mapping is managed by DNS(Domain Name System), so when someone click domain amazon.com, the DNS will find mapping and redirect to the original static URL.
  
  What happens after clicking a URL?
  1. browser will parse the URL, find protocol (http or https), domain name, path, query parameter etc.
  2. browser will call to check DNS to find the IP address for the application for the URL domain.
  3. browser will attempt to visit the original URL and build the connection
  4. The request will goes through security layer, and then to controller, service, repository and then to database
  5. the data comes back as a response will go back to the browser
  6. the browser will render the view
  “,
- “keyword”: “Spring Rest”,
- “frequency”: 4,
- “top”: true
“id”: 201,
- “question”: “How does JWT work?”,
- “answer”: “
  JWT is to a tool that you don’t need to keep login with your username and password.
  
  JWT token has 3 parts, the header, payload body and signature. The header contains the type of the token and the algorithms such as SHA256. The payload body contains the user data like username and userrole etc. The signature is to a string used to verify the payload data.
  
  Flow:
  1. User login with username and password, the backend will validate and create a JWT token.
  2. The token is sent back to frontend and stored in the Cookie.
  3. Subsequent requests come with the cookie and the JWT token is passed in the request header.
  4. The token will be validated to check if user is authenticated.
  5. The token expiration time can be extended.
  You dont have to store the token in database, but if you want to persist it or set the expiration time, you can store it in the database.
  “,
- “keyword”: “Spring Security”,
- “frequency”: 5,
- “top”: true
“id”: 211,
- “question”: “Have you used security? how do you protect your rest api? how do you protect your application?”,
- “answer”: “
  What: We use spring security.
  How: We override the spring framework WebSecurityConfigureAdaptor and its many configure method. We can use JdbcAuthentication, InMemoryAuthentication etc and Store the user credentials in the UserDetails object. We can also use BCrypt to encode the password and JWT token to do validations. We can use use antMatcher to let certain URLs only be accessed by certain User Roles.
  Ways for authentication and Authorization:
  - UserNamePassword authentication: When user fill username password in frontend, we can encode their password and validate with database or check if credentials match in UserDetails object.
  - JWT token, if the user is validated, we can use JWT token to validate the subsequent requests so user won’t need to to enter credentials anymore for a validate token period. The JWT token is stored in cookie and will be passed along every request. Each token can have an expiration time and can be extended. The token does not have to be saved to database.
  - Oauth2: we can also use Oauth2 to do authorization, it is 3rd part authorization, just like login with google, :login with facebook etc. You first request 3rd party to get authentication token and then use that authentication token to get authorization access.
  - Asymmetric Key pair, also called public key and private key. Many online portal uses it, just like AWS SDK.
  - Remember-Me feature, it is just to let user choose to let application remember the credentials and store the settings in the user cookie
  - Authorization: can use AntMatcher to do authorization for certain roles.
  “,
- “keyword”: “Spring Security”,
- “frequency”: 5,
- “top”: true

BQ

“id”: 1,
- “question”: “Introduce yourself and talk about your most recent project”,
  - “answer”: “
    Self Introduction
    1. Hi, my name is X, i have over X years of experience as a [title] in software development, design and deployment. My main skills are in Java, XX etc. I have been working in Both frontend and backend.
    2. For frontend end, i used [Angular, React, Jquery, Bootstrap, Html, ES6, CSS] etc
    3. For backend, I used Spring boot, Rest API, GraphQL, Spring Dependency Injection, JPA, Scheduler etc
    4. For security, I am familiar with Oauth2, Basic Authentication, JWT Token, Asymmetric Key pairs etc
    5. For database, I have worked with both SQL and NoSQL, like Oracle, Postgres, SQL Server, MongoDB, Cassandra etc
    6. For cloud, I have used AWS cloud, like EC2, RDS, S3, EBS, lambda, ECS container etc
    7. I also have experience in distributed systems, like MicroServices, Kafka Message queue, Redis distributed cache, Load Balancer, Circuit Breaker, API Gateway etc.
    8. More, i have written a lot of test cases, like JUNIT, Mockito, PowerMock, Selenium, TestNG, Cucumber, Gatling etc
    9. I am also familiar with CICD using Jenkins or Bamboo with maven or gradle.
    10. For monitor tools, i used Grafana, AWS cloudwatch, Jmeter(load test), JProfiler, Splunk, Datadog etc.
    Project Introduction:
    1. Talk pure business and list 2-5 entries to talk about, make it the way everyone can understand. Talk from how users use your app or how data flows in your app.
    2. Then talk about pure technical skills used. Frontend, security, backend, microservice, message queue, cloud, testing, monitoring etc
    3. Make it as long/detailed as possible.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 2,
- “question”: “Talk about the team structure and how your team works when everyone is working remotely”,
  - “answer”: “
    Team structure
    Business Team: responsible for determine the functions of application
    Dev Team: responsible for developing the functions (where developers in)
    QA team: test the functions developed by Dev team:
    DevOps team: deploy the functions to production.
    
    Dev team size: safe to say any number from 4 - 15, good range is a number in 5-10. Like, our team has 8 developers. We all work on both frontend and backed and We all write the test cases.. We also joined the DevOps deployment process, but we have a dedicated DevOps team. Remember to say: whenever you have question about the function, you can talk with business team.
    
    Jira: a tool to track all the tickets that you need to work on in each sprint
    Confluence: a tool to document everything, like functional documents, technical documents etc
    
    Communications: Email, Zoom Meetings, Slack messaging.
    
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 4,
- “question”: “Describe a bug you met and how you deal with it?”,
  - “answer”: “
    Think of one in your most recent project
    Key thing to mention:
    1) How was the bug found in production - monitor tools like Splunk OR customer feedback to your support team
    2) you try to reproduce it in your local and DEBUG it, test with postman, put breakpoint, write new test case to cover it.
    3) CICD and release it, customer is happy.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 5,
- “question”: “How do you coordinate with QA?”,
  - “answer”: “
    Agile with sprint: Sprint is usually 2 or 3 weeks length
    Sprint Begin: planning meeting, business, dev, and QA sit together to discuss what to do in the sprint.
    Then: grooming meeting: Dev team members only to get everyone familiar with their own tickets
    Daily standup: report status of everyone ticket and discuss issues
    Spring End: retrospective meeting to review what have been done.
    
    In 2 weeks sprint, every ticket is mark as dev completed will be tested by QA, if any issue, QA feedback to developer and get it fixed immeidately.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 3,
“id”: 11,
- “question”: “What’s the architecture of your project? How many layers are there?”,
  - “answer”: “
    For big web based application:
    Overall: Microservice, Load Balancer, Circuit Breaker, Kafka, Docker, Cloud etc
    Each service: Frontend -> security -> controller -> service with helper and utils -> repository, model, DTO etc.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 4,
“id”: 14,
- “question”: “How did you start with a new job/project?”,
  - “answer”: “
    Some general steps:
    1. Get code to local and try to run it
    2. Read documents about the workflows
    3. Try to solve some simple tickets
    “,
  - “keyword”: “BQ”,
  - “frequency”: 4,
“id”: 15,
- “question”: “Talk about your daily work, what’s your typical day looks like”,
  - “answer”: “
    We follow Agile methodology, we have 2 weeks sprint. So at beginning of each sprint, we have a planning meeting which we sit together to discuss all the tickets we need to work in in the whole sprint, and after that we have grooming meeting which is for developers to get familiar their own tickets. Then in each day, we have daily standup meeting in the morning at around 10am when we discuss our progress on each ticket and any blockers (need to wait on others work) we have. After meeting, we go back to work on our tickets and sometimes, we have meeting with business team to discuss the detailed problems, we also have design meetings for each big stories and we also have developer meetings to discuss our common issues. AT the end of each sprint, we have retrospective/retro meeting to review what we have done.
    Percentage of daily time: 60-70% on coding including development and test cases, 10-20% on meetings, 10-20% on leading junior people or system design meeting
    You need to say 60-70% on coding because they are hiring you as a software developer who writes code all the time.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 4,
“id”: 20,
- “question”: “When you have conflicts with your colleague, how do you deal with it?”,
  - “answer”: “
    1. Conflicts is normal, everyone has their own ideas, and not everyone familiar with every part of the project, so conflicts is common
    2. Communication is the key to solve conflicts, never hide my idea, i always explain and spread out
    3. I reach out to the person and explain my ideas and I try best to understand his ideas. And we choose the better one regardless whose idea that is. we only want the best solution goes to the code
    4. If conflicts cannot be solved between us, we escalate it to tech lead or team manager.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 21,
- “question”: “Tell a time you have conflicts with your team and how you resolved it”,
 - “answer”: “
 Conflicts <find a particular conflicts >
 How do you solve it: The key thing is communication, I will first open communication, i will explain my idea. I will also try my best to understand his idea. We will discuss and keep it transparent and try to choose the best solution. It does not matter who comes up with that solution, because our goal is to make best product for customers.
 If we cannot really agree on each other, we will escalate to manager and let manager decides, we should all agree on the final decision.
 “,
 - “keyword”: “BQ”,
 - “frequency”: 4,
“id”: 24,
- “question”: “Do you like Pair programming or coding on your own”,
  - “answer”: “
    Both has pros and cons
    Pair programming:
    1. Good to learn from the leader and good for new members to get familiar with project
    2. Good to trigger new ideas, when you discuss, new ideas come out more often then you just think by yourself
    3. Bad: coding is very slow.
    Work independent:
    1. I am senior and experienced, so i can quickly get things done.
    2. Sometimes I get stuck, it can take a long while to find solution
    Overall: I am experienced, so I can solve most of the tickets just by working on my own. But I also did pair programming with team members, like when we have POC (proof of concept) or Demo or Design meetings, or when I do knowledge transfer for some new team memebers, I do pair programming to help them.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 2,
“id”: 26,
- “question”: “During middle of sprint, your manager suddenly add a new task to you, what do you do?”,
  - “answer”: “
    1. There must be a reason why manager added that ticket, it could be urgent issues. so i understand him, i will take it
    2. I will explain what I have left in my ticket list, I will put that urgent ticket as top priority to fix it, and other tickets will be pushed after
    3. I will still try to fix other tickets according to their priority, i can work extra hours
    4. If i really cant finish the other tickets, i will ask to move to next sprint or to share to other team members.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 27,
- “question”: “How do you debug?”,
  - “answer”: “
    First, we check the application log, like Splunk Log can tell where it has exception. Then we can try to reproduce it in our local environment. Put a breakpoint, and start application in debug mode, when program stop at the breakpoint, we can step into, step over, jump to next breakpoint, check variable values, do expression evaluation.
    REPRODUCE is always the best way to find the bug root cause.
    If it is not an exception, if it is something like performance issue, like page loads slowly, we have many tools to find the reason, like DataDog, Splunk, CloudWatch etc.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 338,
- “question”: “Do you have any leader experience”,
  - “answer”: “
    YOU DONT SAY: YOU WERE A LEADER! BUT YOU SAY, YOU HAVE SOME LEADING EXPERIENCE.
    Answer: I was not a leader of the entire team, but I do have some leading experience. Whenever our team have new hires or juniors, I was always the person who onboard them and guide them. I need to assign easy tasks to them and do pair programming with them to help them know more about the applications. I also answer their questions. Basically I was the person who make sure they will be able to catch up with the team pace.
    Also I review our team PR on a regular basis. In [client], I was one of the small group who reviews code for all team members. we have a checklist to go through when we review the code
    
    “,
  - “keyword”: “BQ”,
  - “frequency”: 2,
“id”: 339,
- “question”: “What do you need to look when you review others code”,
  - “answer”: “
    1. Syntax error
    2. Possible duplicate logic
    3. Method possibilities to split to reusable methods.
    4. Make sure having unit test that covers the part
    5. Check performance improvements, like try to improve the time and space complexity.
    6. Check performance, like try to use cache or eliminate duplicate database calls.
    7. …
    “,
  - “keyword”: “BQ”,
  - “frequency”: 4,
“id”: 428,
- “question”: “Have you ever worked in a situation where you are on your own, with no other developer and no other infrastructure, just you and PM?”,
  - “answer”: “
    Hint: Key to this problem is show you can work independently. Some project only has 1-2 people and some projects can have 20-40 people.
    Answer: Yes, actually I have worked purely by myself for the project at XXX. I was the only person who worked on the project from scratch, from design the service, to write implementation and test code and even to production release. The project is about XXXX (description). It could me about 3 ( to 6) months to complete the entire project. My manager was very satisfied and customers are still using the application now.
    The project actually helped me a lot as well. It gives me confidence that I can work on independently and solve the entire project by myself. I can learn things quickly and write code fast etc…
    “,
  - “keyword”: “BQ”,
  - “frequency”: 3,
“id”: 429,
- “question”: “Describe a task that you did by yourself”,
  - “answer”: “
    Key: Pick a medium size task and explain it clearly.
    Example 1: While in project XXX, i was given task to write stored procedures for the data transfer in different inventory databases. I was the only person responsible for writing all the database programming. I wrote many triggers, stored procedures, functions, views and database links. I feel it was a great experience to me because I gained all the SQL experiences.
    Example 2: I remember a task at XXXX, we were previously returning all the data in string format and fields are separated with semi colons. However, in some cases, the result string may contain semi colon as part of the contents which we should not parse it as delimiter. Initially, we solve it case by case, but later on, we see it happens more when customer increases. So I proposed and created this task by myself to refine all the logic to use json format instead of the string format. I have to revise all the related logics and have to update about 100 java classes which return this result string. It is a big task but it is also one of the most impacted task to the project.
    Example 3: When I was working on migrating the legacy system to new angular spring boot based system, I was given a task to rewrite the payment flow. Instead of just rewrite, I actually redesigned it and created a template for this workflow migration, i created several base classes and typescript files. With this case, all the future workflow migration just need to extend my template and the base classes. It becomes a new format and rule to the entire project. I become the expert in that project and I created a lot of documentations for that as well.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 430,
- “question”: “Describe a time you made a big mistake, what lesson you learnt from it”,
  - “answer”: “
    Key: find a mistake, clearly explain it, and then say how your solve it in a positive way and the lesson you learned in a positive way.
    Example: Mistake: Accidently deleted some data in database and there is no backup. Solve: try to put data back via 1) asking others help 2) reproduce data with some code etc. Lesson learnt: 1) Always backup 2) Always be careful with Update, Delete. etc.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 431,
- “question”: “Tell me about a time you have difficulty with a project or with a team member. How you solve it. What strategy did you use to solve them? “,
  - “answer”: “
    For conflicts, always prepare something technical related.
    Answers should always be: When (which project) -> What (what conflicts) -> How (how do you solve it) -> Result (what is the good consequences)
    When: I remember when I was at XXX project, I had a conflict with my team member (from another team).
    What: The conflict is about a ticket/story, the ticket is about XXX, My idea is XXX, his idea is XXX, he does not agree with me. We argue about it.
    How: I think communication is key, so I explain my idea to him and listen to him carefully. As long as it is not personal, it is all about work, I have to be professional. I even write POC/demo to show my idea.
    Result: Finally, 1) if two people cannot reach the same agreement, we escalate to our manager to make a decision and we should all listen to managers OR 2) we both things our ideas have some good parts, so together we make a better plan that combines the goodness of both ideas and it turned out working very well.
    
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 432,
- “question”: “Talk about your experience working in a small team and a large team, which one do you prefer”,
  - “answer”: “
    Small team: Pro: 1) efficiency - easy communication, fast communication 2) every one can have chance work on every part of the project, can learn a lot. Cons: 1) limit resources, due to lack of people, many things can be blocked
    Large team: Pro: 1) large project, more users, more traffic, more challenge 2) big family, more culture part. Cons: 1) low efficiency 2) only work on small portion of the entire whole project.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 3,
“id”: 433,
- “question”: “Tell a time you faced a hard deadline, how do you solve it”,
  - “answer”: “
    1. provide detailed example in the project
    2. Solution: 1) Make priority order of the tasks and focus on high priority first, the low priority may be pushed to backlog or next sprint. 2) Work extra time, commit fully to the tasks 3) if still cannot finish or extra time is not allowed in the company, I will request manager to push to next sprint or extend the deadline.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 434,
- “question”: “What are the key things you care about in a new team/project?”,
  - “answer”: “
    Some points to mention:
    1. Good team culture, nice working environment
    2. Good skills and new technologies used in the team
    3. You feel you can grow in the team, someday you may become a senior or leading some juniors
    4. You feel being important to the project, you can make contributions and be needed by others as well.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 4,
“id”: 435,
- “question”: “Do you need to work with a business team ever? Describe your daily work with them.”,
  - “answer”: “
    Yes, I need to work with business team pretty much all the time.
    1) we have agile sprint, so at the beginning of each sprint, the entire team of developers and business team need to sit together to discuss about the work to be done in the sprint
    2) whenever I am unclear about the tickets, I would reach out to the business team members directly to discuss about it.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,
“id”: 436,
- “question”: “How do you learn something new? How do you start the process?”,
  - “answer”: “
    !! Never mention Google, GPT, ChatGPT, Youtube
    1. read official documents and tutorial guidelines, they are the most accurate and first-hand study materials.
    2. follow some tutorials or courses on Udemy etc.
    3. Most importantly, I always try the examples, try to implement by myself. The best way to learn new technologies is to implement with it.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 4,
“id”: 437,
- “question”: “What is your team size? What methodology was used?”,
  - “answer”: “
    Team size: developers (in real world, it could be 2 - 20, when you answer, safe to say any number in 4-10)
    Mostly we don’t business and QA inside the team, when refer to team, we refer to dev team, but when having scrum meetings, project manager, scrum master, dev, QA all join the meetings, including daily standup meeting
    Methodology: Agile Sprint.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 4,
“id”: 438,
- “question”: “Do you have experience working in a global team? “,
  - “answer”: “
    Yes. We have team members in different countries, we have part of the team in India. So i often need to have meetings with them in late night or early mornings. It is very common to have global team nowadays.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 3,
“id”: 439,
- “question”: “Your degree is in XXX; why do you switch to a developer?”,
  - “answer”: “
    Just tell your personal story.
    Some points to consider 1) I always like programming 2) original degree is hard to find a job 3) I learnt programming when i was pursuing my degree in XXX etc.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 4,
“id”: 441,
- “question”: “How do you debug (in your IDE)?”,
  - “answer”: “
    Java IDE
    1. put breakpoints in the code
    2. run project
    3. code will stop at the breakpoints, we can choose to step into/over/skip the breakpoint
    4. check variable values Or evaluate expressions.
    Frontend
    1. open chrome browser DevTools
    2. Sources tab will list the file and we can put breakpoints in the code.
    3. Network tab will show traffic, we can check the request status, payload and response
    4. Elements tab will show the html structure, we can locate the html elements
    5. Console tab will show the logs and also can be used to evaluate the local variables and expressions.
    “,
  - “keyword”: “BQ”,
  - “frequency”: 3,
“id”: 442,
- “question”: “Have you used task management tools like Jira, Rily, and Confluence?”,
  - “answer”: “
    YES.
    The task management tools like Jira can be used to run the scrum meetings, it will list the sprint tickets (task, story, issue etc), each ticket can have status like TO DO, In Progress, Done etc
    “,
  - “keyword”: “BQ”,
  - “frequency”: 3,
“id”: 443,
- “question”: “Can you share the most enjoy point in your current company, or what you really expect for your next role? “,
  - “answer”: “
    Same as the what your look for in the new team
    1. New skills/technologies
    2. Good team culture, open communication etc
    “,
  - “keyword”: “BQ”,
  - “frequency”: 5,

CICD

“id”: 30,
- “question”: “Can you talk about CI/CD?”,
  - “answer”: “
    KeyPoints:
    1. CICD is continuous integration and continuous deployment. In the project, we usually use Jenkins with its pipeline scripts to implement CICD.
    2. The script contains multiple parts. The stages parts list each stage and the steps inside. For example, stage one is checkout and steps in this stage are like using git clone to checkout the code from repository and then use maven to package it etc. Another part of the script is post part which handles different result. For example, what to do when the build is success or failure, what to do when the test cases failed etc.
    3. CICD usually starts from when the code is pushed to the target branch, and then it includes checkout and package the code, deploy the jar/war, run the test cases and send reports etc. It could cover from dev to QA/Staging environment, but usually does not cover production.
    “,
  - “keyword”: “CICD”,
  - “frequency”: 5,

Cloud AWS

“id”: 297,
- “question”: “How to deploy microservice in AWS container”,
 - “answer”: “
 MicroService is mostly deployed to AWS EKS service (Elastic Kubernetes Service). To deploy we need to
 1) Use eksctl to create the cluster and update the kubeconfig file to use new EKS cluster.
 1) Create a cluster and define the deployment.yaml and service.yaml. Deployment.yaml is a file that specify the metadata for deployment, including apiVersion, number of replications and container image and port etc. The service.xml defines the details of each service pods and how to access them, aka, how to communicate between pods/services.
 2) Use kubectl command to apply the deployment and service configurations: kubectl apply -f deployment.yaml kubectl apply -f service.yaml
 
 “,
 - “keyword”: “Cloud AWS”,
 - “frequency”: 4,
“id”: 317,
- “question”: “AWS difference between parameter store and secret manager”,
  - “answer”: “
    Parameter Store: 1) mainly store configurations. 2) Does not support auto rotation. 3) Use hierarchy structure to store parameters
    Secret Manager: 1) mainly store database credentials, API keys and other sensitive information. 2) Auto rotation support 3) Not using hierarchy structure.
    “,
  - “keyword”: “Cloud AWS”,
  - “frequency”: 1,
“id”: 318,
- “question”: “AWS where to store certificate file”,
  - “answer”: “
    For SSL/TLS related certification, we can use AWS Certificate Manager(ACM) or AWS Identity and Access Management(IAM) directly
    For customized certificate data, we can store it in the Parameter Store.
    
    “,
  - “keyword”: “Cloud AWS”,
  - “frequency”: 1,

Docker

“id”: 235,
- “question”: “How to use docker in the Spring Boot?”,
  - “answer”: “
    Docker is a container with flexible memory management and has dockerHub that you can upload or download images
    To use with Spring boot, 1) include docker dependency 2) add a Dockerfile
    “,
  - “keyword”: “Docker”,
  - “frequency”: 2,

ElasticSearch

“id”: 347,
- “question”: “ElasticSearch why do you use it”,
  - “answer”: “
    Elastic Search is an engine to make search data very faster. It is usually put between backend application and database, it works like a cache or a database. Some people think it is a databse, but it is actually defined to only optimize search.
    ElasticSearch use index to cache out all the fields you want to search, just like the database Non-Cluster Index.
    For example, you have JSON:
```
Product{\n   id : 234323423434,\n   name : a complete guide to java,\n   description : This is a book as a complete description to java, it is mainly focused on java, spring, java 8, jdbc, spring framework. the author is intended to help any one with no or strong experience in java or any programming language, I am very long..,\n   many other fields\n}\n
```
    You can add the fields or the description texts as the index so you can search any text match in the name or description. It is very fast.
    “,
  - “keyword”: “ElasticSearch”,
  - “frequency”: 3,
“id”: 348,
- “question”: “How do you use elasticSearch in your java application”,
  - “answer”: “
    Spring boot project:
    If using JPA: (https://www.baeldung.com/spring-data-elasticsearch-tutorial)
    - We need to add elastic search to our configuration class, Elastic Search has many clients, we can use the RestHighLevelClient to work with JPA.
    - Entity need to add @Document(indexName = XXX, type = XXX) to do ORM mapping.
    - Repository needs to extend ElasticSearchRepository
    When it is complex that can not be handled by JPA repository: (https://reflectoring.io/spring-boot-elasticsearch/)
    - Use ElasticsearchOperations object, it has many method, like index() and search() methods.
    - Use NativeSearchQueryBuilder object to build a complex query and run it directly with JPA @Query
    “,
  - “keyword”: “ElasticSearch”,
  - “frequency”: 2,

Git

“id”: 41,
- “question”: “Git command you used in the project”,
  - “answer”: “
    There are 2 common repositories working with git: Github and Bitbucket
    - Clone from repository as new project: git clone URL
    - Steps to commit change to remote repository: git add (files), git commit (-m message), git push
    - get remote data: git pull or git fetch (git fetch just read remote repository, git pull is git fetch + push to current local branch)
    - rebase and merge: git rebase, git merge
    - create a branch: git checkout branchName
    - delete a branch: git branch -d branchName
    - to override current branch with remote: git reset –hard remoteHead
    “,
  - “keyword”: “Git”,
  - “frequency”: 2,
“id”: 358,
- “question”: “How do you release from the git reposiotry”,
  - “answer”: “
    Use git tag.
    In Git, a tag is a named pointer to a specific commit. It is used to mark specific points in Git history, such as release versions, significant milestones, or any other notable events. Tags are lightweight and can be created quickly and easily without affecting the repository’s history.
    Git tags are typically used to:
    1. Mark a specific point in history: You can create a tag to mark a specific commit as a significant point in the repository’s history, such as a release version or a major milestone.
    2. Identify releases: You can use tags to identify releases, which are specific versions of your software that have been tested and are ready for production use. This makes it easy to track which version of your software is deployed in production and to roll back to a specific version if necessary.
    “,
  - “keyword”: “Git”,
  - “frequency”: 1,
“id”: 367,
- “question”: “How do you combine several commits together”,
  - “answer”: “
    Use squash. Example to use:
    1. If you need to combine the last N commits together: git rebase -i HEAD~N (N is the number of commits)
    2. If you have a branch F which contains many commits, you want to merge F branch into your current branch: git merge –squash F
    “,
  - “keyword”: “Git”,
  - “frequency”: 1,
“id”: 368,
- “question”: “What is git cherry-pick”,
  - “answer”: “
    Cherry-pick is to pick a particular commits into your current branch.
    For example, if you have two branches with commits (DEV: a -> b -> c -> d) and (FEATURE: b -> x -> y -> z)
    if you are currently on DEV branch, but you want to have the y commit from FEATURE onto DEV too, you can do git cherry-pick y
    “,
  - “keyword”: “Git”,
  - “frequency”: 1,
“id”: 369,
- “question”: “difference between git and svn”,
  - “answer”: “
    Both are used to maintain work repository (where your code will stay)
    Git is a distributed model, good for large team collaboration. You have a main branch, for every ticket, you can create feature branch out from the main branch, once you are down, you can merge the feature back to the main branch.
    SVN is a centralized model, good for small team or straightforward projects. You have a main repository called trunk, all developers will commit to this trunk
    “,
  - “keyword”: “Git”,
  - “frequency”: 2,
“id”: 370,
- “question”: “difference git merge and rebase”,
  - “answer”: “
    Suppose you have 2 branches: f1 and f2 bot derived from main branch and both have some commits. now you are on f1 and you want the commits from f2.
    Merge: combine all commits from f1 and f2 as a new commit and put on f1. so merge will create a new commit.
    Rebase: your f1 is based on main, rebase is to let your f1 branch based on f2. it will make f2 as the new base for f1.
    link: https://www.atlassian.com/git/tutorials/merging-vs-rebasing
    “,
  - “keyword”: “Git”,
  - “frequency”: 2,

Java

“id”: 43,
- “question”: “Abstract class vs. Interface. When to use abstract class and when to use interface?”,
  - “answer”: “
    Abstract Class: 1) still a class, so you can only extend one abstract class. 2) Have both concrete method and abstract method.
    Interface: 1) you can implement many interfaces 2) Only has abstract method. 3) In java 8, interface can have default and static method
    Usage:
    Most of the places, interfaces are preferred, but if you need some common method to inherit automatically, you can use abstract class.
    
    FOLLOW UP:
    since java 8 allows default and static method in interface, what is the essential difference between abstract class and interface?
    A: abstract class can have fields, the fields can hold value and track the status of the object itself. Interface cannot have fields, it can only have constants.
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 44,
- “question”: “New feature of Java 8. Give an example of how you use them in your project”,
 - “answer”: “
 Top of java 8 features:
 - Functional interface: is an interface that only has ONE abstract method. We can use lambda expression to implement that method
 - Lambda expression: () -> {}. It is to implement functional interface and anonymous class. You can pass a lambda function to a method as argument
 - Optional: to prevent NullPointerException in runtime. for example, Optional<Employee>, it has methods like isPresent(), isEmpty(), get(), orElse() etc.
 - Default method in interface:
 - Why need it: When a interface has 10 children classes, all children classes need the same method, before java 8, you need to implement this same method in every child class, but with default method, you just write it once as default method in interface, all children will automatically inherit it.
 - If a class implements 2 interfaces and both interfaces has same default method, then there will be exception because the class does not know which on to use, the class then has to override them.
 - Stream API: a group of methods to handle collections easily. like, filter, map, flatmap, sorted, reduce, groupingBy, joining etc.
 - Intermediate operator vs terminator operator
 - flatmap vs map
 - Java Date Time API update: new date time API has default timezone, so developer does not need to set it.
 “,
 - “keyword”: “Java”,
 - “frequency”: 5,
“id”: 45,
- “question”: “Comparable vs. Comparator”,
 - “answer”: “
 Comparable is an interface. (In java, able is mostly an interface). You use a object class to implement comparable interface and implement its compareTo method. int compareTo(Object B)
 Comparator is a class, many times used as anonymous class, like in Collections.sort(list, comparator), you need to implement the compare(Object A, Object B) method.
 “,
 - “keyword”: “Java”,
 - “frequency”: 3,
“id”: 46,
- “question”: “Types of Exceptions and how do you deal with exceptions in your project?”,
  - “answer”: “
    - Java Exception hierarchy:
    throwable – error + exception.
    error is like system error which can NOT be handled by program, like OutOfMemoryError, StackOverflowError etc.
    Exception – compile/checked exception + runtime/unchecked exception. Checked exception can be handled using try catch block, like the SQLException, Thread InterrupttedException; Unchecked exception happens in runtime, like NullPointerException, IndexOutOfBoundException etc.
    - self defined exception: Just extend the java Exception class and define your own constructor and message
    - How to deal with exception
    - Java: use Try/Catch/Finally block or use Throws on method level.
    - Spring: use @ExceptionHandler @ControllerAdvice on the controller level to catch exception in whole application
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 47,
- “question”: “Generics and how do you use generics in your project?”,
 - “answer”: “
 Generics is used to prevent the error when converting data from one type to another type or just to make a method work for multiple type of data.
```
public V getFirstElement(List<T> list) {\n    return list.isEmpty() ? null : list.get(0);\n}\n
```
 Usually T is used to present Type and V is used to represent Value.
 With generics, we can 1) make sure the type is safe at compile time. 2) make a method or class work for different type of data.
 “,
 - “keyword”: “Java”,
 - “frequency”: 3,
“id”: 48,
- “question”: “Java OOP 4 principles, and explain each of them”,
  - “answer”: “
    PIEA:
    Polymorphism: 2 types, static polymorphism/overload and dynamic polymorphism/override. overload is you have 2 methods in the same class, they have SAME method name but different type or numbers of parameters . They can have different access modifier too (they are basically just 2 different methods happening to have the same name).
    Override: 2 methods with same method signature(method name, parameters) in Parent and Child class, but different implementations. The child method must have same or broader access modifier than parent method.
    Inheritance: One class can only inherit one parent class, one class can implement many interfaces
    Encapsulation: This is about who can access your method or fields, Access modifer: Public, Private, Protected, Default.
    Abstraction: abstract class and interfaces.
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 49,
- “question”: “If java 8 allows default method in interface, so what is the real difference between interface and abstract class?”,
  - “answer”: “
    abstract class can have regular fields which can host the data, but interface cannot, interface can only have constants.
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 52,
- “question”: “Serialization, What is Serializable and SerialVersionUID?”,
  - “answer”: “
    Serialization is to convert the java object into byte stream so you can save it to file system or database or send across network.
    To implement serialization, just implement serializable interface. private and final fields can be serialized, but static field cannot, because static field does not go with objects.
    When a serialVersionUID is presented, it is used to match the byte stream with current java object, if they match, the object can be de-serialized, otherwise, exception will be thrown.
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 53,
- “question”: “HashMap: how does it work internally, what is hash collision”,
  - “answer”: “
    VERY IMPORTANT!!!
    HashMap has 2 key important methods, equals() and hashcode()
    Think there is a list of buckets, each bucket is identified by a hashcode.
    When you call get(key), the key will first be passed to hashcode() method and a hashcode is returned, Use this hashcode, you can locate the corresponding bucket. Inside that bucket, it is a tree structure of all key-value pairs that share the same hashcode. so to find the target key-value pair, the equals() method will be called, and once found, the value will be returned.
    Hash collision: all the key-value pair that shares the same hashcode stays in same bucket, that is called hash collision. It is preferred in hashmap, because if there is NO hash collsion, each key-value pair will stay in one bucket, then there will be too many buckets, causing too much memory. If all entries in one bucket, then it is hard to search the target. The hash collision makes the time complexity of hashmap to O(1) because of hashing.
    Why hashmap use Tree structure in bucket: Previously it is a list, but then changed to tree, because tree has left node smaller than root and root smaller than right. So the search is O(logn), much faster than list.
    
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 59,
- “question”: “What is the Functional Interface? Java 8 built in functional interface?”,
  - “answer”: “
    Function interface is in java 8, it can only contain Single Abstract Method. You can use lambda to implement it.
    Java built-in function interface:
    Consumer: the method takes input but NO output. Example: System.out.println(input)
    Supplier: the method takes NO input but HAS output. Example: RandomNumberGenerator.
    Predicate!: the method return boolean type, true or false, it is widely used in stream().filter(predicate) to filter out collections
    Function: the method takes INPUT and RETURN output. it is used to convert data, like stream().map(function)
    Binary Operator: the method has 2 input and 1 same type output: like int add(int a, int b)
    there are other types, but you only need to anser, the top 4.
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 62,
- “question”: “HashTable vs. HashMap”,
  - “answer”: “
    HashTable: thread safe, synchronized, low performance
    HashMap: not thread safe, good performance
    Simliar group:
    Vector vs ArrayList.
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,

“id”: 67,

“question”: “Implement a singleton”,

“answer”: “

REMEMBER THIS:

import java.io.Serializable;\n\n\npublic class Singleton implements Cloneable, Serializable {\n\n\n    private static Singleton instance;\n\n\n    private Singleton() {}\n\n\n    public static Singleton getInstance() {\n        if (instance == null) {\n            synchronized (Singleton.class) {\n                if (instance == null) {\n                    instance = new Singleton();\n                }\n            }\n        }\n        return instance;\n    }\n\n\n    @Override\n    protected Object clone() throws CloneNotSupportedException {\n        throw new CloneNotSupportedException(Cloning of Singleton is not allowed.);\n    }\n\n\n    protected Object readResolve() {\n        return getInstance();\n    }\n}\n\n\n

“,

“keyword”: “Java”,
“frequency”: 5,

“id”: 68,
- “question”: “Do you know about the Executor Service and Future?”,
  - “answer”: “
    Executor Service has thread pool. It can be used run multi threads in parallel.
    Thread Pool:
    - Fixed Thread Pool: create fixed number of threads no matter you will use it or not
    - Cached Thread Pool: create threads based on needs, if new task is coming and no threads available, it will create new thread. If a thread idle for some time, it will be terminated.
    - Scheduled Thread Pool: can be used to set delays and schedule tasks
    - Fork Join Pool: It uses a work-stealing algorithm, the tasks are break into many small pieces. If some threads are done with their tasks, they can steal other threads task to run. This will have better performance.
    When the task has return (callable tasks)
    Use Future object to host the return. The tasks are like async process, they are submitted, and later on, if there is a return comes back, the return will be stored in Future object.
    Future has method like get() to get result or isDone() to check if task is completed.
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,

“id”: 69,

“question”: “Explain the Factory design pattern”,

“answer”: “

A factory is a method that if you pass an input, it can return the corresponding objects:

REAL PROJECT Example:

Credit card payment, if enter MasterCard, will return mastercard payment object, if enter Visa, will return visa payment etc.
Database Connection, if pass in oracle, will return oracle connection object, if pass mysql, will return mysql payment object.

Example:

public interface DatabaseConnection {\n    void connect();\n}\npublic class MySqlConnection implements DatabaseConnection {\n    @Override\n    public void connect() {\n        // Implementation details for connecting to MySQL\n    }\n}\n\npublic class PostgreSqlConnection implements DatabaseConnection {\n    @Override\n    public void connect() {\n        // Implementation details for connecting to PostgreSQL\n    }\n}\npublic class DatabaseConnectionFactory {\n    //driver method takes dbType and will get the corresponding type\n    public static DatabaseConnection createDatabaseConnection(String dbType) {\n        if (dbType.equalsIgnoreCase(MySQL)) {\n            return new MySqlConnection();\n        } else if (dbType.equalsIgnoreCase(PostgreSQL)) {\n            return new PostgreSqlConnection();\n        }\n        // Handle other database types or throw an exception for unknown types\n        throw new IllegalArgumentException(Unsupported database type: + dbType);\n    }\n}\n\n\n\n\n

“,

“keyword”: “Java”,
“frequency”: 4,

“id”: 70,
- “question”: “What design patterns did you worked on before?”,
  - “answer”: “
    Singleton, Factory + One more (You pick the 3rd one, You need to know how to explain and how to write it)
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,

“id”: 71,

“question”: “How to custom an Exception?”,

“answer”: “

Just extend the Exception class

public class CustomException extends Exception {\n    \n    String message;\n\n    public CustomException(String message) {\n        super(message);\n        //other logic if needed.\n    }\n}\n

“,

“keyword”: “Java”,
“frequency”: 4,

“id”: 72,
- “question”: “OutOfMemoryError vs StackOverflowError vs Memory Leak”,
  - “answer”: “
    OutOfMemoryError:
    - Cause: JVM Heap memory is all used. Like read too large file into memory OR infinite loop keep creating objects.
    - Prevent: batch read file; avoid creating unused object; increase heap memory with XmX setting etc
    Memory Leak:
    - Cause: objects are not used anymore, but still not garbaged collected. Like static objects.
    - Prevent: avoid creating too many static objects and clean unused objects
    - !!! Heap dump can show if there is memory leak. (WebSphere or JProfiler can do heap dump)
    StackOverflowError:
    - cause: Too many references in stack causing stack memory out
    - Prevent: avoid recursive calls without proper terminations, avoid too many references not deleted.
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,
“id”: 75,
- “question”: “java 8: Different types of method reference“,
  - “answer”: “
    In java 8, functional interface just has one abstract method, so we can use method reference to refer to it because the method input is fixed.
    There are 4 types of method references:
    1. Reference to a Static Method:
    \t\t\t\t\t– Syntax: ClassName::staticMethodName
    \t\t\t\t\t– Example: Math::max refers to the max method of the Math class.
    1. Reference to an Instance Method of a Particular Object:
    2. Syntax: object::instanceMethodName
    3. Example: list::size refers to the size method of the list object.
    4. Reference to an Instance Method of an Arbitrary Object of a Particular Type:
    5. Syntax: ClassName::instanceMethodName
    6. Example: String::toUpperCase refers to the toUpperCase method of the String class.
    7. Reference to a Constructor:
    8. Syntax: ClassName::new
    9. Example: ArrayList::new refers to the constructor of the ArrayList class.
    “,
  - “keyword”: “Java”,
  - “frequency”: 2,
“id”: 78,
- “question”: “What is Optional?”,
 - “answer”: “
 Optional is introduced in java 8, to prevent null pointer exception.
 For example, if you have employee.getAddress().getCity(), in runtime, if employee is null, getAddress() will throw exception.
 Wen can use Optional<Employee>, optional has method like ifPresent(), isPresent(), get(), orElse() etc.
 “,
 - “keyword”: “Java”,
 - “frequency”: 4,
“id”: 90,
- “question”: “ArrayList vs LinkedList, which one to choose?”,
  - “answer”: “
    Structural: Arraylist has index and get(index) method. LinkedList: has only header and next pointer.
    For TIME complexity,
    if you know the index of target element in arraylist, arraylist is best O(1), if you dont know index, arraylist and linkedlist are the same O(n)
    For Space complexity,
    ADD element ArrayList is O(n) because you have to shift all elements after. But linkedlist is O(1) because you just change the pointer.
    
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 91,
- “question”: “How does Java class loader work?”,
  - “answer”: “
    When java loads a class, it has to load the parent first, but one class is only loaded once.
    Bootstrap class loader: is parent of all class loaders. it loads the core java in jre/lib.
    Extension class loader: it loads all java standard extensions or 3rd party extensions
    Application class loader: it loads java classes from class path, like the class developer wrote.
    It is a tree like hierarchical structure.
    “,
  - “keyword”: “Java”,
  - “frequency”: 2,
“id”: 92,
- “question”: “Java 8: Intermediate operator and terminal operator in stream api”,
  - “answer”: “
    Intermediate operator:
    - refer to operators that return another stream which can be appended by another operator. like stream().map(), the map is an intermediate operator because we can chain it with more operations.
    - Example: filter, map, sorted
    Terminal operator:
    - refer to final operators in stream api. We cannot append more operations after terminal operator.
    - Example: forEach, collect, count, findAny
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 95,
- “question”: “How do you create a thread?”,
  - “answer”: “
    There are 2 ways: extend the Thread class or Implement the Runnable interface
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 98,
- “question”: “How does arraylist work internally?”,
  - “answer”: “
    Internally ArrayList is implemented by Array. Initial size is 10. When the array is filled about to full size, it will create a large array (default double size) and copy old data into new array so there will be more space to add elements
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 104,
- “question”: “How does thread communicate/interact/share data with each other?”,
  - “answer”: “
    Communicate/Interact:
    1. Wait() and Notify() method: wait() method will let current thread pause and release lock to other threads, this current thread will only be waken up and get lock if other threads call notify() or notifyAll().
    2. Executor service in java concurrent package can interact threads, like the WorkStealingPool use join and fork to interact between threads to improve performance. CompletableFuture also can chain threads.
    If asking how to share data between threads:
    1. Let threads visit same data memory, like same object, same database table, same file or cache
    2. Use message queues. one thread sending data, another thread consume data
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,
“id”: 106,
- “question”: “What are the meaning of thread methods: join, wait, sleep, yield”,
  - “answer”: “
    JOIN: to let current thread wait until another thread finishes. So it is used to let threads run in order.
    WAIT: wait is to RELEASE lock and let other threads run. this thread will resume only when other threads call notify(), notifyAll()
    SLEEP: this thread will NOT RELEASE the lock, it lets current thread to sleep for given time and then it will restart by itself. Different from wait method, the sleep will not release lock and will resume by itself.
    YIELD: if some threads share the same priority, yield method is to hold current thread and let others run first.
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,
“id”: 113,
- “question”: “Shallow copy vs. Deep copy”,
  - “answer”: “
    If you have an object, for example Employee e;
    Shallow Copy: Employee f = e; //you are just copying the reference e to f. Now both e and f pointing to same one object.
    Deep copy: Employee f = new Emplyee(), f.setName(e.getName()); //you create a new employee f, and then you copy every field in employee e to f. so f and e having same contents. But they are TWO objects in memeory.
    “,
  - “keyword”: “Java”,
  - “frequency”: 1,
“id”: 115,
- “question”: “How does ConcurrentHashMap works?”,
  - “answer”: “
    ConcurrentHashMap is thread safe and it has better performance then SynchornizedMap
    ConcurrentHashMap divides its internal buckets into 16 segments. When 1 thread visits the map, it will lock that segement, and the other threads can still visit other segments.
    The SyncrhonziedMap will lock the entire map, so its performance is not as good as ConcurrentHashMap
    “,
  - “keyword”: “Java”,
  - “frequency”: 2,
“id”: 117,
- “question”: “What is ConcurrentModificationException and how to handle it?”,
  - “answer”: “
    ConcurrentModificationException is thrown when you have multiple threads try to modify the NON-thread-safe java collections, like ArrayList, HashSet, HashMap etc.
    To handle:
    1. When modify collection, like remove element, using Iterator instead of for loop.
    2. Use thread safe collection, like CopyOnWriteArrayList, ConcurrentHashMap, CopyOnWriteHashSet etc.
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 118,
- “question”: “Relationship between equals() and hashcode()”,
  - “answer”: “
    In HashMap, when you do a get(key) call, first key is passed to hashcode() to locate a bucket, and then inside bucket, call equals() to find the entry.
    HashCode() and Equals() should use exactly the same object fields.
    1. If two objects are equal according to the equals() method, they must have the same hash code (equal objects must produce equal hash codes).
    2. However, the reverse is not necessarily true: two objects with the same hash code may or may not be equal.
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,
“id”: 119,
- “question”: “How to make class immutable?”,
  - “answer”: “
    Immutable means it cannot be changed. So we should prevent all ways to change a class and its object
    - make class final, public final class ..so we cannot extend and modify it
    - make fields private, so we cannot modify it directly from outside
    - Do NOT provide setter method.
    - in the get method, don’t return fields directly, return copy of the fields.
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 121,
- “question”: “What is the deadlock? How to FIND it? How to avoid it?”,
  - “answer”: “
    Deadlock is when you have 2 threads, Thread1 is waiting Thread2 to release lock on an object while Thread2 is waiting for Thread1 to release lock on an object. They are waiting on each other.
    To find:
    use Thread dump, thread dump is like to take a snapshot/photos of all current threads, so it will show if there are deadlocks.
    JProfiler/FastThread/JStack are all tools can show thread dump.
    To prevent:
    1) For all shared objects/resources by both threads should be combined as a whole entity and should be locked together.
    2) Set global orders for the shared objects, so that threads will only lock them in same order.
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,
“id”: 127,
- “question”: “Difference between HashSet and TreeSet, HashMap and TreeMap”,
  - “answer”: “
    TreeSet the key is sorted in binary tree order. (left smaller than root, root smaller than right)
    Same for HashMap vs TreeMap. TreeMap the key is also sorted in tree structure. So hashMap time complexity is O(1) because of hashing, but TreeMap is O(logn) for binary search.
    Benefit of tree structure is that the keys are ordered, so you can quickly know if a key exists in that structure.
    “,
  - “keyword”: “Java”,
  - “frequency”: 2,
“id”: 131,
- “question”: “When implements Serializable, what if you don’t define the serialVersionUID? What if you remove it?”,
  - “answer”: “
    System will use a default SerialVersionUID
    “,
  - “keyword”: “Java”,
  - “frequency”: 1,
“id”: 132,
- “question”: “What is fail-fast and fail-safe?”,
  - “answer”: “
    Fail-Fast: detects the possible failures before it happens. Like when you loop element of HashMap and try to remove it. It will fail fast with ConcurrentModificationException
    Fail-safe: Use the data structure that can handle ConcurrentModificationException by itself, so it will not throw exception, like when loop and remove elements from ConcurrentHashMap.
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,
“id”: 135,
- “question”: “Map vs. FlatMap”,
  - “answer”: “
    In Java 8 stream api.
    Map is to convert data, it takes a function as input.
    FlatMap is Map + Flat. It can handle 2 dimensional matrix, and apply Map on each row and then Flat each row result into a final 1 dimensional array.
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 138,
- “question”: “HashMap vs LinkedHashMap and HashSet vs LinkedHashSet”,
  - “answer”: “
    HashMap vs LinkedHashMap; HashSet vs LinkedHashset
    HashMap/HashSet: key is not ordered, random order.
    LinkedHashMap/LinkedHashSet: key is in insertion order - keep the order when they are inserted.
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 139,
- “question”: “why using static and why not?”,
  - “answer”: “
    What: static is a keyword to make sure there is only 1 copy of the resource. like static field, static method or static inner class
    For What: static resources can be shared across whole applications, like use static block so initalize some global data. Static method can be used as helper or util methods, we can just call Class.StaticMethod so we dont need to create instances.
    Why Not: Static object will not be garbage collected. They will stay in memory forever. Too many static objects can cause memory leak.
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,
“id”: 163,
- “question”: “what is SOLID principle?”,
  - “answer”: “
    SOLID represents 5 principles
    S: Single responsibility - a class does its own thing, like Employee class only does things, will not handle Department things.
    O: open for extension and close for modification. A child class can extend a parent class but cannot modify the parent class.
    L: Liskov Principle, The Liskov Substitution Principle (LSP) applies to inheritance hierarchies such that derived classes must be completely substitutable for their base classes.
    I: The Interface Segregation Principle (ISP) states that clients should not be forced to depend upon interface members they do not use. In other words, do not force any client to implement an interface that is irrelevant to them.
    D: The Dependency Inversion Principle (DIP) states that we should depend on abstractions (interfaces and abstract classes) instead of concrete implementations (classes). The abstractions should not depend on details; instead, the details should depend on abstractions.
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 295,
- “question”: “How to make a global count in multithreading environment”,
  - “answer”: “
    A: Use AtomicInteger. Atomic is to keep object/field thread safe in multi-threading environment. There are AtomicInteger, AtomicBoolean, AtomicReference etc
    “,
  - “keyword”: “Java”,
  - “frequency”: 2,
“id”: 296,
- “question”: “Difference: Synchronized, ThreadLocal, Volatile, AtomicInteger”,
  - “answer”: “
    Synchronized: it is to make resource thread safe in multi-threading environments, can be used on block of code OR method. If we have Employee object and it contains another address object and updateEmployee() method. If we put synchronized on the method, it will lock the whole employee object. If we use synchronized(address) in the code, it will only lock the address field, will not lock whole employee object, So the synchronized block has better performance.
    ThreadLocal: If a variable is defined as ThreadLocal, then when a thread gets this variable, it will gets its own copy, so when this thread update this variable, it only updates its own copy, the other copies used by other threads will not be affected.
    Volatile: If a variable is volatile, it is kept at a core main memory. All threads will only read and update this main copy. They will not have their own copy. All threas share exactly the same main copy. It guarantees that if one thread updates the value, the other threads will get that updated value because there is only 1 copy.
    AtomicInteger: AtomicInteger/AtomicBoolean/AtomicReference etc: the ‘atomic’ is to make sure the operations on the variable is a single operation and cannot be splitted further. It is typically used as a Global Counting and prevent thread race conditions.
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 303,
- “question”: “How does string works? Why is String immutable in Java?”,
  - “answer”: “
    String is immutable in java, means once you create a string object, you cannot change it anymore. If you want to use mutable string, use StringBuilder instead.
    
    How string memory works:
```
String s1 = abc;\nString s2 = new String(abc);\nString s3 = abc;\nString s4 = new String(abc);\nString s5 = abc.intern();\n
```
    In memory, there is a constant pool which only stores the quoted string, like abc, it will not have duplicates in this constant pool. So when we create s1, it goes to constant pool. S2 is created by new String() constructor, whenever we call this constructore, we create a separate copy in the heap memory, not in the constant pool. For intern() method, it will check if the constant pool has a copy, it will use it, if not, it will create one copy in the constant pool,.
    So s1 == s3 == s5 != s2 != s4
    
    Why is string immutable:
    1. So we can use it in many places, like as Map key.
    2. We can use it for security reasons, like store passwords or keys
    3. It will be thread safe, multi-thread cannot change the value.
    4. We can use for caching and hashing.. like as the Cache key or used in other APIs.
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 310,
- “question”: “What’s Garbage collection types and Whats new in java 8? “,
  - “answer”: “
    Types of GC:
    1. Serial Garbage Collector: Uses only single thread to perform garbage collection. Good for small sized heaps.
    2. Parallel Garbage Collector: Use multiple threads to in parallel. Good for multi-core systems, like systems with high throughput.
    3. CMS (Concurrent) Garbage Collector: perform GC concurrently with application execution. Used for system requires very low-latency.
    4. G1(Garbage-First) Garbage Collector: It is to balance between low-latency and high throughput. It divides heap into regions and perform GC with each region.
    What’s new in Java:
    1. MetaSpace: Preivouly java use fixed size for Permanent Generation (store metadata and internal code), java 8 introduces metaspace which is flexible based on system memeory.
    2. G1 is made as default GC for large heaps.
    Java allows you to choose different GC algorithms based on your JVM version. Common GC options include -XX:+UseSerialGC, -XX:+UseParallelGC, -XX:+UseConcMarkSweepGC, and -XX:+UseG1GC.
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 321,
- “question”: “Java switch statement has too many cases, how to improve it”,
 - “answer”: “
 Too long switch/case statements can make program very hard to read. Two ways to replace it:
 1) use Reflection, 2) use Map<String, Runnable>
 https://stackoverflow.com/questions/60311302/using-reflection-instead-of-a-long-switch-statement
 “,
 - “keyword”: “Java”,
 - “frequency”: 1,
“id”: 330,
- “question”: “New features in java 11 and 17”,
  - “answer”: “
    Java 11
    1. Local variable in lambda expression. Not you can use var to define local variables in java 11.
    2. New Garbage Collector: like Epsilon (for testing) and ZGC for low-latency and large heap system.
    Java 17:
    1. Sealed Class: Use sealed keyword to control which class can be subclass of this class. Use permits keyword to allow subclass.
```
sealed class Shape permits Circle, Rectangle, Triangle {\n    // Common methods and properties for all subclasses\n    abstract double calculateArea();\n}\n
```
    1. Hidden Class: which can not be seen by java reflection.
    2. Text Blocks: allow you to use text like long strings.
    “,
  - “keyword”: “Java”,
  - “frequency”: 3,
“id”: 332,
- “question”: “Difference: Sleep and Wait”,
  - “answer”: “
    Sleep(time): when a thread sleeps, it will hold the lock and just pause running for given time, after the time, it will resume running again by itself.
    Wait: when a thread waits, it will give the lock to other threads, this thread will only resume when other thread notify() it or notifyAll()
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 343,
- “question”: “Suppose when you have Employee class to store data, when do you use list or map”,
  - “answer”: “
    1) List can have duplicates and it is just to store all information. Map is key value pair, key must be unique
    2) In application, if you just want to show all employees in json format, you can use list; but if you want to show list of employee Ids and if you click the Ids it will display the whole employee json, so it is like you need a id –> employee association, then you can use map.
    “,
  - “keyword”: “Java”,
  - “frequency”: 2,
“id”: 344,
- “question”: “Difference: Arraylist vs LinkedList, when to use which”,
  - “answer”: “
    READ:
    - ArrayList: is usually faster because it has index. It can be O(1), or worst O(n) if you dont know index
    - LinkedList: is slower because you have to traverse from header, so it is always O(n)
    ADD/REMOVE
    - ArrayList: is usually slower because when you add element, you have to shift all elements after it. So it is O(n)
    - LinkedList: is faster because you just change the pointer, O(1)
    INTERNAL IMPLEMENTATION:
    - ArrayList: implemented by dynamic Array, Need less space because it only need to store value and index
    - Linkedlist: double linkedlist, with value and pointers. Need more space to store, value, left and right pointer
    WHICH ONE:
    - If your app need more READ, less ADD/REMOVE, then linkedlist is good
    USE CASE:
    - ArrayList: for example to store a list of objects
    - Linkedlist: to store object where you just need previous or next value, like browser history or stack.
    “,
  - “keyword”: “Java”,
  - “frequency”: 5,
“id”: 363,
- “question”: “Difference runnable vs callable”,
  - “answer”: “
    Both are used to run tasks/threads
    Runnable 1) return type is void. 2) cannot handle exception
    Callable 1) can have return type 2) can handle exception
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 364,
- “question”: “Difference future vs completableFuture”,
  - “answer”: “
    When you submit a task to executor service, it returns a future.
    CompletableFuture is advanced version of future.
    1) It has method like thenApply, thenCombine etc. so you can build thread chain.
    2) it has handle and whenComplete method, which you can handle exception with it.
    “,
  - “keyword”: “Java”,
  - “frequency”: 4,
“id”: 371,
- “question”: “JDK vs JRE vs JVM”,
  - “answer”: “
    JDK is for developer to write java code, it can compile the java code to binary class code and also it has debug mode.
    JRE is a java running environment, if you want to run java application, you have to have JRE installed.
    JVM: java virtual machine, is to mange java memory, like heap, stack, metaspace etc.
    “,
  - “keyword”: “Java”,
  - “frequency”: 2,
“id”: 372,
- “question”: “What is externalization and its difference with serialization”,
  - “answer”: “
    Both serialization and externalization are used to serialize objects. Externalization gives you more control of the process.
    Serializable is a marker interface which does not contain any methods for you to implement
    Externalizable is not marker interface, it has readExternal() and writeExternal() method that you can override
    “,
  - “keyword”: “Java”,
  - “frequency”: 1,

“id”: 373,

“question”: “How do you implement a deadlock”,

“answer”: “

public class ThreadLock\n{\n    final static String R1 = Hello Welcome to Pilot!;\n    final static String R2 = Visit Pilot!;\n\n\n    public static void main(String[] args)\n    {\n    \t    // creating thread T1\n \t    Thread T1 = new Thread(){\n                // implementing run method\n \t\tpublic void run(){\n\n\n \t            // thread T1 locking the R1 resource\n \t\t    synchronized (R1){\n \t\t        System.out.println(Thread T1 locked -&gt;&nbsp; &nbsp;Resource R1);\n\n\n \t\t        // thread T1 locking the R2 resource\n \t\t\tsynchronized (R2){\n \t\t\t    System.out.println(Thread T1 locked -&gt; Resource R2);\n \t\t        }\n \t\t    }\n \t\t}\n \t    };\n\n\n \t    // creating thread T2\n \t    Thread T2 = new Thread(){\n \t\t// implementing run method\n \t\tpublic void run(){\n\n\n \t\t    // thread T2 locking the R2 resource\n \t\t    synchronized (R2){\n \t\t        System.out.println(Thread T2 locked -&gt; Resource R2);\n\n\n \t\t\t// thread T2 locking the R1 resource\n \t\t\tsynchronized (R1){\n \t\t\t        System.out.println(Thread T1 locked -&gt; Resource R1);\n \t\t\t}\n \t\t    }\n \t\t}\n \t};\n\n\n \t// starting both the threads\n \tT1.start();\n \tT2.start();\n    }\n}\n\n\n

“,

“keyword”: “Java”,
“frequency”: 4,

“id”: 374,

“question”: “Synchronized method vs Synchronized block”,

“answer”: “

public class UserService{\n    private Address address;\n    private String username;\n\n    public static synchronized void lockUserServiceClass(){\n       //synchronized method is to lock whole object, but since this method is static, it only stays in the class\n       //so static synchronized will lock the class, not the created objects/instances\n    }\n\n    public synchronized void lockUserServiceInstance(){\n       //this method will lock the entier userService Instance\n    }\n\n    public void lockBlock(){\n       synchronized(address){\n         //here only lock the address object, not the whole instance, performance is best\n       }\n    }\n}\n

“,

“keyword”: “Java”,
“frequency”: 3,

“id”: 375,
- “question”: “Difference between Iterator and Enumeration”,
  - “answer”: “
    Both use to loop java collections.
    Iterator: can remove elements when iterator.
    Enumeration: cannot remove elements.
    “,
  - “keyword”: “Java”,
  - “frequency”: 2,
“id”: 448,
- “question”: “What is proxy design pattern”,
  - “answer”: null,
  - “keyword”: “Java”,
  - “frequency”: 4,

JDBC

“id”: 141,
- “question”: “PreparedStatement vs Statement vs Callable Statement”,
  - “answer”: “
    Statement is to run a SQL as string directly.
    PreparedStatement is to compile the SQL and use ? to take the passed-in paramter
    Callable statement is to call Stored Procedure.
    “,
  - “keyword”: “JDBC”,
  - “frequency”: 1,

Kafka

“id”: 143,
- “question”: “Did you use Kafka in your project? How does it work?”,
  - “answer”: “
    Kafka has 3 parts, Producer, Cluster/Broker, Consumer (!DO NOT READ AS CUSTOMER!)
    Producer send message (has topic) to broker
    Broker has topics, each topic has several partitions, the messages are send to these partitions.
    Consumer belongs to one consumer group, they will read the message from partition.
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 5,
“id”: 149,
- “question”: “Talk about Kafka and Zookeeper”,
  - “answer”: “
    In Early version of Kafka, Zookeeper is like manager, it managers the metadata, like which broker is the leader and the offset tracking.
    In new Kafka version, it uses Raft consensus algorithm for leader election. So it does not need Zookeeper.
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 3,
“id”: 331,
- “question”: “How to start and stop kafka server?”,
  - “answer”: “
    Kafka has 2 scripts to start and stop the server.
```
bin/kafka-server-start.sh\nbin/kafka-server-stop.sh\n
```
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 1,
“id”: 334,
- “question”: “How to prevent data loss in kafka”,
  - “answer”: “
    There are 3 parts of Kafka, all 3 parts need to prevent data loss.
    Producer: when producer sends message to broker, the broker will send a status back to producer if the message is received, if not received, producer will keep sending the same message again and again.
    Broker: Each partition has K replications/backups, there is a parameter ACKS (acknowledgement), ACKS = 0 means broker will not tell if the message is received, so if there broker is down, then it is lost. ACKS = 1 means if the message is received by leader partition, but not yet received by replications, it will tell producer the message is received, so when ACKS = 1 and the leader broker is down, the message will be lost. ACKS = ALL means only when all replications of partitions receive the message and then the producer will be notified. ACKS = 0/1 could cause message loss, but ACKS = ALL will slow down performance.
    Consumer: enable.auto.commit is a configuration that let consumer auto commit the offset, once auto commit, the message is considered read by consumer successfully. But if the consumer has some error, it may cause the read failure. so we can set enable.auto.commit = false and manually commit the offset.
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 5,
“id”: 335,
- “question”: “How to keep message order in Kafka”,
  - “answer”: “
    Key: message in one partition is consumed in order. So to make message in order, we just need to send them to same partition. In kafka, each message has an id, if you don’t give id, kafka will assign auto generated id, Kafka use hashing to convert this id to hashcode which is corresponding the partition. (just like hashmap hashcode and bucket). So to make message in order, we need to assign same message ID to them, like if it is order message, we can use order id, if it is like transaction messages, we can use transaction id.
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 5,
“id”: 336,
- “question”: “How to prevent duplicate message in kafka”,
  - “answer”: “
    Kafka has consumer and producer. To prevent duplicate, we should try on both side [reference]
    Producer:
    - Kakfa has many producers and each producer can send many messages, to make each message unique, we need to assign producer an ID and each message an ID, so the producer ID + message ID combination will be unique.
    Consumer:
    - enable.auto.commit should be set to false. enable.auto.commit = true means kafka will auto commit the offset even if consumer failed to process the message, this could cause message loss.
    - Consumer has 2 ways to prevent duplicate messages, 1) it can check the message unique id, if found that id is already processed, it will ignore it. 2) it can make its opreation idempotent, just like put, update once and twice will yield same results.
    One more thing, if each message is sent only once, but the consumer is down, then we could have message lost, so we need to configure auto.offset.reset, this is a parameter to decide when consumer is down, whether we should restart reading from last failed position (latest - default) or beginning of the partition (earliest).
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 5,
“id”: 345,
- “question”: “Kafka how to let two consumers read the same message”,
  - “answer”: “
    Put them in different consumer group.
    In kafka, consumers in same group can only read different partitions - that is why the number of consumers cannot be more than number of partitions in each group. But consumer in different group can read the same partition.
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 2,
“id”: 346,
- “question”: “Kafka how to determine the consumption rate”,
  - “answer”: “
    What is kafka consumption rate:
    It is defined by the offset of last produced message divide by time. For example, if producer sent message1 out and the offset of message1 in partition is 1000 (there are 999 messages ahead of it to be processed). Now, if to process this 1000 messages, it will take 100 seconds, so the consumption rate will be 1000msgs/100s = 10 messages/second.
    To improve the consumption rate:
    1. increase the network bandwidth. The bandwidth can be a bottleneck for the consumption uplimit. Kafka has monitor to see bandwidth.
    2. increase hardware. like CPU and memeory.
    3. reduce the average time for every consumers or add more consumers.
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 1,
“id”: 359,
- “question”: “How to implement security to kafka. Kafka Security”,
  - “answer”: “
    1. Broker authentication: Add authentication for kafka broker, only authenticated applications can connect to kafka brokers.
    - We can use SASL (Simple authentication and security layer) to implement it, SASL supports secure authenticaiton like PLAIN, SCRAM. SASL is a tool to add security to many network protocols, like LDAP, SMTP, IMAP etc.
    1. Data Encryption: Add encryption to broker so that data sent in and out of kafka brokers are encrypted.
    - We can use SSL/TLS to encrypt data. To add SSL certificate to kafka. We can first use openSSL to create a certificate and then use keytool to create a truststore and add the certificate to it. We also need to configure kafka to use the SSL certificate like security.portocol=SSL
    1. Maintain a Access Control List (ACL) to specify which user or group can access which topic or partition.
    “,
  - “keyword”: “Kafka”,
  - “frequency”: 4,
“id”: 450,
- “question”: “What is kafka dead letter queue and how do you handle it?”,
  - “answer”: null,
  - “keyword”: “Kafka”,
  - “frequency”: 4,

Microservice

“id”: 145,
- “question”: “What application details are stored in service registry?”,
  - “answer”: “Service Registry and Service Discovery — Erueka
    1. Service Name: The name or identifier of the service. (This helps other services in the system locate and communicate with the desired service)
    2. Service EndPoints: The IP addresses and port number where the service currently hosing on.
    3. Health Status: Information about the health and availability of the service. (whether the services is up and running)
    “,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 146,
- “question”: “How can you make services communicate with each other? -> Tools like Spring Cloud to setup microservice or use message queue like Kafka”,
  - “answer”: “
    There are two ways to communicate between services, sync and async
    Sync: RestTemplate/RestClient – when service 1 call rest api of service 2, service 1 will have wait for the return from service 2, so this is sync communication.
    Async: message queue like Kafka – service 1 as producer sends message to kafka cluster, service 2 as consumer subscribes from kakfa cluster.
    “,
  - “keyword”: “Microservice”,
  - “frequency”: 5,
“id”: 152,
- “question”: “How to use the Zuul Gateway API? / How does the Zuul Gateway API work?”,
  - “answer”: “
    Zuul API Gateway is to distribute the traffic do a particular service.
    For example, Amazon has 3 services, order service is at localhost:8070, payment service is at localhost:8080, delivery service is at localhost: 8090. You don’t want to expose all 3 different addresses to customers. So you add one API Gateway like at localhost:9000. Customers only access to API Gateway. API will redirect to different services based on the URL. For example, localhost:9000/order will be redirected to order service, localhost:9000/payment will be redirected to payment service, localhost:9000/delivery will be redirected to delivery service.
    To set API Gateway, we need Zuul gateway server, all the other services should register the zuul gateway server in their application.properties.
    “,
  - “keyword”: “Microservice”,
  - “frequency”: 4,
“id”: 153,
- “question”: “How to manage the entire transaction across different microservices? How to rollback?”,
  - “answer”: “
    Saga Pattern
    Saga Orchestration Pattern is a design pattern to manage global transaction across multiple microservices based on message queue.
    For example, if you make one order which involves Order Service, Payment Service and Delivery Service as one transaction. In saga orchestration pattern, you will need one command center service, like Command Service which works as a communication center for all the services.
    When order service is completed, it sends a completion message to command center, the command center received and send a message to payment service, the payment service will process payment and send complete message to command service, the command service received payment completion message and send message to delivery service and once delivery is done, it tells command service and command service will mark the entire transaction as completed.
    When there is error, the transaction will be rolled back in reverse order. For example, if delivery service failed, it sends failure message to command service, the command service will tell payment service to rollback payments, once payment service completes the rollback and tells the command service, the command service will ask the order service to rollback. It goes this way until the entire transaction is rolled back.
    “,
  - “keyword”: “Microservice”,
  - “frequency”: 5,
“id”: 191,
- “question”: “How to communicate between microservices”,
  - “answer”: “
    Sync: use RestTemplate or FeignClient
    Async: use message queue, like Kafka, ActiveMQ, RabbitMQ etc
    “,
  - “keyword”: “Microservice”,
  - “frequency”: 5,
“id”: 147,
- “question”: “Explain microservice”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 148,
- “question”: “What microservice did your team use?”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 150,
- “question”: “Disadvantage of microservice”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 151,
- “question”: “Synchronous communication and A-Synchrounous commuication in microservice-> RestTemplate or feign and message queue like Kafka”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 154,
- “question”: “vertically and horizontally”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 155,
- “question”: “How to deploy microservices to AWS EC2?”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 156,
- “question”: “What type of application is suitable for microservice architecture? What type is not?”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 157,
- “question”: “Suppose you have two Eureka servers, how does each application know which Eureka server it is registered to?”,
  - “answer”: “Every application doesn’t register only to a single Eureka server. It registers with all the servers that are configured. And these servers replicate data between each other. You can check the logs, look at the Eureka dashboards, or query the registration status in your code to find out which server the app initially registered with.”,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 158,
- “question”: “What is the circuit breaker?”,
  - “answer”: “In distributed systems, we have this thing called a circuit breaker. It’s a pattern that helps us handle failures smoothly and avoid a chain of bad things happening. It’s a kind of protection. When a service is failing, it stops requests to that service for a bit, giving the service time to fix itself. and it usually has three status, like 1. Closed: Requests go as usual, but we watch for failures. If too many failures happen, it turns to Open.2. Open: Requests don’t even try the service and just fail right away. After a break, it changes to Half - Open. 3. Half - Open: We let a few test requests through. If they work, it goes back to Closed. If not, it stays Open. “,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 159,
- “question”: “How does microservices communicate with each other?”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 160,
- “question”: “How do you use RestTemplate?”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 161,
- “question”: “How do you get noticed when a service is down?”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 233,
- “question”: “How to setup service discovery?”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 301,
- “question”: “What is Granuarity Line in microserivce”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 0,
“id”: 325,
- “question”: “How check services and their status, what is they are hosted in docker”,
  - “answer”: null,
  - “keyword”: “Microservice”,
  - “frequency”: 5,

NoSQL

“id”: 352,
- “question”: “How do you decide which database to choose, SQL or NoSQL”,
  - “answer”: “
    Several Main difference
    - 1. SQL: only have pre-defined structure schema/data, it is table based.
    - 1. NOSQL: unstructure data, like MongoDB can store PDF/audio/video/text/json data easily. Cassandra is column based, you can easily expand the columns
    - 2. SQL: based on ACID rules, designed to handle transactions.
    - 2. NOSQL: based on CAP theorem, not good for transactions.
    - 3. SQL: traditional database with SQL, not designed for big data
    - 3. NOSQL: designed for big data, have partitions.
    “,
  - “keyword”: “NoSQL”,
  - “frequency”: 0,
“id”: 290,
- “question”: “Explain CAP theorem and which database use them”,
  - “answer”: null,
  - “keyword”: “NoSQL”,
  - “frequency”: 0,
“id”: 337,
- “question”: “How to find all available keyspaces in Cassandra”,
  - “answer”: “
```
2 Ways:\n\n1.select * from system_schema.keyspaces;\n\n2.describe keyspaces\n
```
    “,
  - “keyword”: “NoSQL Cassandra”,
  - “frequency”: 2,
“id”: 452,
- “question”: “What is consistent hashing in cassandra”,
  - “answer”: null,
  - “keyword”: “NoSQL Cassandra”,
  - “frequency”: 3,
“id”: 453,
- “question”: “what is cassandra replicatoin strategy”,
  - “answer”: null,
  - “keyword”: “NoSQL Cassandra”,
  - “frequency”: 2,
“id”: 376,
- “question”: “What is sharding in MongoDB?”,
  - “answer”: “
    Sharding is to split the dataset into multiple partitions. For example, if you have data from 1 to 10 million, you can store the id from 1 to 1 million as first shard, 1 million to 2 million as 2nd shard etc.
    “,
  - “keyword”: “NoSQL MongoDB”,
  - “frequency”: 4,
“id”: 377,
- “question”: “How replication works in MongoDB”,
  - “answer”: “
    To prevent the data loss, MongoDB set replication of the nodes.
    like if you have 20 shards, the 1st shard is in Virginia, MongoDB can make 2 replications (copies) of this node and put them in Ohio and California so if Virginia server is down, the other 2 replications will back up.
    “,
  - “keyword”: “NoSQL MongoDB”,
  - “frequency”: 1,
“id”: 162,
- “question”: “Design a Employee Voting system according to the requirements”,
  - “answer”: null,
  - “keyword”: “OOD”,
  - “frequency”: 0,

OOP

“id”: 166,
- “question”: “Basic principles of the OOP”,
  - “answer”: null,
  - “keyword”: “OOP”,
  - “frequency”: 0,
“id”: 167,
- “question”: “Why Inheritance? / Benefit of using Inheritance”,
  - “answer”: null,
  - “keyword”: “OOP”,
  - “frequency”: 0,
“id”: 169,
- “question”: “Design a parking lot according to the requirements”,
  - “answer”: null,
  - “keyword”: “OOP”,
  - “frequency”: 0,
“id”: 170,
- “question”: “Inheritance vs. Composition/Aggregation -> IS-A and HAS-A”,
  - “answer”: null,
  - “keyword”: “OOP”,
  - “frequency”: 0,
“id”: 171,
- “question”: “Can a class inherits multiple parent classes? / Is multiple inheritance allowed? Why?”,
  - “answer”: null,
  - “keyword”: “OOP”,
  - “frequency”: 0,
“id”: 353,
- “question”: “When you API request or Frontend page loading slowly, how do you handle it?”,
  - “answer”: “
    Key things:
    1. For large dataset request, you can use Pagination. Just like google search, you can split your data into batches, each request only fetch fixed amount of rows.
    2. Use cache instead of database visit, Frontend: cache the visited page data. Backend: in-memory java cache for monolithic application, distributed cache, redis, for microservices.
    3. Other tools can help improve read performance, like elasticsearch can boost the search.
    4. Database side: Optimize the SQL, use Sql tuning tools, like the Oracle explain plan. Add proper index (non-cluster index) on some frequently visited columns.
    “,
  - “keyword”: “Performance”,
  - “frequency”: 0,
“id”: 298,
- “question”: “Key Difference: Soap vs Rest”,
  - “answer”: null,
  - “keyword”: “Rest”,
  - “frequency”: 0,
“id”: 354,
- “question”: “How do you implement security for your application or microservices”,
  - “answer”: “
    Principles:
    For Authentication
    - Basic Authentication: use username and password authentication. the password should be encrypted. common encryption algorithm: BCrypt, SHA256, RSA.
    - JWT Token: When the first time user login with username and password, backend will create a JWT token which contains the user info, the token will be stored in the frontend cookie. Every single request will carry this token, backend will validate this token to decide if user is authenticated. A token usually has a expiration time.
    - Asymmetric key pairs: this is used for something like AWS command portal validation. It create a private key on server side and give public key to the client side. client with public key should be able to match with the private key on the server side.
    - OAuth2: this is like 3rd party SSO (single sign on). Like for some applications, you can login with google or facebook. The application is pre-registered with the 3rd party, when a user login, it sends a request to 3rd party authentication server and gets a token, and once got the token, it will use that token to call the 3rd party authorization server to get the user role. [Learn more]
    For Authentication:
    - OAuth2 is a authorization method.
    - For other authentication, we can have AntMatcher to match the routes/paths and use hasRole to allow particular role to access it.
    Implementations:
    \t\tIn spring, we can override the WebSecurityConfigureAdaptor class, it is part of the security filter chain and it contains configure method, we will need to override the configure method and override the UserDetails object and UserDetailService class.
    
    “,
  - “keyword”: “Security”,
  - “frequency”: 0,

Spring Boot

“id”: 12,
- “question”: “How do you config for multiple environments?”,
  - “answer”: “
    1. In spring boot, we can define different profiles for different environments, like DEV, QA/Staging, PROD etc.
    2. We can have application-dev.propeties, application-staging.properties, application-prod.applications, when we run the application, we just need to set the active profile to corresponding env.
    3. In microservice, we can also use Config Server, which we can config the different profiles and put them in server hardware or in code repository and use active profile to refer to it. The benefit is we can track the version of the files.
    “,
  - “keyword”: “Spring Boot”,
  - “frequency”: 5,
“id”: 196,
- “question”: “Why do you use Spring Boot? / Benefits of Spring Boot”,
  - “answer”: “
    Top 1 question in spring boot.
    Spring boot has many benefits, the top 4 are like:
    1. Embedded Server: spring boot has Web starter which contains the tomcat or Jetty server, you dont need to deploy the application, it is auto-deployed by one click or one command line. You just run your whole application with server together as a JAR file
    2. Auto Configuration: Spring boot has auto configuration, as long as you put the properties there, spring boot will auto setup everything. Example, if you have Data Source entries in the application.properties file, Spring boot will try to auto connect the database for you.
    3. Dependency Management: Spring boot wraps up related dependencies into starters, like the Web Starter contains json, rest api, mvc model, server etc. You don’t need to add them to POM.XML separately, also you dont need to worry about the version conflicts in the dependencies.
    4. Actuator: Spring boot provides actuator which has many endpoints to tell the status of the spring boot application. Like: /info is to tell the status, /health summarizes the health status of our application. /metrics details metrics of our application. This might include generic metrics as well as custom ones.
    Disadvantage:
    Spring boot wrap too many things in the box, so many things are in under the cover.
    “,
  - “keyword”: “Spring Boot”,
  - “frequency”: 5,
“id”: 220,
- “question”: “How to start a Spring Boot project?”,
  - “answer”: “
    Several Steps in order:
    1. Go to spring initializer, fill information like Java Version, Build Tool Maven, enter project name description, Package type as Jar or War
    2. Choose Starters, like Web Stater, Spring Data Starter, Security Starter etc
    3. generate the project and download the zipfile
    4. Unzip and import into IDE as new project.
    “,
  - “keyword”: “Spring Boot”,
  - “frequency”: 5,
“id”: 221,
- “question”: “Command to run a spring boot application”,
  - “answer”: “
    Maven Command: mvn spring-boot:run
    Java command: java -jar application-name.jar
    “,
  - “keyword”: “Spring Boot”,
  - “frequency”: 1,
“id”: 228,
- “question”: “What does @SpringBootApplication mean?”,
  - “answer”: “
    3 Key Things included in this application
    @ComponentScan: will scan all beans at current level or lower level, this is why the @SpringBootApplication is on top of a main class that is higher than all other classes, so that it can scan all beans
    @AutoConfiguration: will let spring boot auto configure. For example, if you have put datasource in the application.properties, spring boot will auto connect for you. If you dont want auto configuration, use Excludes=XXX.Class to exclude that particular configuration
    @Configuration: means this is a configuration class.
    
    “,
  - “keyword”: “Spring Boot”,
  - “frequency”: 5,
“id”: 234,
- “question”: “For Spring Boot, how do I use another server such as WebLogic instead of the embedded Tomcat server?”,
  - “answer”: “
    Some configurations needed:
    1. add Exclusions in POM.XML to exclude the embedded tomcat and jetty server
    2. need to add JNDI in the application.properteis for the new server (such as weblogic)
    3. the main class needs to extend the SpringBootServletInitializer
    4. Change package in POM.XML from JAR to WAR.
    “,
  - “keyword”: “Spring Boot”,
  - “frequency”: 4,
“id”: 307,
- “question”: “Regarding @Async 1) what is it for 2) how to define it 3) how to call async method 4) can async method be private and why”,
 - “answer”: “
 What is @Async?
 - @Async is used to make a method asynchronous, meaning it will be executed in a separate thread without blocking the main thread.
 How to use @Async?
 - First, the spring boot must enable async support, we can do it by adding @EnableAsync on top of the main class
 - add @Async on the target method
```
@Service\npublic class MyService {\n\n @Async\n public void asyncMethod() { //has no return\n // Method logic\n }\n\n @Async\n public Future<String> asynMethod2(){ //return a future\n //logic\n }\n}\n
```
 How to call the async method?
 - Just call it as regular method, but since it is in another thread, so result may not be ready when you call it, so have to use while loop to handle the future and wait for it.
```
public void callAsyncMethod(){\n Future<String> future = myService.asynMethod2(); //just call and host result in future\n while(true){\n if(future.isDone()){\n String result = future.get();\n break; // stop while loop when result is returned\n }\n }\n }\n
```
 Can async method be private and why?
 - The async method can only be PUBLIC.
 - The @Async is internally implemented by spring AOP, if the method is private, AOP cannot find it, so @Async will not work.
 “,
 - “keyword”: “Spring Boot”,
 - “frequency”: 2,

“id”: 312,

“question”: “What is Conditional bean in Spring boot?”,

“answer”: “

the Conditional bean is only created when the condition is met, it can be applied on top of a class or a method bean

@Configuration\n@Conditional(isDevCondition.class)  //only create bean if it is dev environment (common used)\n@ConditionalOnProperty(value=isDev, havingValue=true) //create bean only if properties have entry isDev=true\n@ConditionalOnExpression(${isDev:true}) //use Expression\n@ConditionalOnBean(MyBean.class) //create bean if MyBean.class is created  (common used)\n@ConditinoalOnClass(MyConfig.class) //create bean only if this configuration class exists in the classpath\n@ConditionalOnJava(JavaVersion.EIGHT) //create bean only if java version >= 8\n@ConditionalOnWarDeployment   //create this bean only if deployed as war\npublic class DevLoggingService{\n    @Bean\n    @Conditional(isDevCondition.class) //only create bean if it is dev environment  (common used)\n    public AnotherDevLoggingService anotherDevLoggingService(){\n         return new AnotherDevLoggingService();\n    }\n}\n

Spring comes with many default @Conditional annotations as showing above. Some can be used on method, and most can be used on class.

They are all having one purpose: to only create a bean based on the given condition

“,

“keyword”: “Spring Boot”,
“frequency”: 2,

“id”: 350,
- “question”: “Difference between Spring boot and Spring”,
  - “answer”: “
    1. Spring boot use starter to manager dependencies, like Web Starter has MVC, REST, JSON, TOMCAT, IOC etc all included in one web starter. You dont need to worry about dependency conflicts.
    2. Spring boot has tomcat in web starter by default, so you dont need to package and deploy to tomcat. You can just run it directly or package it as JAR file and run it everywhere.
    3. Spring boot put everything in annotation by default, you dont need to write a lot code as in Spring.
    4. Spring boot add auto configuration, like if you put datasource in application.properties file, it will auto connect for you. You dont need to write the java connection code.
    5. Spring boot provide actuator which you can use to measure the metrics of the applications, like /info, /heath etc to tell the metrics, it is very useful in microservice environments.
    “,
  - “keyword”: “Spring Boot”,
  - “frequency”: 0,
“id”: 447,
- “question”: “How to do cache in spring boot and how to refresh the cache”,
  - “answer”: “
    We can use @Cachable on a method to make the returned object
    “,
  - “keyword”: “Spring Boot”,
  - “frequency”: 4,

Spring Core

“id”: 174,
- “question”: “Spring Annotation you used in your project?”,
  - “answer”: “
    @Controller, @RestController, @RequsetMapping @GetMapping @PutMapping @PostMapping @DeleteMapping
    @PathVariable @RequestParam
    @Autowired, @Qualifier
    @Service @Repository @Componenet
    
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 5,
“id”: 176,
- “question”: “What is IoC/Dependency Injection?”,
  - “answer”: “
    That is the most basic module of spring. Without spring, if you want to use another bean in one class, you have to create instance by yourself by calling the constructor. But with spring, you dont need to do that, you just use @component or @bean and other spring annotations to let spring manage the beans for you, so spring has a bucket called bean factory, it manages all the beans there for you, if you need to inject a bean, you just use @autowired, spring will find the instance and wire it for you. So you are giving the control of creating instance to spring, that is why it is also called inversion of control.
    
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 5,
“id”: 177,
- “question”: “What is AOP and how do you implement AOP in the project?”,
  - “answer”: “
    AOP - Aspect oriented programming, is to interfere with main application execution.
    Aspect: @Aspect is to mark a class as AOP class which contains AOP annotations and methods
    Pointcut: an expression to find all the main application package or methods to apply AOP. like execution(* com.example.CalculatorService.*(..)) means find all methods in CalculatorService package.
    Advise: when to apply the AOP logic, @before, @after @around @afterThrowing etc.
    
    Purpose of AOP: 1)exception handling 2) logging
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 3,
“id”: 180,
- “question”: “Spring bean annotation, bean life cycle and bean scope”,
  - “answer”: “
    Annotations:
    - @Component @Bean @Controlelr @Service @Configuration etc
    Bean lifecycle
    - Bean instantiated –> dependency injected –> init() –> custom operation –> destory()
    Bean Scope:
    - Singleton (DEFAULT): only one instance per whole applcation/container
    - Prototype: create a new instance whenever you need to INJECT this bean
    - session: one instance per user session
    - request: one instance per user request-response cycle.
    EXTRA: Does spring has thread scope? – NO: if you need, create by yourself.
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 5,
“id”: 184,
- “question”: “Spring Bean scope and explain the request scope”,
  - “answer”: “
    Singleton: DEFAULT scope, only one instance per application.
    Prototype: create new instance whenever you use @Autowired to inject
    Request: create new instance per user request response cycle
    Session: create one new instance per one user session
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 5,
“id”: 186,
- “question”: “Different ways of DI”,
  - “answer”: “
    Constructor based, Setter based, Field based
    Assume you have Bean A and Bean B. A depends on B and B also depends on A.
    Constructor based: when you start spring application, spring will create bean and inject the dependencies. So in this case, when create Bean A, it will need Bean B to inject, so it will create Bean B, and then it finds Bean B will need Bean A. So Bean A and Bean B are waiting for each other. It will throw BeanCurrentlyInCreation exception.
    Setter based: the dependency is only injected when it is used. Spring will first create Bean A and Bean B, but will not inject to each other until B is used in methods inside A. so there will be no exceptions
    Field Based: it is based on java reflection, so it will not throw exception either.
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 4,
“id”: 190,
- “question”: “Difference between @Component and @Bean”,
  - “answer”: “
    @Component is used on top of a class. @Bean is used on top of a method.
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 3,
“id”: 193,
- “question”: “When there is circular dependency, use which type of Injection? / Setter based Injection vs. Constructor based”,
  - “answer”: “
    Circular Dependency: when 2 beans are dependent for each other. Bean A and B, A is injected into B and B is also injected into A.
    Constructor based: the beans are injected when initialized. So when you create bean A, it will try to create bean B so it can be injected, but while it tries to create bean B, it needs bean A. So using constructor based, it will throw BeanCurrentlyInCreationException.
    Setter Based: Dependencies are only injected when they are used, they are not injected when spring initialize the ApplicationContext. So this will not throw the exception.
    
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 4,
“id”: 194,
- “question”: “Explain DispatcherServlet in detail”,
  - “answer”: “
    Dispatch Servlet is the CORE of spring MVC module.
    1. When a request comes, it goes to dispatcher servlet
    2. The request is sent to Mapping Handler which will decide which controller it will be redirected to
    3. The request is sent to that controller and then service and repository and then database with returned data
    4. The response from controller is sent to View Resolver which will determine which view page to be displayed
    5. The view page and the data together will be combined as a response and rendered to user.
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 4,
“id”: 199,
- “question”: “ApplicationContext vs. BeanFactory”,
  - “answer”: “
    Both are the IOC container of spring beans. ApplicationContext extends BeanFactory. So it has more features than BeanFactory, like the ApplicationContext contains the I18n language support etc.
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 2,
“id”: 218,
- “question”: “How to inject bean when there are two beans with same type?”,
  - “answer”: “
    Use @Qualifier. Like if you have an interface and 2 children, you can use @Qualifier to decide which one to inject
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 5,

“id”: 227,

“question”: “Spring validation?”,

“answer”: “

It is used to add validation on the data object. Example:

public class User {\n\n    @NotBlank(message = Username is mandatory)\n    private String username;\n\n    @NotEmpty(message = Password cannot be empty)\n    @Size(min = 8, message = Password must have at least 8 characters)\n    private String password;\n\n    // Getters and setters\n}\n

@NotBlank, @NotEmpty @Size are all validations added on top of a field. There are many more annotations.

“,

“keyword”: “Spring Core”,
“frequency”: 2,

“id”: 349,
- “question”: “How to make a java class managed by Spring”,
 - “answer”: “
 - Use annotation like @Component, @Bean @Configuration, @Service @Controller etc
 - Use XML. <bean id = bean1, reference=com.test.MyClass>
 “,
 - “keyword”: “Spring Core”,
 - “frequency”: 4,
“id”: 362,
- “question”: “What is Spring Retryable”,
  - “answer”: “
    Spring Retry is to let a method auto retry for given max attempts. Its is implemented by @Retryable and @Recover
```
@Service\npublic interface MyService { \n\n    @Retryable(retryFor = SQLException.class, maxAttempts = 3)\n    void retryMethod(String sql) throws SQLException; \n\n    @Recover\n    void recover(SQLException e, String sql); \n}\n
```
    For example, if the retryMethod throws SQLException, it will rerun for at most 3 times. If it throw SQLException for all the 3 retries, it will stop and call the recover method instead.
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 2,
“id”: 365,
- “question”: “How does spring inject singleton bean into prototype bean?”,
  - “answer”: “
    If spring inject the real prototype into singleton bean, then singleton bean will not be singleton anymore.
    To solve it, spring create a proxy for the protype bean, so it actually just inject the proxy once. When proxy is called during runtime, spring will decide if create a new instance based on the real bean scope.
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 4,
“id”: 366,
- “question”: “How to let spring create a bean only when that bean is needed instead of create at beginning”,
  - “answer”: “
    Use annotation @Lazy. It will skip the bean when spring starts, only create the bean when that bean is used/injected
    “,
  - “keyword”: “Spring Core”,
  - “frequency”: 2,
“id”: 449,
- “question”: “What to lazy loading a spring bean”,
  - “answer”: null,
  - “keyword”: “Spring Core”,
  - “frequency”: 4,

Spring JPA

“id”: 204,
- “question”: “How do you implement transaction?”,
  - “answer”: “
    The transactions have been managed so that the operations inside one transaction is purely Atomic
    Use @Transactional to mark a method (usually in server layer) as a transaction. The annotation has some parameters
    - ROLLBACKFOR, NOROLLBACKFOR: parameters to control what kinda of exceptions will cause the transaction to rollback.
    - PROPAGATION: defines when a new transaction is needed. Propagation=Required (default) means always a transaction is needed. Propagation=NEW means need to create a new transaction. etc
    - ISOLATION: set the isolation level, like READ COMMITTED means you can only read the committed data, READ UNCOMMITTED means you can read uncommitted data which could cause phantom reading.
    Extra:
    if you dont use spring, hiberneate has transaction management which can handle the transactions as well. You can use session.beginTransaction to start a new transaction and you use try catch to handle the errors
    “,
  - “keyword”: “Spring JPA”,
  - “frequency”: 5,
“id”: 315,
- “question”: “How does hibernate internally check if entity version has changed”,
  - “answer”: “
    1. locking
    2. call the update SQL, that sql return integer, use that method to decide
    “,
  - “keyword”: “Spring JPA”,
  - “frequency”: 1,

“id”: 319,

“question”: “How to configure multiple database using JPA”,

“answer”: “

— in Application.properties:\nspring.datasource.jdbcUrl = [url]\nspring.datasource.username = [username]\nspring.datasource.password = [password]\n\nspring.second-datasource.jdbcUrl = [url]\nspring.second-datasource.username = [username]\nspring.second-datasource.password = [password]\n\n    @Bean\n    @ConfigurationProperties(prefix=spring.datasource)\n    public DataSource firstDataSource() {\n        return DataSourceBuilder.create().build();\n    }\n\n    @Bean\n    @ConfigurationProperties(prefix=spring.second-datasource)\n    public DataSource secondDataSource() {\n        return DataSourceBuilder.create().build();\n    }\n\n\n

“,

“keyword”: “Spring JPA”,
“frequency”: 4,

Spring Rest

“id”: 172,
- “question”: “How does the RestTemplate work?”,
 - “answer”: “
 RestTemplate is the tool to call other REST APIs inside java code. It is Async call.
```
ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);\nString responseBody = response.getBody();\n
```
 “,
 - “keyword”: “Spring Rest”,
 - “frequency”: 2,
“id”: 178,
- “question”: “Http status code you ever met”,
  - “answer”: “
    2XX: success
    - 200: Success
    - 201: Resource created successfully
    - 202: Accepted: the request is accepted, but not processed yet.
    - 204: No Content: request is success, nothing to return
    3XX: the requested resources have been moved, client needs to do a redirect.
    - 301: resource is permanently moved.
    - 302: resource is not found - temporary moved to another location
    - 308: permanently redirected to a new location
    4XX: client side error
    - 400: Bad Request
    - 401: Unauthorized
    - 403: Forbidden
    - 404: Not found
    - 405: Method not Allowed
    5XX: server side error
    - 500: Internal server error
    - 502: Bad Gateway
    - 503: Service Unavailable
    - 504: Gateway timeout
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 5,
“id”: 187,
- “question”: “Explain MVC and the order of each components”,
  - “answer”: “
    Request –> security –> controller –> service –> repository –> response
    Security: handles request authentication and authorization
    controller: handles request, contains the mapping, endpoint, methods, return type etc.
    service: for business logic
    repository: crud operation with database tables
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 5,
“id”: 197,
- “question”: “Different types of request mapping/rest api/http methods”,
  - “answer”: “
    CRUD METHODS: C - POST, R - GET, U - PUT, D - DELETE
    PUT vs POST:
    1. PUT is to update, it is idempotent (means, if you do PUT 2 times with same data, you get the same results)
    2. POST is to create new object, if you do POST 2 times, you create 2 objects, so it is not idempotent.
    Can you write create object or update object in GET request?
    \tYES. the methods are contracts in REST api, it is just to limit how you call the rest api, the detailed logic has to be implemented by yourself, so you can write any logic you want, but it is not good idea to write post or put logic inside get method.
    
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 5,
“id”: 198,
- “question”: “Comparison between Soap and Rest”,
  - “answer”: “
    1. Soap is a Protocol based on XML, it works over HTTP, SMTP, TCP etc. But REST is a architecture type of webservice that is based on HTTP only
    2. Soap use XML for format of data, REST uses json format by default. But they do support other types
    3. Soap is Stateful and Rest is Stateless. (If 2nd request knows the data of 1st request, that is stateful, if each request is independent, it is stateless)
    4. Soap has built-in security features like WS-Security, but Rest is based on HTTP, you have to use http security, like SSL, Oauth etc.
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 3,
“id”: 206,
- “question”: “When designing a public API, what needs to be considered?”,
  - “answer”: “
    1. Restful Principles: follow the principles, like the HTTP methods, JSON format etc
    2. Good naming conventions: endpoints should have good naming conventions so caller can easily know which endpoint to call.
    3. Version: add version to the rest and make it back compatible.
    4. Security: add authentication and authorization to the endpoints
    5. Rate Limiting: Enforce rate limiting to prevent attack and abuse.
    6. Performance: Pagination can split resources and cache can reduce network travel to improve performance
    7. Scalability: Make the API easy to scale so it can handle large requests
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 4,
“id”: 219,
- “question”: “If define a object in the controller, and then other request update the value of the object, then which value will be fetched by a new request?”,
  - “answer”: “
    Spring beans by default are all Singleton. So Controller, Service, Repository are all singleton. If you define an field or object in them, it will be shared by all threads, if a request comes to update the value, another request will get the updated value.
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 3,
“id”: 226,
- “question”: “How to handle controller exceptions? How spring handles exception?”,
  - “answer”: “
    @ExceptionHandler can handle exceptions at controller level. @ControllerAdvice + @ExceptionHandler together can handle exceptions in all exceptions.
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 5,
“id”: 229,
- “question”: “How do you create a controller?”,
 - “answer”: “
 @RestController
 @RequestMapping(/user)
 public class UserController{
 @Autowired
 private UserRepository userRepository
 
 @GetMapping(`) public ResponseEntity<List<User>> getAllUsers(){ try{ List<User> users = userRepository.findAll(); return ResponseEntity.status(HttpStatus.OK).body(users); }catch(Exception e){ return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build(); } } @GetMapping(/{id}`)
 public ResponseEntity<User> getUser(@PathVariable int id){
 try{
 User user = userRepository.findById(id);
 return ResponseEntity.status(HttpStatus.OK).body(user);
 }catch(Exception e){
 return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
 }
 }
 
 }
 “,
 - “keyword”: “Spring Rest”,
 - “frequency”: 5,
“id”: 232,
- “question”: “What is difference between path variable and query param?”,
  - “answer”: “
    PathVariable is a MUST-HAVE parameter in URL. Query Param is more like for optional parameters.
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 4,
“id”: 236,
- “question”: “What will happen after clicking the URL?”,
  - “answer”: “
    How is application deployed?
    \tFor example, when you deploy amazon application to amazon.com, the application is deployed on a server with a static URL, that static URL is mapped to the domain name amazon.com, the mapping is managed by DNS(Domain Name System), so when someone click domain amazon.com, the DNS will find mapping and redirect to the original static URL.
    
    What happens after clicking a URL?
    1. browser will parse the URL, find protocol (http or https), domain name, path, query parameter etc.
    2. browser will call to check DNS to find the IP address for the application for the URL domain.
    3. browser will attempt to visit the original URL and build the connection
    4. The request will goes through security layer, and then to controller, service, repository and then to database
    5. the data comes back as a response will go back to the browser
    6. the browser will render the view
    “,
  - “keyword”: “Spring Rest”,
  - “frequency”: 4,

Spring Security

“id”: 201,
- “question”: “How does JWT work?”,
  - “answer”: “
    JWT is to a tool that you don’t need to keep login with your username and password.
    
    JWT token has 3 parts, the header, payload body and signature. The header contains the type of the token and the algorithms such as SHA256. The payload body contains the user data like username and userrole etc. The signature is to a string used to verify the payload data.
    
    Flow:
    1. User login with username and password, the backend will validate and create a JWT token.
    2. The token is sent back to frontend and stored in the Cookie.
    3. Subsequent requests come with the cookie and the JWT token is passed in the request header.
    4. The token will be validated to check if user is authenticated.
    5. The token expiration time can be extended.
    You dont have to store the token in database, but if you want to persist it or set the expiration time, you can store it in the database.
    “,
  - “keyword”: “Spring Security”,
  - “frequency”: 5,
“id”: 211,
- “question”: “Have you used security? how do you protect your rest api? how do you protect your application?”,
  - “answer”: “
    What: We use spring security.
    How: We override the spring framework WebSecurityConfigureAdaptor and its many configure method. We can use JdbcAuthentication, InMemoryAuthentication etc and Store the user credentials in the UserDetails object. We can also use BCrypt to encode the password and JWT token to do validations. We can use use antMatcher to let certain URLs only be accessed by certain User Roles.
    Ways for authentication and Authorization:
    - UserNamePassword authentication: When user fill username password in frontend, we can encode their password and validate with database or check if credentials match in UserDetails object.
    - JWT token, if the user is validated, we can use JWT token to validate the subsequent requests so user won’t need to to enter credentials anymore for a validate token period. The JWT token is stored in cookie and will be passed along every request. Each token can have an expiration time and can be extended. The token does not have to be saved to database.
    - Oauth2: we can also use Oauth2 to do authorization, it is 3rd part authorization, just like login with google, :login with facebook` etc. You first request 3rd party to get authentication token and then use that authentication token to get authorization access.
    - Asymmetric Key pair, also called public key and private key. Many online portal uses it, just like AWS SDK.
    - Remember-Me feature, it is just to let user choose to let application remember the credentials and store the settings in the user cookie
    - Authorization: can use AntMatcher to do authorization for certain roles.
    “,
  - “keyword”: “Spring Security”,
  - “frequency”: 5,

SQL

“id”: 31,
- “question”: “Different type of Joins”,
  - “answer”: “
    Supposed you have table A 100 records, table B 50 records, they match by 20 records
    1. Inner/Equi Join: the match part (like: where a.id = b.ta_id), should be 20 records
    2. Left Join : match plus remaining of left side table, if A left join B, then return 100, if B left join A, then return 50
    3. Right Join, match plus remaining of right side table. A left join B = B right join A
    4. Full Outer Join: match plus remaining of A and B, 20 + 80 + 30 = 130
    5. Cross Join: Each row of A join Each row of B: 100 * 50 = 5000
    6. Self Join: A self Join A, treat as 2 tables, A1, A2, so A self join is like A1 join A2
    “,
  - “keyword”: “SQL”,
  - “frequency”: 5,
“id”: 33,
- “question”: “Write a query: find the most popular product of one month”,
  - “answer”: “
    Analysis:
    most popular –> appear most times –> max count –> find count and order, GROUP BY always needed for aggregate function
```
SELECT p.name, count()\nFROM product p\nWHERE p.month = ‘GivenMonth’\nGROUP BY p.name.  //group by name –count by name, field must appear in select caluse\nORDER BY count() DESC //order in desc of count\nLIMIT 1 // just find top1\n
```
    “,
  - “keyword”: “SQL”,
  - “frequency”: 0,
“id”: 34,
- “question”: “What is normalization and denormalization? Give a example”,
  - “answer”: “
    Normalization is to make every data a single cell so there will be no mess up in data, like Address is consisted of street, city, state, zip. You should have 4 columns instead of just one address column in database, this is called normalization. Data normalization should be done to all data to make sure you can write SQL easily (like if you want to join on zipcode, you just read zipcode column)
    Denormalization is opposite, if you have street, city, state, zip 4 columns, you add 1 more column called address which is combination of all 4 columns. So if you want to find address, you can just call address column instead of concatenation of 4 columns. Denormalization is for convenience.
    
    “,
  - “keyword”: “SQL”,
  - “frequency”: 1,
“id”: 35,
- “question”: “Is the primary key unique? Difference between the primary key and unique key”,
  - “answer”: “
    Primary Key must be Unique. Unique key may not be primary key
    For example, User table, UserID is primary key, it must be unique. UserEmail and SSN are also unique, but it is not primary key
    “,
  - “keyword”: “SQL”,
  - “frequency”: 2,
“id”: 38,
- “question”: “Explain the ACID concepts”,
  - “answer”: “
    ACID is the design principle for SQL relational database.
    A: atomicity: means every transaction to database should be atomic, should be as a whole operation. If there is any failure inside, the whole transaction should rollback.
    C: Consistency. Data should be consistent. It should not violate any rules of the database constraints.
    I: Isolation, it refers to the isolation level, like READ_COMMITTED, READ_UNCOMMITED. The READ_COMMITTED level means you can only read the data that is already committed.
    D: durability: when there is system crash or node failure, the data should still be available.
    “,
  - “keyword”: “SQL”,
  - “frequency”: 5,
“id”: 39,
- “question”: “What kind of database did you use and how do you communicate with the DB”,
  - “answer”: “
    Ways to communicate with database: JDBC, JPA, HIBERNATE, MYBATIS etc
    “,
  - “keyword”: “SQL”,
  - “frequency”: 5,
“id”: 355,
- “question”: “Find the 2nd largest salary in employee table”,
 - “answer”: “
 SOLUTION 1 (best for highest, 2nd highest, not good for 3rd, 4th etc, need to understand subquery)
```
SELECT MAX(salary) FROM employee WHERE salary < (SELECT MAX(salary) FROM employee);\n
```
 SOLUTION 2: (best for Kth highest. need to understand OFFSET, LIMIT)
```
SELECT DISTINCT salary FROM employee ORDER BY salary DESC OFFSET 1 LIMIT 1\n
```
 “,
 - “keyword”: “SQL”,
 - “frequency”: 0,
“id”: 356,
- “question”: “Find employee whose salary is higher than its own manager (only given employee table which contains employee id and its manager id)”,
  - “answer”: “
    Employee (id, name, salary, managerId)
    KEY: we need to get employee salary and manager salary from same table, it is SELF JOIN, when do SELF join, we can always treat Employee as 2 tables, employee and manager
```
SELECT emp.name\nFROM employee emp\nJOIN employee mgr\nON emp.managerId = mgr.id\nWHERE emp.salary > mgr.salary;\n
```
    “,
  - “keyword”: “SQL”,
  - “frequency”: 0,
“id”: 378,
- “question”: “Given employee table contain employee id, name, salary and manager id, find the employee whose salary is higher than their manager.”,
  - “answer”: “
    When you are asked to compare data inside same table, that is SELF join, the key to do self join is to treat the table as 2 tables.
```
SELECT emp.name, mgr.name AS manager, emp.salary, mgr.salary AS manager_salary\nFROM employee emp\nJOIN employee mgr\nON emp.managerId = mgr.id\nWHERE emp.salary > mgr.salary;\n
```
    Here, i treat emplyee table as 2 tables, one is employee and another is manager, the SQL becomes very clear.
    “,
  - “keyword”: “SQL”,
  - “frequency”: 4,
“id”: 316,
- “question”: “SQL how to delete duplicate rows, only keep unique rows”,
  - “answer”: null,
  - “keyword”: “SQL”,
  - “frequency”: 0,
“id”: 328,
- “question”: “SQL: Given 2 tables, find the data in both of table that not matching each other”,
  - “answer”: null,
  - “keyword”: “SQL”,
  - “frequency”: 0,
“id”: 341,
- “question”: “String literal and new and intern() objects”,
  - “answer”: “
    String str = abc. //constant pool create abc and str is referring pointing to abc
    String str1 = abc // since abc already in constant pool, so str1 just point to it, so there is only abc and str and str1 both point to the same one
    String str2 = abc.intern() //inter() will create a copy and put in constant pool, but since abc is already in constant pool, it will not create the copy, so str, str1, str2 point to same abc
    String str3 = new String(abc) // new String() always create a new Object in heap memory, not in constant pool.
    In the end, str, str1, str2 all point to same abc in constant pool. str3 point to new heap memory string
    “,
  - “keyword”: “String”,
  - “frequency”: 5,
“id”: 342,
- “question”: “Why is String immutable in Java?”,
  - “answer”: “
    1. String use constant pool, once you put one string object in the constant pool, that object cannot be changed, if you try to change it, you will end up create new string instead of modifying it.
    2. String is made immutable because it can be used to hold security information like database credentials, user credentials, tokens etc, these information should not be changed.
    3. String is made immutable because it can be used as cache. Like when use String as map key, the hashcode will be cached as string, so when you call map.get(key) you dont need to calculate hashcode everytime.
    4. String is made immutable so that it is thread safe.
    “,
  - “keyword”: “String”,
  - “frequency”: 4,

System

“id”: 28,
- “question”: “How much load can your API handle at the same time? What is your RPS”,
  - “answer”: “
    RPS: Requests per second is a metrics measuring how many requests per second.
    If your project is internal, it will be very minimal, you can have 1-10 requests at the same time and about 1-10 RPS
    if your project is not ecommerce, like insurance or bank, and if it is nation-wide, it could be 100 RPS.
    If your project is ecommerce or bank transactions, it could be very high, like 1000 or more RPS.
    For example, if you work on amazon or walmart or ebay or mastercard, chase bank, it is very busy, it could have 10,000 RPS.
    If you work in cvs, Geico etc, it could be up to 100 RPS
    
    “,
  - “keyword”: “System”,
  - “frequency”: 4,
“id”: 205,
- “question”: “When your frontend or rest api loads slowly, how do you solve it?”,
  - “answer”: “
    Performance issue always can be answered from below points, you can address it from frontend to backend and then database
    Frontend:
    - If the request contains large amount of data, you can always split it into pages, just like Google display results in many pages, each page only has 50 records.
    - Use cache. If a page is visited or some data is previously loaded, cache it out, when load the page or data again, just use Cache.
    Backend:
    - Use pagination - same as frontend, Spring has PagingAndSortingRepository which can do pagination of the large dataset.
    - Use cache, if the data is not changing on every request, we can always cache it out to reduce calls to database
    - Use fast data retrieval tools, like Elastic Search, it will index the data and data reading very fast.
    - Use inspection tools, like JProfiler, DataDog etc to reduce unnecessary calls to database.
    - Improve the time complexity of the code.
    Database:
    - Improve SQL, use tools like Oracle Explain Plan to analyze the SQL performance, optimize the query and change joining order to improve SQL.
    - Add index to database tables, if a column is frequently used in SQL, we can add non-cluster index on the column
    - Combine multiple SQL calls into a stored procedure, so backend only call stored procedure once instead of calling multiple SQLs.
    “,
  - “keyword”: “System”,
  - “frequency”: 5,
“id”: 207,
- “question”: “How to monitor the status of the application? / What dependency is used when monitoring the application?”,
  - “answer”: “
    Many tools to monitor
    Splunk: Use as application log file, can also use splunk SQL to search log, good for production
    CloudWatch: AWS tool, can track system memory usage, CPU usages, traffic, alerts etc
    DataDog: Performance and Analytics tools, can be used to record metrics, like Active Users, Requests, CPU, Memory usages. Also can be used for logs. Also used to traces, like availability and latency etc.
    JProfiler: Tool to for Java applications, can be used to check performance bottleneck, CPU usages, memory leaks and thread issues etc.
    Spring Actuator: Spring boot provided actuator tool with many endpoints to show the health of one service, like /metrics and /health and /info
    
    For Microservice
    Eureka: Service discovery, can be used to register services and check their running status.
    
    “,
  - “keyword”: “System”,
  - “frequency”: 5,
“id”: 209,
- “question”: “How do you use cache in your whole project?”,
  - “answer”: “
    Also refer to the problem of how do you improve performance
    Cache can be used directly based on different applications.
    Frontend, you can cache the page out, you can also cache the data out, so the whole page will be cached.
    Backend
    - Inside Java, you can use java native cache, just like static hashmap can cache data as key-value entries
    - For application level or microservices, you can use distributed cache, like Redis or MemCached.
    “,
  - “keyword”: “System”,
  - “frequency”: 3,
“id”: 237,
- “question”: “Ways to connect to database”,
  - “answer”: “
    1. JDBC - the basic way to connect to database, use statement/preparedStatement/callableStatement to run SQL direclty, use RestSet to host data. JDBC is the core for all other connections
    2. Hibernate - ORM framework. Use ORM so you dont need to write statement, SQL and ResultSet. Use Session and SessionFactory to do CRUD. Has 3 types of cache.
    3. Spring Data JPA - build on top of Java JPA. Use ORM framework as internal mapping tools and Use Naming Convention to do CRUD.
    “,
  - “keyword”: “System”,
  - “frequency”: 4,
“id”: 40,
- “question”: “If you have error, but it is not showing in log, how do you debug and find it.”,
  - “answer”: null,
  - “keyword”: “System”,
  - “frequency”: 4,

Test

“id”: 240,
- “question”: “What kind of test experience do you have?”,
  - “answer”: “
    Unit test: Junit, mockito, powermock – test each method, this is method level. The way to write unit test is to define a hard code input and call the target method and then verify if the result is correct using assert.
    Automation test: Selenium, Cucumber, TestNG
    Regression test: is to make sure the new part of code does not break the existing functions
    Integration test: is to make sure the new parts interacts/works well with the other parts.
    End to End test: is to make sure the entire workflow works from beginning to end.
    
    Regression/Integration/End2End tests are just different type of tests, they are mostly implemented by Selenium and Cucumber or TestNG.
    “,
  - “keyword”: “Test”,
  - “frequency”: 5,

“id”: 245,

“question”: “Cucumber and its annotations / How cucumber works, give an example”,

“answer”: “

When they ask what test framework have you done, always mention Junit/Mockito and Selenium/Cucumber

Feature file defines test scenarios like below, it uses keyword like scenario, given, when, and, then:

Feature: Login Functionality\n  Scenario: Successful login with valid credentials\n    Given the user is on the login page\n    When the user enters a valid username and password\n    And clicks the login button\n    Then the user should be redirected to the dashboard page\n

The step definitions file uses annotations like @Given @When @Then to write test cases. @Given is for given conditions, @When is for input @Then is for result.

For example for login, @Given is user is at the login page, @When is a method when user enters the credentials and click login, @Then will be a method to verify the user enters homepage.

these annotations use brackets to include the feature file steps

\n    @Given(the user is on the login page)\n    public void the_user_is_on_the_login_page() {\n        System.setProperty(webdriver.chrome.driver, /path/to/chromedriver);\n        driver = new ChromeDriver();\n        driver.get(https://example.com/login);\n    }\n\n\n    @When(the user enters a valid username and password)\n    public void the_user_enters_a_valid_username_and_password() {\n        driver.findElement(By.id(username)).sendKeys(validUsername);\n        driver.findElement(By.id(password)).sendKeys(validPassword);\n    }\n\n\n    @When(clicks the login button)\n    public void clicks_the_login_button() {\n        driver.findElement(By.id(loginButton)).click();\n    }\n\n\n    @Then(the user should be redirected to the dashboard page)\n    public void the_user_should_be_redirected_to_the_dashboard_page() {\n        String expectedUrl = https://example.com/dashboard;\n        String actualUrl = driver.getCurrentUrl();\n        Assert.assertEquals(actualUrl, expectedUrl);\n        driver.quit();\n    }\n}\n\n\n

“,

“keyword”: “Test”,
“frequency”: 5,

“id”: 239,
- “question”: “Functional test & Integrtion test & Unit test”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 241,
- “question”: “What’s the test framework in your team?”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 242,
- “question”: “Talk about Mockito and give an example”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 243,
- “question”: “Talk about different test you did before”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 244,
- “question”: “JUnit vs. Automation”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 246,
- “question”: “What is the limitation of the Mockito?”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 247,
- “question”: “Can you mock a static field using Mockito?”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 248,
- “question”: “How to test a private method without other framework?”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 304,
- “question”: “Difference: InjectMock vs InjectMockBean”,
  - “answer”: null,
  - “keyword”: “Test”,
  - “frequency”: 0,
“id”: 326,
- “question”: “Unix/Linux: list java process, kill a process, search a file”,
  - “answer”: null,

Pilot Training Questions

Mock

Self - Introduction

Work/Project Summary

15 behavioral questions

1. Why did you leave your last job?

2. Describe a major conflict within or outside your team and how you handled it, or how you dealt with a difficult team member.

3. Describe a time when you had difficulty completing a task or making progress.

4. If your manager asks you to change something that you think is already good enough, how would you handle it?

5. Why do you want to join our team?

6. Are you familiar with Agile / ˈædʒ(ə)l / processes and Waterfall methodology / ˌmeθəˈdɑːlədʒi /?

7. What does a typical day look like for you?

8. What do you think are the most important factors for a successful team ?

9. If you are working on a sprint and your manager suddenly assigns you a new task that needs to be finished as soon as possible, what would you do?

10. Tell me something about yourself that is not on your resume.

11. Tell me about a difficult project or challenge you faced and how you handled it.

12. Share a time when you made a mistake in a team setting, how you resolved it, and what you learned from the experience.

13. Do you have on-call experience, and are you comfortable with overnight on-call duties?

14. Do you know what pair programming is, and what are your thoughts on it?

15. If you are mentoring a junior colleague and they propose a new idea to the team, how would you handle it?

16. Describe your code review process. What do you focus on during a code review?

Leetcode

Rest API

Top100

my own answer

Misc

Java

Kafka

Microservice

Database

SpringBoot

SpringCore

SpringRest

BQ

CICD

Cloud AWS

Docker

ElasticSearch

Git

Java

JDBC

Kafka

Microservice

NoSQL

OOP

Spring Boot

Spring Core

Spring JPA

Spring Rest

Spring Security

SQL

System

Test

6. Are you familiar with Agile `/ ˈædʒ(ə)l /` processes and Waterfall methodology `/ ˌmeθəˈdɑːlədʒi /`?