DEV Community: eric6166

10 Useful Prompts to Enhance Your Learning 🚀

eric6166 — Thu, 06 Feb 2025 10:38:27 +0000

In today's fast-paced digital world, learning effectively is more important than ever. Whether you're diving into a new subject, refining a skill, or seeking mentorship, asking the right questions can make all the difference. Here are 10 powerful prompts to optimize your learning journey.

📌 1. Extract the Core Knowledge

"I want to learn about [topic]. Identify and share the most critical 20% of knowledge from this topic to help me grasp 80% of its core content."

✅ Focus on the most impactful insights.

✅ Quickly gain a deep understanding of any subject.

🧠 2. Create a Mind Map

"Create a mind map for [your topic]. List the main topics as central ideas, primary branches, and sub-branches. Provide me with this mind map in plain text format."

✅ Visualize complex information efficiently.

✅ Organize key concepts logically.

🎯 3. Test Your Understanding

"After I study [topic], test my understanding with detailed questions and provide immediate feedback. Ensure the questions cover all key concepts and explain any incorrect answers clearly."

✅ Reinforce learning with practical assessments.

✅ Get clear explanations to improve weak areas.

📅 4. Design a Personalized Study Plan

"Help me design a personalized study plan to master [topic]. Break it down into daily learning tasks, recommended resources, and practical exercises to develop my skills. [Add some personal details to ensure the plan is as realistic as possible.]"

✅ Structure your learning with a step-by-step plan.

✅ Stay motivated with daily goals.

🎓 5. Get Mentorship in Your Field

"Take on the role of a mentor in [field]. Offer advice, insights, and useful tips for beginners in this field, including common mistakes and how to avoid them."

✅ Gain expert-level insights from experienced professionals.

✅ Avoid common pitfalls and fast-track your learning.

📖 6. Turn Lessons into Engaging Stories

"I'm learning about [topic]. Turn the key lessons from this topic into engaging stories and vivid metaphors to help me remember them more easily."

✅ Improve retention with storytelling techniques.

✅ Make learning fun and memorable.

💡 7. Solve Real-World Problems

"Present a problem related to [topic] and guide me step by step through brainstorming potential solutions."

✅ Develop problem-solving skills in a practical context.

✅ Learn how to think critically and creatively.

📆 8. Follow a 30-Day Skill Improvement Plan

"I want to learn/improve [desired skill]. I'm a complete beginner. Create a 30-day learning plan to help someone like me acquire and enhance this skill."

✅ Build skills progressively over a structured timeline.

✅ Stay accountable with daily tasks and exercises.

🤔 9. Challenge Your Critical Thinking

"Challenge me with a series of thought-provoking questions about [topic]. After each question, provide feedback on my response and suggest ways to improve my critical thinking on the subject."

✅ Enhance your ability to analyze and evaluate ideas.

✅ Learn how to think deeply and logically.

🗣️ 10. Teach to Learn Better

"Simulate a conversation where I have to explain [topic] to someone completely unfamiliar with it, focusing on clarity and engagement."

✅ Reinforce knowledge by teaching others.

✅ Improve communication and articulation skills.

By leveraging these prompts, you can make learning more structured, engaging, and effective. Try using them in your studies, discussions, or self-improvement plans to maximize your potential! 🚀📚

Getting Started with Spring WebFlux

eric6166 — Wed, 25 Dec 2024 08:09:07 +0000

Spring WebFlux is a reactive programming framework introduced in Spring 5. It provides a non-blocking, asynchronous programming model for building web applications, particularly suited for handling high-throughput, concurrent, and event-driven applications. WebFlux is part of the larger Spring Framework and offers an alternative to the traditional Spring MVC, which is based on a blocking programming model.

1. Core Concepts of Spring WebFlux

Reactive Programming: WebFlux is built on Project Reactor, which implements the Reactive Streams specification. Reactive programming is a paradigm for handling asynchronous data streams and non-blocking operations.
- Reactive types:
  - Mono<T>: Represents a single value or no value (0 or 1 element).
  - Flux<T>: Represents a stream of 0 to N values.

Example Mono:

Mono<String> mono = Mono.just("Hello, WebFlux!");
mono.subscribe(System.out::println); // Output: Hello, WebFlux!

Example Flux:

Flux<String> flux = Flux.just("A", "B", "C");
flux.subscribe(System.out::println);

Output:

A
B
C

Non-blocking I/O: WebFlux uses non-blocking I/O at its core, which allows threads to perform other tasks while waiting for I/O operations to complete, leading to better resource utilization.
Functional and Annotation-based API:
- Annotation-based (similar to Spring MVC): Using @Controller, @RequestMapping, etc.
- Functional programming style: Using RouterFunction and HandlerFunction.

2. Key Components of WebFlux

Reactive Streams: A specification for asynchronous stream processing with non-blocking backpressure. It ensures the producer and consumer handle data flow efficiently.
Netty: WebFlux can run on multiple servers like Netty (default for WebFlux), Tomcat, Jetty, or others. Netty is preferred for fully reactive applications.
Reactor: Spring WebFlux relies on Project Reactor to implement reactive streams (Mono and Flux).

3. Differences Between Spring MVC and Spring WebFlux

Feature	Spring MVC	Spring WebFlux
Programming Model	Blocking (Servlet API)	Non-blocking (Reactive Streams)
I/O Model	Synchronous	Asynchronous
Concurrency Model	Thread-per-request	Event-loop (few threads)
Performance	Suitable for CPU-bound tasks	Ideal for I/O-bound tasks

4. Why Use Spring WebFlux?

Scalability: Handles a large number of concurrent requests with fewer threads.
Efficiency: Ideal for applications where I/O is the bottleneck, such as:
- Streaming data (e.g., WebSockets).
- Real-time APIs.
- Applications interacting with multiple external services (e.g., REST APIs or databases).
Integration: Compatible with reactive databases (e.g., MongoDB Reactive Streams, R2DBC).

5. Example of Spring WebFlux

Annotation-based Controller

@RestController
public class HelloController {

    @GetMapping("/hello")
    public Mono<String> sayHello() {
        return Mono.just("Hello WebFlux");
    }
}

Functional Style Routing

@Configuration
public class RouterConfig {

    @Bean
    public RouterFunction<ServerResponse> route() {
        return RouterFunctions.route(
            RequestPredicates.GET("/hello"),
            request -> ServerResponse.ok().bodyValue("Hello WebFlux")
        );
    }
}

6. When to Use Spring WebFlux?

Applications requiring high concurrency and scalability.
Real-time streaming services (e.g., live notifications, chat applications).
Microservices interacting with external reactive systems.
Systems with significant I/O operations (e.g., file systems, databases).

7. Key Features of Spring WebFlux

Reactive Data Access: Works seamlessly with reactive databases (MongoDB, R2DBC).
WebSocket Support: Supports real-time communication through WebSockets.
Backpressure Handling: Ensures efficient data flow between producers and consumers.
Seamless Integration: Interoperates with other Spring modules and libraries.

8. Summary

In summary, Spring WebFlux is designed for modern applications where responsiveness, scalability, and resource efficiency are critical. It’s a great choice for I/O-heavy and reactive applications.

9. References

Spring. (n.d.). Spring Framework Reference Documentation: WebFlux New Framework. Available at: https://docs.spring.io/spring-framework/reference/web/webflux/new-framework.html.
Baeldung. (n.d.). Introduction to Spring WebFlux. Available at: https://www.baeldung.com/spring-webflux.

Understanding Database Isolation Levels: An Essential Overview

eric6166 — Wed, 04 Sep 2024 07:54:35 +0000

Database isolation levels define how transactions interact with each other in a database, particularly when multiple transactions are executed concurrently. These levels control the visibility of changes made by one transaction to other transactions before the first transaction is committed. Isolation levels are crucial for maintaining data consistency and integrity. In this article, we'll explore four primary isolation levels defined by the SQL standard - Read Uncommitted, Read Committed, Repeatable Read, and Serializable - and provide examples of how they affect transaction behavior.

1. Read Uncommitted

1.1 Definition

At this level, a transaction can read data that has been modified by other transactions but not yet committed. This is the least restrictive isolation level and allows for the highest level of concurrency.

1.2 Issues

Dirty Reads: Transactions can read uncommitted changes from other transactions, which may later be rolled back.

Example:

Transaction A: Updates the price of a product but hasn’t committed.
Transaction B: Reads the new price before Transaction A commits.
If Transaction A rolls back, Transaction B has acted on incorrect data.

1.3 Use Case

Rarely used in practice due to the risk of reading invalid data, but may be used when performance is prioritized over consistency.

2. Read Committed

2.1 Definition

A transaction can only read data that has been committed by other transactions. However, other transactions can modify data after it has been read, meaning that data may change between different reads within the same transaction.

2.2 Issues

Non-Repeatable Reads: A transaction might get different results if it reads the same data multiple times because other transactions may commit changes in between.

Example:

Transaction A: Reads a product price.
Transaction B: Updates and commits the price.
Transaction A: Reads the price again, but it’s different from the first read.

2.3 Use Case

This is the default isolation level in many databases (e.g., PostgreSQL, Oracle) and is a good balance between consistency and concurrency.

3. Repeatable Read

3.1 Definition

A transaction can read only committed data, and once a transaction reads data, other transactions cannot modify that data until the first transaction completes. This ensures that if a transaction reads the same data multiple times, it will get the same result.

3.2 Issues

Phantom Reads: New rows inserted by other transactions may appear if the transaction executes a query that returns a range of rows (e.g., using WHERE), but rows themselves cannot be modified.

Example:

Transaction A: Reads all orders from a customer.
Transaction B: Adds a new order and commits.
Transaction A: Re-reads the orders, and the new order appears.

3.3 Use Case

Useful when transactions need to ensure that data does not change between multiple reads, ensuring more consistent reads.

4. Serializable

4.1 Definition

This is the strictest isolation level, ensuring complete isolation between transactions. Transactions are executed in such a way that they appear to be executed serially, one after the other, even though they may be executed concurrently.

4.2 Issues

None: Prevents all anomalies such as dirty reads, non-repeatable reads, and phantom reads.

Example:

Transaction A: Reads all inventory items.
Transaction B: Tries to add a new inventory item but is blocked until Transaction A completes.

4.3 Performance

This level can significantly reduce performance due to the need for locks or serialization mechanisms, leading to more transaction conflicts.

4.4 Use Case

Used when data integrity is critical and no anomalies can be tolerated, but it can severely limit concurrency.

Summary

Understanding these isolation levels helps you choose the right balance between performance and consistency in database transactions. Lower levels like Read Uncommitted are faster but risk inconsistency, while higher levels like Serializable ensure data integrity at the cost of slower performance.

Performance Pitfalls: Using Hints in Oracle Database

eric6166 — Mon, 05 Aug 2024 14:00:00 +0000

In Oracle Database, hints can guide the optimizer to improve query performance. However, incorrect usage can lead to performance degradation. Here's an in-depth look at how using hints can impact performance, using a practical example.

Table and Index Creation

First, let's create a table and an index:

CREATE TABLE TRANSACTIONS
(
    TRANSACTION_ID NUMBER,
    AMOUNT         NUMBER(10, 2)
);

CREATE INDEX idx_amount ON transactions (amount);

Inserting 1 Million Records

We populate the table with 1 million records using the following PL/SQL block:

BEGIN
    FOR i IN 1..1000000
        LOOP
            INSERT INTO TRANSACTIONS (TRANSACTION_ID, AMOUNT)
            VALUES (i, ROUND(DBMS_RANDOM.VALUE(1, 99999999.99), 2));
        END LOOP;
    COMMIT;
END;

Query Performance with and without Hints

Now, let's examine two queries: one without a hint and one with a hint that forces the use of the index.

Query Without Hint

SELECT TRANSACTION_ID, AMOUNT
FROM TRANSACTIONS
WHERE AMOUNT > 50000000;

Execution Plan:

Execution Plan: Full table scan
Total Cost: 660

Query With Hint (Forcing Index Usage)

SELECT /*+ INDEX (TRANSACTIONS, IDX_AMOUNT) */ TRANSACTION_ID, AMOUNT
FROM TRANSACTIONS
WHERE AMOUNT > 50000000;

Execution Plan:

Execution Plan: Index range scan
Total Cost: 1766

Explanation

Without Hint:

The Oracle optimizer analyzes the query and decides that a full table scan is more efficient for this particular case.
Although it might seem counterintuitive, for certain data distributions and query conditions, a full table scan can be faster than using an index, especially if a large portion of the table's rows satisfy the condition.
Result: The total cost is 660, indicating a more efficient execution in this scenario.

With Hint:

The /*+ INDEX (transactions, idx_amount) */ hint forces Oracle to use the idx_amount index for the query.
An index range scan reads the index entries and then retrieves the corresponding table rows. If the index does not significantly reduce the number of rows accessed, this approach can be more expensive.
Result: The total cost is 1766, showing that using the index in this case is less efficient.

Impact of Using Hints

Using hints can sometimes optimize specific queries by guiding the optimizer. However, they should be used with caution:

Positive Impact: Hints can improve performance when the optimizer's default plan is not ideal for a specific query.
Negative Impact: Misuse of hints, like forcing an index scan when a full table scan is more efficient, can lead to significant performance degradation.

Best Practices

Test Thoroughly: Always test the impact of hints on query performance in a staging environment before applying them in production.
Understand Your Data: Know the size and distribution of your data. Indexes are beneficial for large tables with selective queries.
Monitor Performance: Use Oracle's execution plan tools to monitor and analyze the performance of your queries.

Conclusion

While hints can be powerful tools for query optimization, misuse can lead to severe performance issues. It's crucial to understand their impact and test thoroughly to ensure they improve rather than degrade performance. Always trust the optimizer's decision unless there's clear evidence that a hint will provide a better execution plan.

Creating Custom Annotations for Validation in Spring Boot

eric6166 — Wed, 24 Jul 2024 13:36:51 +0000

Creating Custom Annotations for Validation in Spring Boot

1. Overview

While Spring standard annotations (@NotBlank, @NotNull, @Min, @Size, etc.) cover many use cases when validating user input, there are times when we need to create custom validation logic for a more specific type of input. In this article, I will demonstrate how to create custom annotations for validation.

2. Setup

We need to add the spring-boot-starter-validation dependency to our pom.xml file.


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

3. Custom Field Level Validation

3.1 Creating the Annotation

Let’s create custom annotations to validate file attributes, such as file extension, file size, and MIME type.

ValidFileExtension


@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(
        validatedBy = {FileExtensionValidator.class}
)
public @interface ValidFileExtension {
    String[] extensions() default {};

    String message() default "{constraints.ValidFileExtension.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

ValidFileMaxSize


@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(
        validatedBy = {FileMaxSizeValidator.class}
)
public @interface ValidFileMaxSize {
    long maxSize() default Long.MAX_VALUE; // MB

    String message() default "{constraints.ValidFileMaxSize.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

FileMimeTypeValidator


@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(
        validatedBy = {FileMimeTypeValidator.class}
)
public @interface ValidFileMimeType {
    String[] mimeTypes() default {};

    String message() default "{constraints.ValidFileMimeType.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

Let's break down these annotations' components:

@Constraint: Specifies the validator class responsible for the validation logic.
@Target({ElementType.FIELD}): Indicates that this annotation can only be applied to fields.
message(): The default error message if the validation fails.

3.2 Creating the Validator

FileExtensionValidator

public class FileExtensionValidator implements ConstraintValidator<ValidFileExtension, MultipartFile> {

    private List<String> extensions;

    @Override
    public void initialize(ValidFileExtension constraintAnnotation) {
        extensions = List.of(constraintAnnotation.extensions());
    }

    @Override
    public boolean isValid(MultipartFile file, ConstraintValidatorContext constraintValidatorContext) {
        if (file == null || file.isEmpty()) {
            return true;
        }
        var extension = FilenameUtils.getExtension(file.getOriginalFilename());
        return StringUtils.isNotBlank(extension) && extensions.contains(extension.toLowerCase());
    }
}

FileMaxSizeValidator

public class FileMaxSizeValidator implements ConstraintValidator<ValidFileMaxSize, MultipartFile> {

    private long maxSizeInBytes;

    @Override
    public void initialize(ValidFileMaxSize constraintAnnotation) {
        maxSizeInBytes = constraintAnnotation.maxSize() * 1024 * 1024;
    }

    @Override
    public boolean isValid(MultipartFile file, ConstraintValidatorContext constraintValidatorContext) {
        return file == null || file.isEmpty() || file.getSize() <= maxSizeInBytes;
    }
}

FileMimeTypeValidator


@RequiredArgsConstructor
public class FileMimeTypeValidator implements ConstraintValidator<ValidFileMimeType, MultipartFile> {

    private final Tika tika;
    private List<String> mimeTypes;

    @Override
    public void initialize(ValidFileMimeType constraintAnnotation) {
        mimeTypes = List.of(constraintAnnotation.mimeTypes());
    }

    @SneakyThrows
    @Override
    public boolean isValid(MultipartFile file, ConstraintValidatorContext constraintValidatorContext) {
        if (file == null || file.isEmpty()) {
            return true;
        }
        var detect = tika.detect(TikaInputStream.get(file.getInputStream()));
        return mimeTypes.contains(detect);
    }
}

These classes are implementations of the ConstraintValidator interface and contain the actual validation logic.
For FileMimeTypeValidator, we will use Apache Tika (a toolkit designed to extract metadata and content from numerous types of documents).

3.3 Applying the Annotation

Let's create a TestUploadRequest class intended for handling file uploads, specifically for a PDF file.


@Data
public class TestUploadRequest {

    @NotNull
    @ValidFileMaxSize(maxSize = 10)
    @ValidFileExtension(extensions = {"pdf"})
    @ValidFileMimeType(mimeTypes = {"application/pdf"})
    private MultipartFile pdfFile;

}


@RestController
@Validated
@RequestMapping("/test")
public class TestController {

    @PostMapping(value = "/upload", consumes = {MediaType.MULTIPART_FORM_DATA_VALUE})
    public ResponseEntity<String> testUpload(@Valid @ModelAttribute TestUploadRequest request) {
        return ResponseEntity.ok("test upload");
    }
}

4. Custom Class Level Validation

A custom validation annotation can also be defined at the class level to validate a combination of fields within a class.

4.1 Creating the Annotation

Let’s create @PasswordMatches annotation to ensure that two password fields match in a class.


@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(
        validatedBy = {PasswordMatchesValidator.class}
)
public @interface PasswordMatches {
    String message() default "{constraints.PasswordMatches.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

@Target({ElementType.TYPE}): Indicates that this annotation targets a type declaration.

4.2 Creating the Validator

PasswordDto

public interface PasswordDto {
    String getPassword();

    String getConfirmPassword();
}

PasswordMatchesValidator

public class PasswordMatchesValidator implements ConstraintValidator<PasswordMatches, PasswordDto> {

    @Override
    public boolean isValid(PasswordDto password, ConstraintValidatorContext constraintValidatorContext) {
        return StringUtils.equals(password.getPassword(), password.getConfirmPassword());
    }
}

The PasswordDto interface is an interface for objects that contain a password and a confirm password field.
The PasswordMatchesValidator class implements the ConstraintValidator interface and contains the logic for validating that the password and confirm password fields match.

4.3 Applying the Annotation

Let's create a RegisterAccountRequest class intended for handling user registration data.


@PasswordMatches
@Data
public class RegisterAccountRequest implements PasswordDto {

    @NotBlank
    private String username;

    @NotBlank
    @Email
    private String email;

    @NotBlank
    @ToString.Exclude
    private String password;

    @NotBlank
    @ToString.Exclude
    private String confirmPassword;
}


@RestController
@Validated
@RequestMapping("/auth")
public class AuthController {

    @PostMapping("/register")
    public ResponseEntity<String> register(@RequestBody @Valid RegisterAccountRequest request) {
        return ResponseEntity.ok("register success");
    }
}

5. Summary

In this short article, we discovered how easy it is to create custom annotations to verify a field or class. The code from this article is available over on my Github.

6. References

Baeldung. (n.d.). Spring MVC Custom Validator. Retrieved from https://www.baeldung.com/spring-mvc-custom-validator