DEV Community: Thailane

What is Spring Boot and what are its advantages?

Thailane — Mon, 09 Sep 2024 18:55:14 +0000

Brief history

Spring came into being in 2003 as a response to the complexity of the early J2EE specifications. While some consider Java EE and its modern-day successor Jakarta EE to be in competition with Spring, they are in fact complementary. The Spring programming model does not embrace the Jakarta EE platform specification; rather, it integrates with carefully selected individual specifications from the traditional EE umbrella.

Spring Boot is a project within the Spring ecosystem that helps us create standalone applications that do not rely on anything else; they work on their own, with the only requirement being Java, which must be installed for them to function. Spring Boot assists with infrastructure tasks, managing the configuration of our project’s infrastructure, especially with the initial setup needed to start coding and implementing business logic, allowing for a more organized project and easier deployment to production.

Some advantages of Spring Boot:

Convention Over Configuration: Spring Boot configures the project based on conventions it adopts. For example, if you want to use JPA, it already includes a dependency that adds sub-dependencies, such as the JPA API, what’s needed for RabbitMQ, etc. The versions of these sub-dependencies are already compatible with each other, tested by the entire Spring Boot community and team. Besides this example, there are a series of dependencies you can configure for your project.
Embedded Server: Spring Boot comes with an embedded server, with Tomcat being the default. This greatly simplifies development because you don’t need to download a server, and it also simplifies production since you don’t need to have or download a server. You can simply take the application, deploy it to production, and have an embedded server ready to run the application.
Organized POM.XML: If you use Maven, you know the POM can sometimes get messy, but with Spring Boot, it’s easier to keep the pom.xml organized. You avoid adding multiple dependencies and checking if they are compatible with each other.
DevTools: Spring Boot provides DevTools, which automatically restarts the project upon any changes made. It also allows for some convenient configurations for development without manually setting them in the application.properties (the configuration file). For HTML page caching, DevTools disable it, so you don’t need to restart the application when making changes to HTML.
LiveReload Integration: When an HTML page is modified, the cache is disabled, and LiveReload integration is enabled, so when returning to the browser, there’s no need to press F5; it updates automatically.
Metrics Analysis: Spring Boot includes the Actuator dependency, which helps monitor and manage the health of the application, allowing you to view and monitor resource usage, especially on production servers. It does this without generating source code lines, and you can customize it just like any other project without Spring Boot. It will detect your configurations and avoid applying its own.

STS IDE: This IDE helps with any Spring ecosystem project, including Spring Boot. For instance, if you want to create a Spring Boot project using STS, you only need to select the “start project” option in the IDE, fill in the required details, select the dependencies you want, and it will download and configure the project, making it ready to use.

Package Generation: Spring Boot generates a JAR package, but it’s a JAR with its own specific structure needed for the standalone setup. It includes the source code, dependencies, and the embedded server, but the command to run this JAR is the same as running any other JAR:

   java -jar target/something-api-1.0.0-SNAPSHOT.jar

These are some of the great features of Spring Boot that can make you a more productive developer and make working with Spring Boot easier in your day-to-day tasks.

Reference: https://spring.io/projects/spring-boot

Fundamental Questions of Java

Thailane — Sun, 25 Aug 2024 21:55:20 +0000

Java was first released by Sun Microsystems in 1995. The development of Java began in the early 1990s, led by James Gosling and his team. The language was originally called "Oak" but was later renamed "Java" after a type of coffee.
Java was created to address the need for a platform-independent programming language that could be used to create software that could run on any device, regardless of the underlying hardware or operating system. The primary goal was to allow developers to "write once, run anywhere," meaning that code written in Java could run on any platform that supported the Java Virtual Machine (JVM).
Java's design focused on simplicity, portability, and security, making it suitable for a wide range of applications, from web development to enterprise software. It quickly gained popularity due to its versatility and the ability to build robust, high-performance applications across different platforms.

Being one of the most widely used languages in software development today, and having studied it for a long time, I've gathered here some questions and answers about the wonderful world of Java.

Hated by many, but loved by others.

Questions

1. What is the difference between JDK and JRE?

The JDK( Java Development kit ) is used by developers for creating Java applications and includes the necessary tools, libraries, and compilers. The JRE (Java Runtime Environment) is used by end-users to run Java applications and provides the runtime environment and essential class libraries, but does not include development tools.

2. What are the benefits of using Java?

These are benefits of using Java:

Portability: Java code can be run on any platform that has a Java Virtual Machine (JVM).
Security: Java has a built-in security model that helps to protect users from malicious code.
Object-oriented: Java is an object-oriented programming language, which makes it easy to create modular and reusable code.
Robust: Java is a robust language that is designed to be reliable and efficient.
Widely used: Java is a Widely used language that has a large community of developers and support resources.

3. What are the different components of the Java Platform?

The Java Platform is a software environment that provides a standard way for developing and running Java applications. It consists of the following components:

Java Virtual Machine (JVM).
Java Runtime Environment (JRE).
Java Development kit (JDK).

4. What are the different types of Java data types?

There are two types of data types in Java: primitive data types and non-primitive data types.

Primitive data types

boolean
byte
short
int
long
float
decimal places
double
char

Non-primitive data types

String
Array
Class
Interface
Enum

5. What are the different types of Java control statements?

There are three types of control statements in Java:

Decision-making statements (if, if else & switch).
Looping statements (while, do while & for).
Jump statements (continue & return).

6. What are the different types of Java classes & Java interfaces?

There are two main types of Java classes:

Normal classes are the most common type of class in Java. They can have fields, methods, and constructors.
Abstract classes are classes that cannot be instantiated. They can only be used as a base class for other classes.

There are also two main types of Java interfaces:

Normal interfaces are a collection of abstract methods. A class can implement an interface, thereby inheriting the abstract methods of the interface.
Maker interfaces are interfaces that do not contain any methods. They are used to indicate that a class has a certain property or behavior.

7. What are the different types of Java libraries & Java frameworks?

A Java library is a collection of reusable Java classes and interfaces.

** Some examples of Java libraries:**

Apache Commons
Google Guava
Joda-Time
JUnit
Mockito

A java framework is a collection of reusable Java classes, interfaces, and code that provides specific functionality.

Some examples of Java libraries:

Spring
Hibernate
JSF
Grails
Struts

8. What are the different types of Java tools?

There are two types of threads in Java: user threads and daemon threads.

User threads are the threads that are created by the user or application. They are high-priority threads and the JVM will wait for any user thread to finish its task before terminating it.
Daemon threads are the threads that are created to provide services to user threads. They are low-priority threads and are only needed while user threads are running. Once all user threads have finished their execution, the JVM will terminate even if there are daemon threads still running.

9. What are the different types of Java networking?

There are two main types of Java networking:

Client-server networking is a type of networking where there is a client application that requests a service from a server application. The server application then provides the service to the client application.
Peer-to-peer networking is a type of networking where two or more applications communicate directly with each other without the need for a server.

10. What is the difference between Procedural programming and OOP?

Procedural programming is a top-down approach to programming, where the program is divided into a series of functions that each perform a specific task.
OOP, on the other hand, is a bottom-up approach to programming, where the program is divided into objects that each represent a real-world entity.

11. What are the core concepts of OOP?

The core concepts of OOP are:

Abstraction: Abstraction is the process of hiding the implementation details of an object from the user. This allows the user. This allows the user to focus on the object's functionality wthout having to worry about how it works.
- Encapsulation: Encapsulation is the bundling of data and codes into a single unit. This makes it easier to maintain and update the code, and it also makes it more difficult for users to accidentally modify the data.
- Inheritance: Inheritance is the ability of an object to inherit the properties and methods of another object. This allows developers to reuse code and create more complex objects with fewer lines of code.
- Polymorphism: Polymorphismis the ability of an object to bahave differently depending on its context. This allows developers to write code that is more flexible and easier to maintain.

12. What is the difference between Overloading and Overriding?

Overloading refers to the ability to have multiple methods with the same name, but different parameters.
Overriding refers to the ability to have a method in a subclass that has the same signature as a method in a superclass.

13. What is the difference between static and dynamic binding?

Static binding and dynamic binding are two different ways of resolving function calls in object-oriented programming (OOP).

-Static binding: occurs when the compiler determines the method to be called at compile time. This is the most common type of binding in OOP, and it is used for both static and non-virtual methods.

-Dynamic binding: occurs when the method to be called is not determined until runtime. This is used for virtual methods, which allow for polymorphism.

14. Why Java doesn't support Multiple Inheritance?

Java doesn't support multiple inheritance because it can lead to a number of problems, including:

Ambiguity.
Circular dependencies.
Complexity.

15. When do you use interface and abstract class in Java?

Abstract classes and interfaces are both used to achieve abstraction in object-oriented programming.

Abstract classes are similar to normal classes, with the difference that they can include abstract methods, which are methods without a body. Abstract classes cannot be instantiated.
Interfaces are a kind of code contract, which must be implemented by a concrete class. Interfaces cannot have state, whereas the abstract class can have state whith instance variables.

16. What are the challenges of using OOP in Java?

There are some challenges associated with using OOP in Java.
These challenges include:

Complexity: OOP can make code more complex, especially when dealing with large and complex systems.
- Overhead: OOP can add some overhead to code, as objects need to be created and managed.
- Testing: OOP can make code more difficult to test, as objects need to be tested in isolation and in combination.
- Performance: OOP can impact performance, as objects can add some overhead.

17. What is the difference between an array and a linked list?

In general, arrays are good choice for data structures where the data is accessed frequently and the order of the data is important.

Linked lists are a good choice for data structures where the data is inserted or deleted frequently and the order of the data is not important.

18. Explain the concept of a hash table.

A hash table is a data structure that maps keys to values. It is a very efficient data structure for storing and retrieving data, as it can access data in constant time.

put(key, value): This method stores the key-value pair in the hash table.
get(key): This method returns the value associated with the key.
remove(key): This method removes the key-value pair from the hash table.

19. What is the time complexity of various operations in a binary search tree (BST)?

The time complexity of various operations in a binary search tree (BST) depends on the height of the tree. The height of a BST is the number of nodes on the longest path from the root node to a leaf node.

The following table shows the time complexity of various operations in a BST:

               Operation---------------Time complexity

20. Describe the difference between breadth-first search (BFS) and depth-first search (DFS) algorithms.

Here is a table that summarizes the key differences between BFS and DFS:

21. Explain the concept of a priority queue and provide an example of its application.

A priority queue is a data structure that stores elements along with their associated priorities. It allows efficient retrieval of the element with the highest (or lowest) priority. The priority determines the order in which elements are processed or accessed.

22. Explain the concept of dynamic programming and provide an example problem where it can be applied.

Dynamic programming is a problem-solving technique that involves breaking down complex problems into smaller, overlapping subproblems and solving them in a bottom-up manner.

23. How does a HashSet work internally in Java?

A HashSet internally uses a HashMap to store its elements. When you add an element to a HashSet, it is first hashed using the hashCode() method.
The hash code is then used to find the corresponding bucket in the HashMap. If the bucket is not empty, the element is compared to the other elements in the bucket using the equals() method. If the element is equal to any of the other elements in the bucket, it is not added to the HashSet.

24. What is the time complexity of various operations in a hash table?

The time complexity of various operations in a hash table depends on the hash function used and the number of elements in the hash table. In general, the time complexity of the following operations is:

Isertion: O(1) on average, O(n) in the worst case.
Search: O(1) on average, O(n) in the worst case.
Deletion: O(1) on average, O(n) in the worst case.

25. What is multithreading, and why is it important in Java?

Multithreading is a programming concept that allows multiple tasks to be executed concurrently. In Java, multithreading is implemented using the thread class. A thread object represents a single thread of execution.

There are many reasons why multithreading is important in Java.
Some of the most important reasons include:

Increased performance.
Improved responsiveness.
Reduced resource usage.

26. How can you create a thread in Java?

There are two ways to create a thread in Java:

By extending the thread class
By implementing the Runnable interface

27. What is the difference between a process and a thread?

A process is a program in execution. It has its own memory space, its own stack, and its own set of resources.
A thread is a lightweight process that shares the same memory space and resources as other threads in the same process.

Some of the key differences between processes and threads:
- Processes are independent of each other.
- Processes are heavier than threads.
- Processes are more difficult to create and manage than threads.

28. How does synchronization work in Java? Explain the concepts of synchronized methods and blocks.

Synchronization in Java is a mechanism that allows multiple threads to access shared resources safely. When a thread is synchronized on a resource, it is the only thread that can access that resource.
This prevents race conditions, which are situations where two or more threads are trying to access the same resource at the same time.

There are two ways to synchronize in Java:

Using synchronized methods.
Using synchronized blocks.

Synchronized methods:

A synchronized method is a method that can only be executed by one thread at a time. To declare a method as synchronized, you need to use the synchronized keyword.

Synchronized blocks

A synchronized block is a block of code that can only be executed by one thread at a time. To declare a block of code as synchronized, you need to use the synchronized keyword and specify the object that the block is synchronized on.

29. What is a deadlock, and how can it be avoided?

A deadlock is a situation where two or more threads are waiting for each other to finish. This can happen when two threads are each trying to acquire a lock on the same resource.

To avoid deadlocks, we can do this:

Avoid using locks unnecessarily.
Use locks in a consistent order.
Use deadlock detection and prevention tools.

30. What is the purpose of the volatile keyword in Java?

The volatile keyword is used to ensure that all threads see the same value of a variable, even if the value is changed by another thread.

31. Explain the difference between preemptive scheduling and time-slicing in the context of thread scheduling.

Preemptive scheduling is when the operating system can forcibly remove a thread from the CPU and give it to another thread. Time-slicing is when each thread is given a certain amount of time to run on the CPU.

The main difference is that in preemptive scheduling, the operating system can interrupt a thread at any time, while in time-slicing, the thread is only interrupted when it has used up its allotted time.

32. What is an exception in Java, and why is exception handling important?

In Java, an exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. It is an object which is thrown at runtime.

Here are some of the benefits of exception handling:

Prevents program crashes.
Allows you to recover from errors.
Provides information about the error.
Makes your code more robust.
Makes your code easier to read and understand.

33. How does Java handle exceptions.

Java handles exceptions by using a mechanism called exception propagation. When an exception is thrown, it is propagated up the call stack until it is caught. If the exception is not caught, the program will crash.

34. Describe the try-catch-finally block and its purpose in exception handling.

The try-catch-finally block is a Java syntax that allows you to handle exceptions gracefully. It consists of three parts:

The try block.
The catch block.
The finally block.

Here are some of the benefits of using try-catch-finally blocks:

Prevents program crashes.
Allows you to recover from errors.
Provides information about the error.
Makes your code more robust.
Makes your code easier to read and understand.

35. What is the difference between the throw and throws keywords in Java?
The throw and throws keywords in Java are used to handle exceptions.

The throw keyword is used to explicitly throw an exception
The throws keyword is used to declare that a method can throw an exception.

36. How can you create custom exceptions in Java?

To create a custom exception in Java, you need to create a class that extends the Exception class. The custom exception class can have its own constructors, methods, and fields.

References: https://medium.com/@spinjosovsky/practical-comparison-between-depth-first-search-dfs-vs-breadth-first-serch-bfs-bf360240cf72
https://docs.oracle.com/en/java/
https://www.algotutor.io/campus-program

MERN Stack Guide

Thailane — Wed, 21 Aug 2024 19:33:23 +0000

What is MERN Stack?
MERN Stack is a JavaScript Stack that is used for easier and faster deployment of full-stack web applications. MERN Stack comprises of 4 tecnnologies namely: MongoDB, Express, React, and Node.js. It is designed to make the development process smoother and easier.
The MERN architecture allows you to easily construct a 3-tier architecture(frontend, backend, database) entirely using JavaScript and JSON. Using these four technologies you can create absolutely any application that you can think of everything that exists in this world today. Now let's understand each technology one by one.

MongoDB: MongoDB forms the M of the MERN stack and works pretty well with the JavaScript ecosystem. MongoDB is a NoSQL database in a which data is stored in documents that consist of key-value pairs, sharing a lot of resemblance to JSON.

The data is not stored in the form of tables and that's how it differs from other database programs. This is how the data stored in MongoDB looks like:

Express: Express is a flexible and clean Node.js web application framework that provides a robust set of features to develop web and mobile applications. It facilitates the rapid development of Node based web applications.
Express helps build the backend very easily while staying in JavaScript ecosystem. It is preferred for self-projects as it helps focus on learning development and building projects pretty fast.
In MERN stack, Express will be used as backend API server which interacts with mongoDB database to serve data to client ( React ) application.

React JS: React is an open-source JavaScript library that is used for building user interfaces specifically for single-page applications. It's used for handling the view layer for web and mobile apps.
React lets you build up complex interfaces through simple Components, connect them to data on your backend server, and render them as HTML.
Almost all the modern tech companies from early-stage startups to the biggest tech companies like Microsoft ad Facebook use React.
The prime reason why react is used, is for Single Page Applications(SPA). SPA means rendering the entire website on one page rather than different pages of the websites.

Node JS NodeJs is a cross-platform JavaScript runtime environment, it's built on Chrome's V8 engine to run JavaScript code outside the browser, for easily building fast and scalable applications.
The main purpose of NodeJS is simple, it allows us to write our backend in JavaScript, saving us the trouble of learning a new programming language capable of running the backend.
Node.js is the platform for the application layer ( logic layer). This will not be visible to the clients. This is where client applications (React) will make requests for data or webpages.

Creating a MERN project

Prerequisites Installation:

Node.js and npm
MongoDB

Create the Backend with Node.js and Express:

Initialize the Project:

mkdir my-project
cd my-project
npm init -y

Install Backend Dependencies:

npm install express mongoose

Mongoose: Library that simplifies interaction with MongoDB.

Set Up the Server:

Create a file called server.js and add the basic server configuration:

Create the Frontend with React:

Create the React Application:

npx create-react-app client
cd client
npm start

This will create a React application in the client folder.
Connect the Frontend to the Backend:
In the frontend, you can use fetch or axios to make requests to the backend created with Node.js/Express.

Connect the Frontend to the Backend:

In the React application, make HTTP requests to the backend to fetch or send data. For example:

Run the Complete Project:

Backend: In the root directory of the project (where server.js is located), run:

node server.js

Frontend: In the client directory, run:

npm start

Now you have a basic project up and running with the MERN Stack!

Don't forget to configure environment variables to protect sensitive code information

References: https://www.mongodb.com/resources/languages/mern-stack-tutorial