Java Methods: Absraction and Responsibility

When I first started programming, I had a very simple mental model: 𝗦𝗮𝗺𝗲 𝗶𝗻𝗽𝘂𝘁 → 𝘀𝗮𝗺𝗲 𝗼𝘂𝘁𝗽𝘂𝘁. It felt almost like math. ⁉️ So I couldn’t understand how a program could sometimes 𝘣𝘦𝘩𝘢𝘷𝘦 𝘥𝘪𝘧𝘧𝘦𝘳𝘦𝘯𝘵𝘭𝘺 𝘸𝘪𝘵𝘩 𝘵𝘩𝘦 𝘦𝘹𝘢𝘤𝘵 𝘴𝘢𝘮𝘦 𝘥𝘢𝘵𝘢. Then I ran into multithreading. And I realized that in concurrent systems, 𝘵𝘪𝘮𝘦 𝘣𝘦𝘤𝘰𝘮𝘦𝘴 𝘱𝘢𝘳𝘵 𝘰𝘧 𝘵𝘩𝘦 𝘪𝘯𝘱𝘶𝘵. Two threads executing the same code can produce different results depending on timing. Not because the logic is wrong but because execution order isn’t guaranteed. ❌ 𝘊𝘰𝘳𝘳𝘦𝘤𝘵-𝘭𝘰𝘰𝘬𝘪𝘯𝘨 𝘤𝘰𝘥𝘦 𝘥𝘰𝘦𝘴𝘯’𝘵 𝘢𝘭𝘸𝘢𝘺𝘴 𝘮𝘦𝘢𝘯 𝘤𝘰𝘳𝘳𝘦𝘤𝘵 𝘣𝘦𝘩𝘢𝘷𝘪𝘰𝘳. 𝗧𝗵𝗶𝘀 𝗶𝘀 𝘁𝗵𝗲 𝗲𝘅𝗮𝗺𝗽𝗹𝗲 𝘄𝗵𝗲𝗿𝗲 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 𝗰𝗼𝗺𝗲𝘀 𝗶𝗻 For example, something as simple as: 𝗰𝗼𝘂𝗻𝘁𝗲𝗿++; isn’t atomic. 𝗜𝘁’𝘀 𝗿𝗲𝗮𝗱 → 𝗺𝗼𝗱𝗶𝗳𝘆 → 𝘄𝗿𝗶𝘁𝗲. If two threads interleave those steps, the result changes. That was the moment I stopped thinking of programs as just logic. They are 𝗹𝗼𝗴𝗶𝗰 + 𝘁𝗶𝗺𝗲 + 𝘀𝗵𝗮𝗿𝗲𝗱 𝘀𝘁𝗮𝘁𝗲. 𝗕𝘂𝘁 𝘄𝗵𝗮𝘁 𝗶𝘀 𝗺𝘂𝗹𝘁𝗶𝘁𝗵𝗿𝗲𝗮𝗱𝗶𝗻𝗴❓ At a basic level, it means running multiple threads inside one program. Instead of doing tasks one by one, the program can be doing 𝘴𝘦𝘷𝘦𝘳𝘢𝘭 𝘵𝘢𝘴𝘬𝘴 𝘢𝘵 𝘵𝘩𝘦 𝘴𝘢𝘮𝘦 𝘵𝘪𝘮𝘦. Why do we use it? 🟢 𝗧𝗼 𝘂𝘀𝗲 𝗺𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝗖𝗣𝗨 𝗰𝗼𝗿𝗲𝘀 🟢 𝗧𝗼 𝗶𝗺𝗽𝗿𝗼𝘃𝗲 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 🟢 𝗧𝗼 𝗸𝗲𝗲𝗽 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝗿𝗲𝘀𝗽𝗼𝗻𝘀𝗶𝘃𝗲 🟢 𝗧𝗼 𝗿𝘂𝗻 𝗯𝗮𝗰𝗸𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗮𝘀𝗸𝘀 Sounds simple but... ...once threads start sharing memory, things get complicated. You can run into: 🟡 𝗥𝗮𝗰𝗲 𝗰𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝘀 🟡 𝗗𝗮𝘁𝗮 𝗶𝗻𝗰𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝗶𝗲𝘀 🟡 𝗗𝗲𝗮𝗱𝗹𝗼𝗰𝗸𝘀 🟡 𝗩𝗶𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆 𝗶𝘀𝘀𝘂𝗲𝘀 It changes how you think about correctness. Now it’s not only “𝘸𝘩𝘢𝘵 𝘩𝘢𝘱𝘱𝘦𝘯𝘴” but also “𝘸𝘩𝘦𝘯 𝘪𝘵 𝘩𝘢𝘱𝘱𝘦𝘯𝘴”. #Java #Multithreading #SoftwareEngineering #Backend #Programming

Day 13 -🚀Array Pairs in Programming An Array Pair is a combination of two elements selected from an array. It is commonly used in many programming problems such as finding target sum, counting pairs, or identifying relationships between elements. Array pairs are usually represented using indices (i, j) where i < j. 📌 Example Array [10, 20, 30, 40, 50] Possible pairs: (10, 20) (10, 30) (10, 40) (10, 50) (20, 30) (20, 40) (20, 50) (30, 40) (30, 50) (40, 50) 📌 Common Problems Using Array Pairs 1️⃣ Find All Possible Pairs Generate all combinations of two elements. 2️⃣ Target Sum Pair Find pairs whose sum equals a given value. Example: Target = 50 Pairs → (10,40), (20,30) 3️⃣ Unique Pairs Avoid duplicate pairs by ensuring i < j. 4️⃣ Count Pairs Calculate the total number of pairs in an array. 💻 Basic Logic (Java) for(int i = 0; i < arr.length; i++) { for(int j = i + 1; j < arr.length; j++) { System.out.println(arr[i] + " , " + arr[j]); } } ⏱ Time Complexity: O(n²) 💡 Understanding array pairs helps solve important problems like Two Sum, pair difference, and combination-based algorithms. #Java #Programming #DataStructures #Arrays #Coding #SoftwareDevelopment #TapAcademy

🔥 LeetCode Daily Challenge — Day Wise DSA Journey Today I solved 696. Count Binary Substrings — a clean and interesting string problem that looks simple but tests observation skills. 🔗 GitHub Solution: https://lnkd.in/gaxUMbRF 💡 Problem Insight We need to count substrings where: ✔️ Number of 0’s and 1’s are equal ✔️ All 0’s and 1’s appear in consecutive groups Instead of checking all substrings (which would be expensive), the trick is to track the lengths of consecutive groups and add the minimum of adjacent group sizes. This reduces the solution to an O(n) single-pass algorithm. (LeetCode Wiki) 🧠 Key Learning Sometimes the optimal solution is not about brute force — it's about recognizing patterns. Breaking the string into groups like 00 | 11 | 00 | 11 makes the problem much simpler to reason about. ⚡ Approach Used Track previous group length and current group length When characters change → add min(prev, current) to answer Greedy + Pattern Recognition 📊 Complexity ⏱️ Time: O(n) 📦 Space: O(1) Consistency over perfection — one problem a day to sharpen problem-solving skills 🚀 #LeetCode #DSA #Java #CodingChallenge #ProblemSolving #SoftwareEngineer #100DaysOfCode #Programming #Developers #LearningInPublic

🚀 Day 522 of #750DaysOfCode 🚀 Today I solved the LeetCode problem “Minimum Changes To Make Alternating Binary String.” 🔹 Problem: Given a binary string consisting of 0s and 1s, we need to make the string alternating (no two adjacent characters are the same). In one operation, we can flip any character (0 → 1 or 1 → 0). The goal is to find the minimum number of operations required. 🔹 Key Idea: An alternating string can only follow two possible patterns: 1️⃣ 010101... 2️⃣ 101010... So we: Count mismatches assuming the string starts with '0'. The other pattern mismatches will be n - mismatch. The minimum of these two values gives the answer. 🔹 Time Complexity: O(n) – we traverse the string once. 📌 Example Input: "1111" Possible alternating strings → "0101" or "1010" Minimum operations → 2 Problems like this highlight how pattern observation can simplify the solution. #leetcode #programming #coding #java #softwaredevelopment #dsa #problemSolving #750DaysOfCode

Async it’s just smart waiting. When people hear async and await, it often sounds complex. Threads? Parallelism? Event loops? But if you look at this simple analogy, the idea is actually clear 👇 Most developers use async and await. But ask this question: 👉 What exactly happens when a coroutine hits await? Does it stop the program? Who resumes it? Is it multithreading? To truly understand async, I built a small repo that explains everything step by step using a simple example: 🍕 Order Pizza (5 min) 🍔 Order Burger (3 min) Synchronous → 8 minutes Async → 5 minutes From there, I break down: • Coroutines • What await really pauses • How the Event Loop manages execution • asyncio.create_task() vs gather() • Blocking vs Non-blocking (with real timing comparison) Clean examples. No overcomplication. Just clarity. If you're learning backend development this might help. 🔗 https://lnkd.in/dPxiPXMA Feedback is always welcome 👨💻 #Python #AsyncProgramming #SoftwareEngineering #Backend #Developers

🚀 Day 510 of #750DaysOfCode 💻 LeetCode 761 – Special Binary String (Hard) Today’s problem was a tough one! 🔥 A Special Binary String has two properties: ✔️ Equal number of 0’s and 1’s ✔️ Every prefix has at least as many 1’s as 0’s At first glance, it looks like a string manipulation problem… But the real insight? 👇 👉 It behaves exactly like a Valid Parentheses problem If we treat: 1 → ( 0 → ) The string becomes a balanced parentheses structure. 🧠 Approach: Break the string into primitive special substrings Recursively solve each inner substring Sort the substrings in descending lexicographical order Join them back together This is a beautiful combination of: ✨ Recursion ✨ Greedy Strategy ✨ String manipulation ✨ Structural decomposition 💡 Key Learning: Sometimes the hardest problems become simple once you identify the hidden pattern. Recognizing that this is equivalent to balanced parentheses was the breakthrough moment. Problems like this improve: Pattern recognition Recursive thinking Problem decomposition skills Hard problems don’t test coding — They test how you think. 💭🔥 Onward to Day 511 🚀 #750DaysOfCode #Day510 #LeetCode #Java #DataStructures #Algorithms #Recursion #Greedy #ProblemSolving #CodingJourney

Day 52 - LeetCode Journey Solved LeetCode 11: Container With Most Water (Medium) today using the Two Pointer approach. This journey isn’t about solving the hardest problems daily, but about showing up consistently and improving step by step. Problems like this help in building a deeper understanding of how optimization actually works. Today’s problem reinforced key concepts like: • Using two pointers to reduce time complexity • Understanding how width and height affect area • Moving the pointer with smaller height for better results • Avoiding brute force and thinking optimally The key idea is simple — start from both ends and move intelligently to maximize the area 💡 Every problem adds a new layer to problem-solving skills, and that’s where real growth happens 💯 ✅ Better understanding of two-pointer technique ✅ Improved optimization thinking ✅ More confidence in DSA concepts Still a long way to go, but progress is progress 🚀 #LeetCode #DSA #Java #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #Algorithms #Programming #DeveloperJourney #KeepCoding

Day 18 of My Programming Journey – Time Complexity Today I learned about Time Complexity, which helps measure how efficient an algorithm is as the input size grows. Understanding time complexity helps developers write optimized and scalable code. 📌 What is Time Complexity? Time complexity describes how the running time of an algorithm increases with the size of the input (n). 🔹 Common Time Complexities • O(1) – Constant Time • O(log n) – Logarithmic Time • O(n) – Linear Time • O(n log n) – Linearithmic Time • O(n²) – Quadratic Time 🔹 Types of Time Complexity Analysis ✔ Best Case The minimum time required for an algorithm to run. Example: Finding an element at the first position in linear search. ✔ Average Case The expected time an algorithm takes for typical input. ✔ Worst Case The maximum time an algorithm takes when the input is in the most difficult case. Example: Searching an element at the last position in linear search. 💻 Problems I Practiced • Linear Search • Finding largest element in an array • Nested loop programs (O(n²)) • Comparing different algorithm efficiencies #Programming #Java #TimeComplexity #DSA #CodingJourney #LearningDaily

✳️Day 17 of #100DaysOfCode✳️ Solving the Longest Common Subsequence Problem! 🚀 I recently took on the "Longest Common Subsequence" (LCS) challenge on LeetCode—a classic problem that perfectly illustrates the power of Dynamic Programming. Here’s the step-by-step approach I took: ✅ 1. Problem Decomposition: I broke the problem down into smaller sub-problems. If the last characters of two strings match, they contribute to the subsequence; if not, we explore the possibilities by skipping a character from either string. ✅ 2. Recursive Foundation: I started by defining the base case—if either string is empty, the LCS length is 0. ✅ 3. Optimization with Memoization: Pure recursion leads to redundant calculations (overlapping sub-problems). I implemented a 2D array (dp[n][m]) to store results of previously computed states, significantly boosting performance. ✅ 4. Refinement: Fine-tuning the logic to ensure the time and space complexity were balanced for an efficient "Accepted" result . Always learning, always coding. On to the next challenge! 💻 #LeetCode #Java #DynamicProgramming #CodingLife #SoftwareEngineering #ProblemSolving