Java 8, 11, 17, 21, 25: Key Features and Improvements

🪐𝐄𝐱𝐩𝐥𝐨𝐫𝐢𝐧𝐠 𝐭𝐡𝐞 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬 𝐨𝐟 𝐉𝐚𝐯𝐚: Java is a versatile and widely used programming language known for its robust features and capabilities. Below are 12 key characteristics that make Java a preferred choice for developers: ⤷𝐒𝐢𝐦𝐩𝐥𝐞😃: Java's syntax is straightforward and easy to learn, especially for those familiar with C or C++. It eliminates complex features like pointers and operator overloading, making it beginner friendly. ⤷𝐎𝐛𝐣𝐞𝐜𝐭-𝐎𝐫𝐢𝐞𝐧𝐭𝐞𝐝🌟: Java is a fully object-oriented language, supporting core OOP principles like inheritance, encapsulation, polymorphism, and abstraction. This approach enhances code reusability and modularity. ⤷𝐏𝐥𝐚𝐭𝐟𝐨𝐫𝐦 𝐈𝐧𝐝𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐭🌠: Java follows the "Write Once, Run Anywhere" principle. Its code is compiled into platform-independent bytecode, which can run on any system with a Java Virtual Machine (JVM). ⤷𝐒𝐞𝐜𝐮𝐫𝐞🗿: Java provides robust security features, such as the absence of explicit pointers, a bytecode verifier, and a security manager. These ensure safe execution of code, especially in networked environments. ⤷𝐑𝐨𝐛𝐮𝐬𝐭🌛: Java emphasizes reliability with features like strong memory management, exception handling, and the elimination of error-prone constructs like pointers. This makes Java applications less prone to crashes. ⤷𝐏𝐨𝐫𝐭𝐚𝐛𝐥𝐞🪄: Java programs are architecture-neutral and can run on any platform without requiring recompilation. This portability is achieved through the use of bytecode and JVM. ⤷𝐇𝐢𝐠𝐡 𝐏𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞✨: While not as fast as fully compiled languages like C++, Java's performance is enhanced by Just-In-Time (JIT) compilation, which converts bytecode into native machine code at runtime. ⤷𝐌𝐮𝐥𝐭𝐢𝐭𝐡𝐫𝐞𝐚𝐝𝐞𝐝 💫: Java supports multithreading, allowing multiple threads to run concurrently. This improves CPU utilization and is ideal for applications requiring parallel processing, such as games and real-time systems. ⤷𝐑𝐢𝐜𝐡 𝐒𝐭𝐚𝐧𝐝𝐚𝐫𝐝 𝐋𝐢𝐛𝐫𝐚𝐫𝐲🪐: Java provides an extensive set of pre-built libraries (Java API) for tasks like file handling, networking, database connectivity, and more. These libraries simplify development and save time. ⤷𝐒𝐜𝐚𝐥𝐚𝐛𝐥𝐞🎇: Java is suitable for both small-scale and large-scale applications. Features like multithreading and distributed computing make it capable of handling complex, high-load systems. ⤷𝐃𝐲𝐧𝐚𝐦𝐢𝐜📈: Java supports dynamic memory allocation and runtime class loading. This flexibility allows applications to adapt and extend their functionality during execution. ⤷𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐚𝐥 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬 🌈: Since Java 8, functional programming capabilities like lambda expressions, the Stream API, and functional interfaces have been introduced, enabling concise and efficient code. #java #Day2 #Corejava #Codegnan Thanks to my mentor: Anand Kumar Buddarapu Saketh Kallepu Uppugundla Sairam

Java25 : main() , Compact Source, IO In Java 25 : The language significantly simplifies writing a main method by removing much of the traditional boilerplate. The new "Compact Source Files and Instance Main Methods" feature (JEP 512) allows you to write simple programs without a class wrapper, a public or static modifier, or the String[] args parameter. Writing main methods in Java 25 - 1.Traditional main method The classic, fully-featured main method remains the standard for most applications and is fully backward-compatible. // MyProgram.java public class MyProgram { public static void main(String[] args) { System.out.println("Hello, " + args[0] + "!"); } } 2. Simplified main method within a class For smaller programs, you can now write a less verbose main method inside a class, omitting the public, static, and String[] args parts. The JVM will look for this simplified version if it doesn't find the traditional one. java // HelloWorld.java class HelloWorld { void main() { System.out.println("Hello, World!"); } } 3. "Compact source file" with instance main For the most minimal entry point, you can place the simplified main method directly in a file without an enclosing class. The compiler automatically wraps the code in an implicit, unnamed class. // Minimal.java void main() { System.out.println("Hello from a compact source file!"); } 4. Using the java.lang.IO helper class To further reduce boilerplate for console I/O, Java 25 introduces a java.lang.IO helper class, making it easier to read and write from the console. java // IOExample.java import static java.lang.IO.*; void main() { var name = readln("What's your name? "); println("Hello, " + name + "!"); } Article: Java's main method gets a beginner-friendly reboot In its latest long-term support (LTS) version, Java 25, the platform has made a significant update to how developers, particularly beginners, can write the entry point to their programs. By finalizing JEP 512, which introduces "Compact Source Files and Instance Main Methods," Java has shed some of its long-standing "boilerplate" to become more accessible and intuitive. The feature, which was refined over several preview releases (including Java 21–24), provides a smoother on-ramp for new programmers by removing the need to understand complex, enterprise-level concepts like public, static, and the String[] args parameter from day one.

𝗝𝗮𝘃𝗮 𝟮𝟱: 𝗪𝗲𝗹𝗰𝗼𝗺𝗲 𝘁𝗼 𝘁𝗵𝗲 𝗡𝗲𝘅𝘁 𝗘𝗿𝗮 𝗼𝗳 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁 Java 25 (JDK 25), released on September 16, 2025, enhances the coding experience for developers, making it smoother, faster, and easier. 𝟭. 𝗜𝗻𝘀𝘁𝗮𝗻𝗰𝗲 𝗠𝗮𝗶𝗻 𝗠𝗲𝘁𝗵𝗼𝗱𝘀 In Java 25, you don't need to write code public static void main(String[] args) for basic programs anymore. You can create a main method without static, without public, and even without String[] args if your program doesn't use them. It makes small programs cleaner and easier to write. 𝟮. 𝗖𝗼𝗺𝗽𝗮𝗰𝘁 𝗦𝗼𝘂𝗿𝗰𝗲 𝗙𝗶𝗹𝗲𝘀 Java 25 now lets you write a complete Java program without creating a class manually. You don't need to write class Hello { ... } anymore. Behind the scenes, the compiler automatically creates an invisible (unnamed) class for you. This means you can write a file that contains only your variables and methods, and Java will handle the rest. It's great for beginners because you can focus on learning core concepts without worrying about class structure. 𝟯. 𝗦𝗶𝗺𝗽𝗹𝗶𝗳𝘆𝗶𝗻𝗴 𝗖𝗼𝗻𝘀𝗼𝗹𝗲 𝗜𝗻𝗽𝘂𝘁 𝗮𝗻𝗱 𝗢𝘂𝘁𝗽𝘂𝘁 𝗶𝗻 𝗝𝗮𝘃𝗮 For beginners, printing messages or reading user input should be easy. But for a long time, Java made these basic tasks more complicated than they needed to be. 𝗧𝗵𝗲 𝗡𝗲𝘄 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: 𝗧𝗵𝗲 𝗜𝗢 𝗛𝗲𝗹𝗽𝗲𝗿 𝗖𝗹𝗮𝘀𝘀 Java 25 introduces a new java.lang.IO class that provides simple, static methods for common console tasks.  No more long setup code - just clean and beginner-friendly methods for reading and writing from the console. 𝟰. 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗰 𝗜𝗺𝗽𝗼𝗿𝘁𝘀 𝗳𝗼𝗿 𝗖𝗼𝗺𝗺𝗼𝗻 𝗔𝗣𝗜𝘀 In compact source files, Java 25 automatically makes many commonly used classes available - especially from packages inside java. base like java.util and java.io. 𝟱. 𝗙𝗹𝗲𝘅𝗶𝗯𝗹𝗲 𝗖𝗼𝗻𝘀𝘁𝗿𝘂𝗰𝘁𝗼𝗿 𝗕𝗼𝗱𝗶𝗲𝘀 In Java 25, constructors become more flexible. You're now allowed to write some statements before calling super(...) or this(...). Earlier, these calls had to be the first line in the constructor. You can't use this, access instance fields, or call instance methods because the object isn't fully created yet. But you can run basic calculations or initialize fields that haven't been set up. 𝟲. 𝗠𝗼𝗱𝘂𝗹𝗲 𝗜𝗺𝗽𝗼𝗿𝘁 𝗗𝗲𝗰𝗹𝗮𝗿𝗮𝘁𝗶𝗼𝗻𝘀 This feature adds a new way to import all packages that a module exports by using a single declaration: This helps reduce the need to write many import statements for individual packages, especially from modular libraries. 𝟳. 𝗦𝗰𝗼𝗽𝗲𝗱 𝗩𝗮𝗹𝘂𝗲𝘀 Scoped values are a new feature in Java that let you share read-only (immutable) data across methods within a thread - and even with its child threads - without passing the data around manually. A scoped value only exists for a limited time. Once the defined scope ends, the value's binding disappears automatically. For a detailed explanation, check out the full article: https://shorturl.at/bMIDE

#DAY51 #100DaysOFCode | Java Full Stack Development #Day51 of my #100DaysOfCode – Java Today I explored one of the most interesting and essential topics in Java — Wrapper Classes. At first glance, wrapper classes may seem like a small topic, but they play a major role in bridging the gap between primitive data types and object-oriented programming. What Are Wrapper Classes? In Java, data types are divided into two categories: primitive types and reference types. Primitive types (like int, boolean, char, etc.) are not objects; they store values directly and are faster to use. However, Java is an object-oriented language, and sometimes we need to treat these primitive values as objects. That’s where Wrapper Classes come in! A wrapper class is an object representation of a primitive data type. Each primitive type has a corresponding wrapper class inside the java.lang package. Why Do We Need Wrapper Classes? To Use Primitives in Collections Java’s Collection Framework (like ArrayList, HashMap, etc.) works only with objects, not primitive types. So, if you want to store an integer value inside an ArrayList, you must use the Integer class instead of int. ArrayList<Integer> numbers = new ArrayList<>(); numbers.add(10); // Autoboxing converts int to Integer automatically For Utility and Conversion Methods Wrapper classes contain several useful methods for conversions, parsing, and comparisons. To Represent Null Values Primitive types like int or boolean cannot hold null, but wrapper classes can. This is helpful in scenarios like working with databases or optional values. ⚙️ Autoboxing and Unboxing Java 5 introduced two powerful features: Autoboxing and Unboxing. These make working with wrapper classes much simpler and automatic. 🔸 Autoboxing → Automatically converts a primitive type into its corresponding wrapper class. 🔸 Unboxing → Automatically converts a wrapper class object back into a primitive type. 🧠 Features of Wrapper Classes ✔️ They are immutable, meaning once created, their value cannot be changed. ✔️ They are defined in the java.lang package. ✔️ Each wrapper class provides methods for conversion between strings, primitives, and objects. ✔️ They enhance the object-oriented nature of Java by allowing primitives to behave like objects. In Conclusion Wrapper classes might look simple, but they play a very important role in Java. By providing utility methods, supporting conversions, and enabling autoboxing/unboxing, wrapper classes make Java more flexible, powerful, and object-friendly. A big thanks to my mentor Gurugubelli Vijaya Kumar Sir and the 10000 Coders institute for constantly guiding me and helping me build a strong foundation in programming concepts. #Java #Coding #Programming #100DaysOfCode #JavaProgramming #CodeNewbie #LearnToCode #Developer #Tech #ProgrammingTips #JavaDeveloper #CodeDaily #DataStructures #CodingLife

What are OOPs concepts in Java? Encapsulation, Inheritance, Polymorphism, and Abstraction. Difference between an interface and an abstract class? Interface has only abstract methods (till Java 7), abstract class can have both abstract and concrete methods. What is the difference between == and .equals()? == compares references; .equals() compares content. What are access modifiers in Java? public, private, protected, and default. What is the difference between String, StringBuilder, and StringBuffer? String is immutable; StringBuilder and StringBuffer are mutable (StringBuffer is thread-safe). Difference between List, Set, and Map in Java? List allows duplicates, Set doesn’t, Map stores key-value pairs. What is HashMap and how does it work internally? Uses hashing; stores key-value pairs in buckets based on hashcode. How to handle duplicate values in arrays? Use Set, or loop and compare values manually. What is the difference between ArrayList and LinkedList? ArrayList is faster for search; LinkedList is faster for insertion/deletion. How to sort a list of numbers or strings in Java? Collections.sort(list); or use list.stream().sorted(). What is the difference between checked and unchecked exceptions? Checked must be handled (like IOException); unchecked are runtime (like NullPointerException). Explain try-catch-finally with example. Can we have multiple catch blocks? Yes, to handle different exception types. Can finally block be skipped? Only if System.exit(0) is called before it. How do you read data from Excel in Selenium? Using Apache POI or JXL library. How do you handle synchronization in Selenium? Using Implicit, Explicit, or Fluent Wait. How do you handle JSON in RestAssured? Using JsonPath or org.json library. How do you handle dynamic elements in Selenium? Use XPath with contains(), starts-with(), or CSS selectors. What is the difference between Page Object Model (POM) and Page Factory? POM is a design pattern; Page Factory is an implementation of POM using @FindBy. How to read data from properties file in Java? Using Properties class and FileInputStream. Explain static keyword in Java. Used for class-level variables and methods; shared among all objects. What is final, finally, and finalize()? final (keyword) = constant; finally = block; finalize() = method before GC. What is constructor overloading? Multiple constructors with different parameter lists. Can we overload or override static methods? Overload Yes, Override No. What is difference between throw and throws? throw is used to throw an exception; throws declares it. Write a Java program to find duplicates in an array. Write a Java program to reverse a string. Write a Java program to count occurrences of each element. Write a Java program to check if a number is prime. Write a Java program to separate positive and negative numbers in an array. #Automation #Interview #Java

☕ Java Revision Day: Java Program Execution Flow 🔄 Today’s revision helped me connect all the dots between JDK, JRE, and JVM — understanding how a Java program actually runs behind the scenes. 💻 Let’s explore this step-by-step 👇 🧩 Step 1️⃣: Writing the Code We start by writing a simple Java program: class Hello { public static void main(String[] args) { System.out.println("Hello, Java World!"); } } Here, the file name is Hello.java (the source code). ⚙️ Step 2️⃣: Compilation Phase (JDK’s Role) When we run the command: javac Hello.java 🧠 The Java Compiler (javac) checks for syntax errors and converts the source code into bytecode, which is platform-independent. ✅ Output: A new file called Hello.class is created. This file doesn’t contain readable text — it holds bytecode (intermediate instructions for JVM). 🚀 Step 3️⃣: Execution Phase (JRE & JVM’s Role) Now we execute: java Hello Here’s what happens internally 👇 1️⃣ Class Loader Subsystem Loads Hello.class into memory. 2️⃣ Bytecode Verifier Ensures the code follows Java’s security rules (no illegal access). 3️⃣ JVM Execution Engine Interpreter reads bytecode line-by-line. JIT Compiler (Just-In-Time) converts frequently used code into native machine code for better performance. 4️⃣ Output Produced: Hello, Java World! 🧠 Step 4️⃣: Memory Management While executing, JVM allocates memory in different areas: Heap: Stores objects and instance variables. Stack: Holds method calls and local variables. PC Register & Method Area: Keep track of current instruction and class-level details. Garbage Collector: Automatically removes unused objects to free memory. 💡 Summary of the Flow: Source Code (.java) ↓ [javac compiler] Bytecode (.class) ↓ [JVM inside JRE] Machine Code → Output So, the process is: Write → Compile → Run → Execute → Output ✅ 🌍 Key Concept: Java follows the principle of WORA – Write Once, Run Anywhere. The .class bytecode can run on any system that has a JVM, whether it’s Windows, Linux, or macOS. 🎯 Reflection: Understanding this execution flow gave me a clear picture of how Java code transforms from simple text to a working program. It’s fascinating how the JDK, JRE, and JVM work together like gears in a machine to make Java reliable, secure, and portable! ⚙️ #Java #Programming #Coding #FullStackDevelopment #JVM #JRE #JDK #LearningJourney #SoftwareEngineering #DailyLearning #RevisionDay #TAPAcademy #TechCommunity #JavaExecution #CareerGrowth #WriteOnceRunAnywhere #TapAcademy

Java Programming Roadmap for SDETs 2025 1. Java Basics (Month 1) Core Syntax & Fundamentals Variables, data types, operators, control structures Methods, arrays, basic I/O operations Practice Problems Calculator Program: Build basic calculator with all arithmetic operations Array Manipulation: Find max/min elements, reverse array, remove duplicates String Operations: Palindrome checker, word count, character frequency 2. Object-Oriented Programming (Month 2) OOP Concepts Classes, objects, constructors, inheritance, polymorphism Encapsulation, abstraction, method overriding/overloading Practice Problems Vehicle Class Hierarchy: Create base Vehicle class with Car, Bike subclasses Bank Account System: Implement account types with different interest calculations 3. Collections Framework (Month 3) Core Collections List (ArrayList, LinkedList), Set (HashSet, TreeSet), Map (HashMap, TreeMap) Queue, Stack, Iterator pattern Practice Problems Word Frequency Counter: Count word occurrences in text using HashMap Duplicate Removal: Remove duplicates from list while preserving order 4. Exception Handling (Month 3) Exception Management Try-catch-finally, checked vs unchecked exceptions Custom exceptions, exception propagation Practice Problems File Reader: Handle FileNotFoundException, IOException with proper cleanup Input Validator: Create custom exceptions for invalid test data formats Division Calculator: Handle ArithmeticException with user-friendly messages 5. Java 8+ Features (Month 4) Functional Programming Lambda expressions, Stream API, Optional class Method references, functional interfaces Practice Problems Data Filtering: Filter employee list by salary range using streams File Processing: Read CSV, transform data, and generate reports using streams Optional Handling: Handle null values in API responses using Optional 6. Multithreading (Month 4) Concurrency Basics Thread creation, synchronization, thread-safe collections ExecutorService, CompletableFuture Practice Problems Parallel Test Execution: Run multiple test methods concurrently 7. Design Patterns (Month 6) Common Patterns Singleton, Factory, Builder, Observer patterns Page Object Model implementation Practice Problems WebDriver Factory: Implement factory pattern for browser instantiation Test Configuration: Use singleton pattern for configuration management Test Data Builder: Create builder pattern for complex test objects ✅ Clean code principles and best practices ✅ Debugging and troubleshooting techniques ✅ Code documentation and commenting standards ✅ Version control integration (Git workflows) ✅ Success Metrics Complete 50+ coding problems across all topics Write clean, maintainable code following Java conventions Handle complex data structures and algorithms efficiently -x-x- Learn basics of Java with DSA and pattern recognitions skills to solve LeetCode Problems | Coding course for SDETs: https://lnkd.in/ggXcYU2s #japneetsachdeva

✅ 50 Must-Know Java Concepts for Interviews ☕💡 📍 Java Basics 1. What is Java? 2. JVM, JRE, JDK — know their roles and differences 3. Data Types & Variables — primitives, reference types 4. Operators — arithmetic, relational, logical 5. Type Casting — implicit and explicit 📍 Control Flow 6. if-else statements 7. switch-case syntax and use-cases 8. Loops: for, while, do-while 9. break & continue — control loop behavior 10. Ternary operator (?:) — compact conditional 📍 OOP Concepts 11. Class & Object — blueprint and instances 12. Inheritance — code reuse and is-a relationship 13. Polymorphism — compile-time (overloading) & runtime (overriding) 14. Abstraction — hiding implementation details 15. Encapsulation — data hiding with access modifiers 📍 Core OOP in Java 16. Method Overloading — same method name, different params 17. Method Overriding — subclass modifies superclass method 18. Constructors & Constructor Overloading 19. this and super keywords — referencing current and parent class 20. Static keyword — class-level variables and methods 📍 Exception Handling 21. try-catch-finally blocks 22. throw vs throws — raising vs declaring exceptions 23. Checked vs Unchecked Exceptions 24. Custom Exceptions — user-defined error handling 25. Common exceptions like NullPointerException, ArrayIndexOutOfBoundsException 📍 Collections Framework 26. List, Set, Map interfaces 27. ArrayList vs LinkedList — pros & cons 28. HashSet vs TreeSet — unordered vs sorted sets 29. HashMap vs TreeMap — unordered vs sorted maps 30. Iterator & enhanced for-loop for traversing collections 📍 Strings & Arrays 31. String vs StringBuilder vs StringBuffer — immutability and performance 32. Common String methods (substring, equals, indexOf) 33. 1D & 2D Arrays — declaration and traversal 34. Array vs ArrayList — fixed vs dynamic size 35. String immutability — benefits and implications 📍 Advanced Java 36. Interfaces & Abstract Classes — design contracts and partial implementation 37. Lambda Expressions — functional programming style 38. Functional Interfaces — single abstract method interfaces 39. Streams API — processing collections declaratively 40. File I/O with FileReader, BufferedReader 📍 Multithreading & Concurrency 41. Thread class vs Runnable interface 42. Thread Lifecycle (New, Runnable, Running, Waiting, Terminated) 43. Synchronization — thread safety techniques 44. wait(), notify(), notifyAll() — inter-thread communication 45. Executor Framework — managing thread pools 📍 Best Practices & Tools 46. Writing Clean Code — naming, formatting, SOLID principles 47. Java Memory Model — Heap vs Stack 48. Garbage Collection basics — automatic memory management 49. Unit Testing with JUnit 50. Version Control — Git & GitHub basics

Here are the 𝗙𝗲𝗮𝘁𝘂𝗿𝗲𝘀 𝗼𝗳 𝗝𝗮𝘃𝗮 written using only emoji numbers + dot, exactly as you requested: 1. Simple Syntax Java uses clean and readable syntax, making it easier for beginners and reducing chances of errors. 2. Object-Oriented Everything in Java follows OOP principles like inheritance, encapsulation, and polymorphism, helping build reusable and modular code. 3. Platform Independent Write once, run anywhere—Java code becomes bytecode, and the JVM runs it on any operating system. 4. Interpreted Java programs are interpreted by the JVM, enabling cross-platform execution without recompilation. 5. Scalable Java supports building both small programs and large enterprise applications without performance issues. 6. Portable Java code runs consistently across devices because of its platform-independent nature and standard libraries. 7. Secure & Robust Java offers strong memory management, exception handling, and security features to protect applications. 8. Memory Management Automatic garbage collection helps manage memory efficiently without manual cleanup. 9. High Performance JIT (Just-in-Time) compilation and optimized JVM make Java faster than traditional interpreted languages. 10. Multithreading Java allows multiple tasks to run at the same time, improving performance and responsiveness. 11. Rich Standard Library A large set of built-in classes and APIs helps developers perform tasks easily, from networking to data structures. 12. Functional Programming Features Lambda expressions, streams, and functional interfaces make code more concise and modern. 13. Integration with Other Technologies Java works smoothly with databases, cloud systems, microservices, and enterprise tools. 14. Supports Mobile & Web Apps Java powers Android apps and large-scale backend systems used worldwide. 15. Strong Documentation & Community Support Java has extensive documentation and a massive community, making troubleshooting and learning easier. 10 Free Resources for MS/PhD Students 1. How to Find Research Gaps in Articles? (6 min video) https://lnkd.in/d86-YRKP 2. How to Write Research Question? (4 min video) https://lnkd.in/dCGerCnm 3. How to Create Online Questionnaire? (12 min video) https://lnkd.in/d-aBmejf 4. How to Write Research Synopsis? (9 min video) https://lnkd.in/dGC5BT35 5. How to Create Table of Contents for Research Paper (4 min video) https://lnkd.in/dcnKjnXS 6. How to make Presentation for Proposal Defense Day? (6 min video) https://lnkd.in/dHqWsnqc 7. How to Find Best Websites to Download Thesis and Dissertation? (10 min video) https://lnkd.in/dsFHMbnZ 8. How to Create a Research Proposal Using Google Gemini Deep Research (7 min video) https://lnkd.in/dtmj4eJR 9. How to Calculate Sample Size in Research (6 min video) https://lnkd.in/dMfy8cAM 10. How to Create Table of Contents for Research Paper (4 min video) https://lnkd.in/deKBH9KE Follow MD. ASIF AHMED for more