docs(paradigms): add detailed explanation of Declarative Programming with Java examples

What
- Documented the concept of **Declarative Programming** vs **Imperative Programming**.
- Highlighted key characteristics:
  - Focus on *what* to achieve, not *how* to achieve it.
  - High-level abstraction with less boilerplate code.
  - Execution strategy left to underlying system (e.g., SQL engine, Streams).
- Provided concrete examples across multiple domains:
  - **SQL** → `SELECT * FROM students WHERE marks > 90` (declarative query).
  - **Java Streams** → `list.stream().filter(...).map(...).toList()` (functional transformations).
  - **HTML/CSS** → structure and styling declaratively described.
- Outlined benefits:
  - Conciseness, readability, maintainability.
  - Easier parallelization via declarative APIs.
- Added **Java-specific comparison**:
  - Imperative sum of even numbers (loops + conditions).
  - Declarative sum using Streams API (`filter`, `mapToInt`, `sum`).

Why
- Declarative programming is central to modern Java (Streams, Lambdas, functional style).
- Developers often confuse *control flow* with *business logic*; declarative style separates the two.
- This doc clarifies when and why declarative approaches are preferred in enterprise apps.

Logic
1. **Definition**
   - Declarative = specify outcome, not steps.
   - Contrasted with imperative = specify exact flow (loops, state changes).

2. **Key Characteristics**
   - Abstraction of execution.
   - Focus on results instead of algorithmic details.
   - Reduction of verbosity and control structures.

3. **Examples**
   - SQL → declare query logic without procedural fetch.
   - Streams → pipelines describe transformation, not iteration.
   - HTML → structure declaration, not rendering process.

4. **Java Focus**
   - Streams API embodies declarative patterns (map/filter/reduce).
   - Shows improved readability and parallelization compared to traditional loops.

Real-life applications
- **Database queries (SQL)**: write intent-driven queries, let DBMS handle execution plan.
- **Back-end APIs (Java Streams)**: declarative transformations for business rules.
- **UI layer (HTML/CSS)**: declaratively specify layout and style, browsers handle rendering.
- **Parallel data processing**: declarative pipelines allow frameworks to optimize multithreaded execution.

Notes
- Declarative ≠ “no control,” but rather offloading control to libraries/engines.
- Imperative code is sometimes necessary for low-level optimization, but declarative style is preferred for clarity.
- Java’s `Stream.parallel()` demonstrates how declarative style enables automatic performance improvements.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Java 8 Crash Course/Java 8 Streams/Declarative Programming/src/ Declarative Programming.txt

@@ -0,0 +1,52 @@
+1. What is Declarative Programming?
+•	Declarative programming is a style of programming where you focus on what the program should achieve,
+rather than how to achieve it step by step.
+•	You describe the logic of computation, not the control flow.
+
+•	Contrast:
+•	Imperative style: “How to do it” (explicit loops, conditions, assignments).
+•	Declarative style: “What result do you want” (expressions, rules, queries).
+
+⸻
+
+2. Key Characteristics
+•	High-level abstraction: You don’t manage low-level steps.
+•	Focus on a desired outcome: The program reads like a description of the result.
+•	Less boilerplate: Fewer lines of code compared to imperative.
+•	Underlying system decides execution strategy.
+
+⸻
+
+3. Examples in Package2.Practice
+•	SQL:
+•	Declarative: SELECT * FROM students WHERE marks > 90;
+(You specify what you want, not how to fetch row by row.)
+•	Functional Programming (Java Streams, Lambdas):
+•	Declarative: list.stream().filter(x -> x > 10).map(x -> x*2).toList();
+(You describe transformations, not write for loops.)
+•	HTML/CSS:
+•	HTML declares what the page contains, not how to render.
+
+⸻
+
+4. Benefits:
+•	Conciseness – less code, fewer bugs.
+•	Readability – reads like “business logic” or natural language.
+•	Maintainability – easier to change rules/logic without touching flow.
+•	Parallelism – declarative constructs (e.g., Streams) can optimize execution internally.
+
+⸻
+
+5. In Java
+•	Java supports declarative programming mainly through Streams API, Lambdas, and functional style constructs.
+•	Instead of loops and mutating state, you chain operations (map, filter, reduce).
+•	Example: Summing even numbers in a list
+•	Imperative: loop + if + accumulator.
+•	Declarative: list.stream().filter(x -> x % 2 == 0).mapToInt(Integer::intValue).sum();.
+
+⸻
+
+Quick Recap:
+✔ Declarative = what to do, Imperative = how to do.
+✔ SQL, Streams, HTML are all declarative approaches.
+✔ Declarative style improves readability, reduces boilerplate, and makes parallelism easier.