Mastering Java Loops & Scanner Class

🚀Day 98 of construct Binary search Tree from Preorder traversal. The Problem given an Array of Integers preorder, which represents the preorder traversal of BST (i.e., binary search Tree) construct the tree and return it's root guaranteed that there is always possible to find a binary tree with the given requirements for the given taste cases. Brute force - sort the preorder array to get inorder traversal, then use both preorder and inorder arrays to reconstruct the BST) ( like standard tree construction.) this gives O(n log n ) time due to sorting, which is inefficient when BST properties can guide direct construction. Approach used - •) if order. length ==0, return null ( empty tree). •) create root with first element, root = new tree node (Preorder [0]). •) return root. Helper function - insert Treenode root int val) •if val < root. val , insert in left subtree, - if root.left == null, create node , root left = new tree node( val). - Else recurse left , insert (root, left, val). •) Else ( when Val > root Val ), insert in right subtree, - if root. right == null, crate node , root right = new Tree node ( val ) - Else , recurse right , insert ( root. right, val ). complexity Time - O ( n × h ) , where h = height of tree is a number of nodes. Space - O( h), recursion stack depth. Note - preorder traversal's first element is always the root. By leveraging BST insertion rules . ( smaller values go left , larger go right ), we can sequentially insert each element from the preorder array. each insertion automatically finds the correct position building the BST without needing inorder traversal or sorting. #Java #LearnToCode #Problemsolving #DSA #coding

Your custom Frappe REST API endpoint is probably duplicating authentication logic you don't need. Many engineers building integrations often re-verify user tokens or session validity inside custom Frappe methods. This is redundant and introduces unnecessary complexity. 💡 Leverage `frappe.auth.get_logged_user()` directly within your custom `frappe.whitelist()` method. It handles session validation and returns the current user ID, or raises `frappe.throw` if unauthorized. Before: Manually parsing headers, validating JWTs, and querying 'User' doctype. ❌ After: A single call to `frappe.auth.get_logged_user()` for robust, built-in validation. ✅ This pattern simplifies custom endpoint development significantly, reducing boilerplate by 30-40% and improving maintainability. For Frappe V14+, always check `frappe.auth` utils. ⚙️ What's your go-to Frappe server-side utility that significantly reduced your development effort? #FrappeFramework #RESTAPI #FrappeDevelopment #Python #WebDevelopment #Frappe #ERPNext #Tech

Ever wondered what really happens when you run a .NET application? Let’s break down some confusing terms in the simplest way possible CLR, CLS, MSIL, Assembly — decoded with a real-life example 🏭 Imagine a Food Factory Think of your .NET application as a food factory. 🧑🍳 Step 1: You write code (C#, VB.NET, F#) You prepare recipes in different languages. 👉 But machines don’t understand human recipes directly. ⚙️ MSIL (Microsoft Intermediate Language) What it is: When you compile your code, it doesn’t become machine code directly. Instead, it becomes MSIL (Intermediate Language) — a common language. 👉 Like converting all recipes into a standard cooking format that every machine can understand. 📦 Assembly (.dll / .exe) 📦 What it is: The compiled output (MSIL + metadata) is stored as an Assembly. 👉 Think of it as a packed food box: - Ingredients (code) - Instructions (metadata) - Labels (version info) 🏭 CLR (Common Language Runtime) 🔥 The real hero What it does: - Converts MSIL → Machine Code (JIT Compilation) - Manages memory (Garbage Collection) - Handles exceptions - Ensures security 👉 CLR is like the factory machine that: - Reads the standard recipe (MSIL) - Cooks the actual food (machine code) - Makes sure nothing burns 🔥 CLS (Common Language Specification) What it is: A set of rules that all .NET languages must follow. 👉 Like factory rules: - Use standard ingredients - Follow naming conventions - Ensure compatibility This is why: 👉 C# code can interact with VB.NET code seamlessly Full Flow (Simple View) 1. You write code → C# 2. Compiler converts → MSIL 3. Stored as → Assembly (.dll/.exe) 4. CLR executes → Machine Code Why this matters? ✔ Write code in any .NET language ✔ Run anywhere CLR exists ✔ Automatic memory management ✔ Cross-language compatibility 🎯 One-Line Summary 👉 MSIL = Common language 👉 Assembly = Packaged output 👉 CLR = Execution engine 👉 CLS = Rules for compatibility Most developers use .NET daily… But understanding this pipeline makes you think like a senior engineer. #dotnet #csharp #backenddevelopment #softwareengineering #programming #developers #coding #tech #learning #architecture

🚀 **Debugging with `System.out.println()` vs Structured Logging** When we start programming, the easiest way to debug is: ```java System.out.println("Value of userId: " + userId); ``` Simple. Fast. Helpful. But now think about a **large production system** running thousands of requests per second. Will you still rely on `System.out.println()`? It may work for small experiments, but in real-world systems it creates problems: • No log levels (INFO, DEBUG, WARN, ERROR) • Hard to filter issues in production • Difficult to track events across services • No structured logging for monitoring tools A mature backend system needs **structured and semantic logging**. Instead of printing messages, we use logging frameworks like: * **SLF4J** * **Logback** * **Log4j** Example: ```java private static final Logger log = LoggerFactory.getLogger(UserService.class); log.info("User created with id: {}", userId); log.warn("Invalid login attempt for user: {}", username); log.error("Database connection failed", ex); ``` Now we can: ✔ Filter logs by level ✔ Monitor production systems easily ✔ Integrate with tools like ELK / Grafana ✔ Debug issues without modifying code You can even design **custom logging architecture** using patterns like **Singleton Logger** for centralized logging. 💡 Writing code is only one part of development. Thinking about **system behavior, observability, and architecture** is what makes a developer mature. Explore. Analyze. Design. Then code. That’s how great systems are built. #BackendDevelopment #Java #SystemDesign #Logging #SoftwareArchitecture

HI CONNECTIONS I recently tackled LeetCode 166, a problem that requires careful handling of edge cases, integer overflows, and the logic of long division. 🔍 The Challenge Given two integers representing a fraction, return the result in string format. If the fractional part repeats, enclose the repeating digit(s) in parentheses. Example: 1 / 2 = 0.5 The Twist: 2 / 3 = 0.(6) 🛠️ My Approach: Long Division with Memory The key to identifying a repeating decimal is realizing that if you encounter the same remainder twice during the division process, the digits will start to repeat from that point onward. Handle Signs & Edge Cases: Determine the sign of the result and handle the case where the numerator is 0. Use long (in Java/C++) to prevent overflow when taking absolute values (e.g., -2147483648). Integer Part: Calculate the whole number part using numerator / denominator. Fractional Part: * Use a Hash Map to store each remainder and its corresponding index in the result string. Multiply the remainder by 10 and continue the division. The Detection: If the remainder is already in the map, insert ( at the stored index and ) at the end of the string, then break. Terminate: If the remainder becomes 0, the decimal is terminating. 📊 Efficiency Time Complexity: O(\text{Denominator}) — In the worst case, the number of digits in the repeating part is less than the denominator. Space Complexity: O(\text{Denominator}) — To store the remainders in the hash map. 💡 Key Takeaway This problem is a great reminder that data structures like Hash Maps aren't just for searching—they are essential for "remembering" states in a process. Recognizing cycles is a fundamental skill in both algorithm design and system monitoring. #LeetCode #AlgorithmDesign #HashMaps #Mathematics #SoftwareEngineering #ProblemSolving

🔥 Day 552 of #750DaysOfCode 🔥 🔐 LeetCode 2075: Decode the Slanted Ciphertext (Medium) Today’s problem looked tricky at first, but once the pattern clicked, it became super elegant 😄 🧠 Problem Understanding We are given an encoded string that was: Filled diagonally (↘) into a matrix Then read row-wise (→) 👉 Our task is to reverse this process and recover the original text. 💡 Key Insight If encoding is: ➡️ Fill diagonally ➡️ Read row-wise Then decoding is: ➡️ Read diagonally from row-wise string ⚙️ Approach ✅ Step 1: Calculate number of columns cols = encodedText.length() / rows; ✅ Step 2: Traverse diagonals starting from each column for (int startCol = 0; startCol < cols; startCol++) { int row = 0, col = startCol; while (row < rows && col < cols) { result.append(encodedText.charAt(row * cols + col)); row++; col++; } } ✅ Step 3: Remove trailing spaces 🚀 Complexity Time: O(n) Space: O(n) 🧠 What I Learned How to reverse matrix-based encoding patterns Converting 2D traversal → 1D index mapping Importance of pattern recognition in problems 📌 Takeaway Not every problem needs heavy logic. Sometimes, it's just about seeing the pattern correctly 👀 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Algorithms #SoftwareEngineering #100DaysOfCode #750DaysOfCode

Stop writing `if (obj != null)` checks in every single method. It's 2026, and we still spend hours debugging `NullPointerExceptions` that could have been caught at compile time. The solution isn't more tests; it's better type modeling. Enter Algebraic Data Types (ADTs) and Pattern Matching. This isn't just functional programming jargon; it's the modern standard for clean, safe code across Java, Rust, TypeScript, and more. 💡 Did you know? Recent 2025 data suggests that Null Pointer Exceptions account for roughly 30% of all runtime crashes in Java-based production environments. One simple NPE in Google's Service Control system recently caused a 7-hour global outage. That's the cost of `null`. ADTs let you model your data so that invalid states are unrepresentable. By using Enums (Sum Types) that carry data and Pattern Matching to handle them, you shift error detection from runtime to compile time. 🚀 Why make the switch? ✅ Exhaustiveness Checking: The compiler forces you to handle every possible case. No more forgotten `else` blocks. ✅ Type Safety: You can't accidentally pass a `null` where a value is expected. ✅ Readability: Logic flows naturally with `match` expressions instead of nested `if-else` ladders. Whether you are adopting Sealed Classes in Java 21+, using Rust's powerful enums, or leveraging Discriminated Unions in TypeScript, ADTs are the key to reducing cognitive load and eliminating entire classes of bugs. It's time to stop fighting the type system and start using it to your advantage. How do you handle state modeling in your projects? Are you team `Optional` or team ADTs? #CleanCode #TypeSafety #PatternMatching #CleanCode,#TypeSafety,#PatternMatching,#SoftwareEngineering,#Java,#Rust,#TypeScript Share your favorite ADT pattern in the comments below! 👇

What if you could fix the entire flow of your code… but still allow flexibility where needed? That’s exactly what the Template Method Pattern does. It defines a fixed structure for an algorithm, while allowing specific steps to be customized. 🎬 Simple Example Think of making beverages: Boil water Add ingredient Pour into cup Add extras The process is the same. But Tea 🍵 and Coffee ☕ differ in how certain steps are implemented. 🧠 Why it matters ✔ Promotes code reuse ✔ Ensures consistent workflows ✔ Reduces duplication ✔ Keeps logic clean and maintainable 🌍 Where it is used • Test frameworks (setup → execute → teardown) • CI/CD pipelines • Framework base classes • Workflow systems 💬 Developer Question Have you used Template Method Pattern in your projects? #DesignPatterns #SoftwareEngineering #SystemDesign #OOP #CleanCode #Programming #BackendDevelopment #Java #Python #DotNet #SoftwareArchitecture #Developers

🚀 Model–View–Delegate Pattern in Qt/QML with SQLite In this project, I implemented a complete Model–View–Delegate architecture using Qt (C++) and QML, connected to an SQLite database. 🔹 Designed a clean data layer using an abstract interface (Interfacedb) to handle database operations. 🔹 Built a custom QAbstractListModel to expose structured data to QML. 🔹 Developed a dynamic QML UI using ListView and delegates for real-time data visualization. 🔹 Added live search functionality using a filter model to update results instantly as the user types. 💡 This example demonstrates: Separation of concerns (Data / Logic / UI) Integration between C++ backend and QML frontend Efficient handling of structured data with Qt Model/View Real-time filtering with responsive UI 🔗 GitHub Repository: https://lnkd.in/dK3W5hrW This was a practical exercise to deeply understand how Qt’s Model–View–Delegate pattern works in real-world applications. #Qt #QML #Cplusplus #SQLite #SoftwareEngineering #ModelView #EmbeddedSystems #GUI