How Java Runs: From Source to Execution

☕ 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's concurrency model is evolving. For years, we relied on OS threads - powerful but heavy. Now, Project Loom changes everything. 𝟭. 𝗧𝗵𝗲 𝗧𝗿𝗮𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗧𝗵𝗿𝗲𝗮𝗱 𝗠𝗼𝗱𝗲𝗹 Java threads mapped directly to OS threads. This worked initially but became costly: - 1 MB memory per thread - Expensive context switching - Limited to thousands of threads - Blocking I/O wasted resources This architecture makes it difficult to build highly concurrent applications such as modern APIs or event-driven systems. 𝟮. 𝗪𝗵𝘆 𝗥𝗲𝗮𝗰𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 𝗘𝗺𝗲𝗿𝗴𝗲𝗱 To address these scalability issues, Reactive Programming introduced a new approach using non-blocking I/O and event loops. Frameworks like Spring WebFlux leveraged this model to handle thousands of concurrent requests efficiently. - Complex programming models - Difficult debugging - Steep learning curves (Mono, Flux) 𝟯. 𝗘𝗻𝘁𝗲𝗿 𝗣𝗿𝗼𝗷𝗲𝗰𝘁 𝗟𝗼𝗼𝗺 Java 21 introduced Virtual Threads - lightweight, JVM-managed threads that scale to millions: - Blocking is now cheap - Context switching happens in the JVM - 𝗪𝗿𝗶𝘁𝗲 𝘀𝘆𝗻𝗰𝗵𝗿𝗼𝗻𝗼𝘂𝘀 𝗰𝗼𝗱𝗲 𝘁𝗵𝗮𝘁 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝘀 𝗹𝗶𝗸𝗲 𝗮𝘀𝘆𝗻𝗰 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 Virtual Threads are managed by the JVM, not the operating system. They’re cheap to create, use minimal memory, and can scale to millions of concurrent operations. 𝟰. 𝗪𝗵𝗮𝘁 𝗟𝗼𝗼𝗺 𝗖𝗵𝗮𝗻𝗴𝗲𝘀 Project Loom eliminates the simplicity vs. scalability trade-off: - Millions of threads without event loops - Readable stack traces - Works with existing Java libraries (JDBC, RestTemplate) 𝟱. 𝗦𝗽𝗿𝗶𝗻𝗴 𝗠𝗩𝗖 + 𝗟𝗼𝗼𝗺 𝘃𝘀 𝗪𝗲𝗯𝗙𝗹𝘂𝘅 With Loom: Spring MVC achieves WebFlux-level scalability while keeping the traditional model. WebFlux remains best for: - Real-time streaming (SSE, WebSockets) - Reactive pipelines - Backpressure scenarios Loom doesn't replace WebFlux—it redefines where each fits. Spring Framework 𝗹𝗲𝗮𝗱 𝗝𝘂𝗲𝗿𝗴𝗲𝗻 𝗛𝗼𝗲𝗹𝗹𝗲𝗿 𝗮𝗻𝗱 𝗰𝗼𝗿𝗲 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗦é𝗯𝗮𝘀𝘁𝗶𝗲𝗻 𝗗𝗲𝗹𝗲𝘂𝘇𝗲 have confirmed: “With Project Loom, Spring MVC becomes as scalable as WebFlux. WebFlux will remain the best choice for reactive and streaming use cases.” 𝟲. 𝗧𝗵𝗲 𝗙𝘂𝘁𝘂𝗿𝗲 𝗼𝗳 𝗝𝗮𝘃𝗮 𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 Virtual threads are production-ready in Java 21, with Spring Framework 6.1+ and Boot 3.2+ supporting them natively. For developers: - Spring MVC scales for modern workloads - WebFlux focuses on reactive/streaming cases - Prioritize readability without losing performance 𝟳. 𝗖𝗼𝗻𝗰𝗹𝘂𝘀𝗶𝗼𝗻 Project Loom bridges traditional and reactive programming. Write clean, synchronous code that scales effortlessly. The future is clear: Simplicity, scalability, and choice. #100DaysOfCode #Java #Springboot #ProjectLoom #VirtualThreads #Spring #SpringMVC #WebFlux #ReactiveProgramming #Microservices #JavaConcurrency #Backend #TechLeadership

🌟 Java What? Why? How? 🌟 Here are 10 core Java question that deepens the insight : 1️⃣ What is Java? 👉 What: A high-level, object-oriented, platform-independent programming language. 👉 Why: To solve platform dependency. 👉 How: Through JVM executing bytecode. 2️⃣ JDK vs JRE vs JVM 👉 What: JVM executes bytecode, JRE = JVM + libraries, JDK = JRE + development tools. 👉 Why: To separate running from developing. 👉 How: Developers use JDK, users need only JRE. 3️⃣ Features of Java 👉 What: OOP, simple, secure, portable, robust, multithreaded. 👉 Why: To make programming safer and scalable. 👉 How: No pointers, strong typing, garbage collection. 4️⃣ Heap vs Stack Memory 👉 What: Heap stores objects, Stack stores method calls/local variables. 👉 Why: For efficient memory allocation. 👉 How: JVM manages both during runtime. 5️⃣ Garbage Collection 👉 What: Automatic memory management. 👉 Why: To prevent memory leaks. 👉 How: JVM clears unused objects. 6️⃣ == vs .equals() 👉 What: == compares references, .equals() compares values. 👉 Why: Because objects may share values but not references. 👉 How: Override .equals() in custom classes. 7️⃣ Abstract Class vs Interface 👉 What: Abstract = partial implementation, Interface = full abstraction (till Java 7). 👉 Why: To provide flexible design choices. 👉 How: Abstract allows concrete + abstract methods, Interface defines contracts. 8️⃣ Checked vs Unchecked Exceptions 👉 What: Checked = compile-time (IOException), Unchecked = runtime (NullPointerException). 👉 Why: To enforce error handling. 👉 How: Compiler forces checked handling, unchecked can occur anytime. 9️⃣ final vs finally vs finalize() 👉 What: final = constant/immutable, finally = cleanup block, finalize() = GC hook. 👉 Why: For immutability, guaranteed cleanup, memory management. 👉 How: finalize() is deprecated. 🔟 Multithreading & Synchronization 👉 What: Multithreading = parallel tasks, Synchronization = safe resource access. 👉 Why: To improve performance and prevent inconsistency. 👉 How: Threads via Thread/Runnable, synchronized blocks for safety. 💡 Java isn’t just interview prep — it’s the backbone of enterprise apps, Android, and cloud systems today. #WhatWhyHow #Java #InterviewPrep #Programming #FullStackDevelopment #Java #SpringBoot #ProblemSolving #LearningInPublic #WhatWhyHow

🚗 Tricky Java Bug — “When Ola’s Cache Broke Serialization: The serialVersionUID Mystery 🧩” 🎬 The Scene At Ola, a backend dev cached user data using Java serialization. Everything ran perfectly in staging. But the moment they deployed a new version… 💥 java.io.InvalidClassException: com.ola.user.UserInfo; local class incompatible: stream classdesc serialVersionUID = 124578, local class serialVersionUID = 987654 Suddenly, users vanished from cache faster than an Ola cab during rain 😅 💣 The Root Cause When Java serializes an object, it stores a unique identifier — serialVersionUID. If you don’t explicitly declare it, JVM generates one automatically based on class structure (fields, methods, etc.). So when someone adds or removes a field later, boom — the calculated ID changes, and deserialization fails because the stored bytes no longer match the “current version” of the class. ⚙️ The Problem Code public class UserInfo implements Serializable { private String name; private int age; private String city; } Then one fine day… someone adds a new field: private String gender; 💣 Old cache data can’t deserialize anymore. ✅ The Fix Always define a fixed serialVersionUID to maintain compatibility: public class UserInfo implements Serializable { private static final long serialVersionUID = 1L; private String name; private int age; private String city; private String gender; // newly added } 🧩 Quick Debugging Tips 🔍 Check the exception message — it always mentions both stream and local IDs. 🧠 Use serialver tool to generate UID for older class versions. 🚫 Don’t rely on JVM-generated IDs if your class might evolve over time. 💾 When backward compatibility isn’t needed — clear the cache before redeploy. 🔄 Consider using JSON-based cache (like Redis with Jackson) for human-readable, version-tolerant data. ✅ Quick Checklist ☑️ Always declare serialVersionUID manually. ☑️ Avoid unnecessary structural changes in serializable classes. ☑️ For distributed cache, prefer JSON serialization over Java native. ☑️ Be aware that adding/removing fields changes serialization compatibility. 💬 Real Talk At Ola, one dev said: > “My cache invalidated itself before I could even write the logic for it!” 😅 Lesson: In Java, serialVersionUID isn’t just a number — it’s your backward compatibility insurance policy. #Java #Serialization #Ola #TrickyBugs #Cache #BackendDevelopment #SpringBoot #Debugging #Developers #TechHumor #Concurrency #Microservices #JavaInterview #SoftwareEngineering

Varna Mapped to Java System Architecture (PASSIONIT PRUTL KALKI AIDHARMA SANATAN framework) Krishna smiles and says: “Arjuna, the Varna is not hierarchy. In a Java system, like in life, each layer is necessary for the program to execute. Remove one, and the JVM throws errors.” 1. Brahmin — Core Logic / Class Layer Java Analogy: Abstract classes, interfaces, and core modules. Function: Define business rules, algorithms, and logic. Example: public abstract class BulbDesign { abstract void defineFilamentSpecs(); abstract void defineVoltageTolerance(); } Cosmic Role: Brahmin is the brain, designing the system. If missing: The program has no structure; execution is meaningless. 2. Kshatriya — Security & Validation Layer Java Analogy: Validator classes, exception handling, authentication modules. Function: Protect system integrity, enforce rules, handle errors. Example: public class BulbValidator { public boolean validateVoltage(int voltage) { return voltage > 0 && voltage <= 240; } } Cosmic Role: Kshatriya is the arms of the system — defending it from chaos. If missing: Logic exists but crashes under invalid input or misuse. 3. Vaishya — Infrastructure / Deployment Layer Java Analogy: Service layers, API interfaces, database connectors, network classes. Function: Translate core logic into usable outputs, interact with external systems. Example: public class BulbService { private BulbValidator validator = new BulbValidator(); public void createBulb(int voltage) { if(validator.validateVoltage(voltage)) { System.out.println("Bulb created with voltage: " + voltage); } else { System.out.println("Invalid voltage!"); } } } Cosmic Role: Vaishya is the hands — distributing value to the world. If missing: Great logic exists internally, but no one can use it. 4. Shudra — Execution / Runtime Layer Java Analogy: Main class, threads, runtime services, API endpoints. Function: Execute logic, serve requests, maintain system operations. Example: public class BulbApplication { public static void main(String[] args) { BulbService service = new BulbService(); service.createBulb(120); // executes the entire system } } Cosmic Role: Shudra is the feet, supporting and running the system continuously. If missing: All other classes exist, but nothing executes — the bulb never glows. Krishna’s System Philosophy Krishna explains: “Arjuna, just as in this Java system, no class is superior. Brahmin designs but cannot run alone. Kshatriya defends but cannot create alone. Vaishya deploys but cannot reason alone. Shudra executes but cannot design alone. The JVM — like the cosmos — requires all layers to function in harmony. Thinking one layer is superior is ignorance. Self-realization is understanding that you are all classes in the same program, each necessary, each divine.”

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 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

💡 My Java Journey: Understanding Static vs Non-Static, final, finally & finalize() When I started working with Java, these four terms — static, final, finally, and finalize() — honestly used to confuse me a lot. They all sounded similar, yet behaved completely differently in code. But once I really understood how each works, my approach to writing cleaner and more predictable Java code changed forever. Here’s how I break it down 👇 ⚙️ Static vs Non-Static In my early days, I often tried accessing non-static variables directly from a static method and got those famous “non-static variable cannot be referenced from a static context” errors 😅 That’s when I realized the key difference: Static belongs to the class, not the object. ✅ Shared among all instances. ✅ Can be accessed without creating an object. 👉 Example: Math.max(a, b) Non-Static belongs to the object. ✅ Each object gets its own copy. 👉 Example: Instance variables like employeeName, salary, etc. Static = one copy shared by all Non-Static = separate copy for each object 🛡️ final When I first read about final, I thought it was just for constants — but it’s so much more. 🔸 final variable → can’t be changed once assigned 🔸 final method → can’t be overridden 🔸 final class → can’t be inherited Example: final int MAX_ATTEMPTS = 3; It’s like putting a “Do Not Modify” tag on your data or design. 🧩 finally I learned the importance of the finally block the hard way — during exception handling. In one project, we had a file open inside a try block, and if an exception occurred, the file never got closed properly. That’s when I started using: try { readFile(); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); } finally { closeFile(); } The finally block ensures your cleanup code always executes, even if things go wrong. It’s one of those small but mighty features. 🧹 finalize() When I first read about finalize(), it felt like a cool concept — a method called before an object is destroyed by the Garbage Collector. Example: protected void finalize() { System.out.println("Object is being destroyed"); } But as I grew with Java, I learned that it’s deprecated now and not reliable for resource cleanup. The modern and safer approach? ✅ Use AutoCloseable and try-with-resources. 💬 My Takeaway Over time, I realized these small keywords teach big lessons: Static – helps share logic across instances final – ensures immutability and clean design finally – guarantees resource safety finalize() – reminds us how Java evolved over time If you’re starting out or brushing up on Java fundamentals, take time to explore why these exist — not just how they work. That’s where true mastery begins. 💪

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