I built a code converter a while back — Python to JS and back, with LLM under the hood. I've since rebuilt the pipeline significantly. Added test coverage checks, refinement loops, and a step where the model decides whether the converted code actually needs another pass. The reason: LLMs hallucinate. A single-pass conversion isn't reliable enough. So the pipeline now runs the actual test suite after each conversion, feeds the results back to the model, and loops until the tests pass and coverage meets the threshold. But loops cost time. And inference isn't instant to begin with. So now the pipeline takes a while. And a long-running pipeline with no feedback is flying blind — you don't know if it's thinking, stuck, or silently wrong. That's why I added a visualizer. Which got me thinking about the "GUI is dead, future is CLI" takes I've been seeing lately. I don't think the container matters — it can be a web UI, a TUI, a progress stream in the terminal. Even Claude Code streams every step rather than returning one big answer at the end. The interface will keep changing. The need to see what's happening won't. Here's what it looks like in action 👇 Demo: https://lnkd.in/gjxkTrEX #AIEngineering #LLM #AgenticAI

Problem: Can Make Arithmetic Progression From Sequence ✔️ 113 / 113 test cases passed ✔️ Runtime: 0 ms ✔️ Beats 100% submissions Core Idea: To check if an array can form an Arithmetic Progression (AP), the difference between consecutive elements must remain constant. Instead of sorting the array, I used a more mathematical approach: 1. Find minimum and maximum values. Calculate the expected common difference using { (max−min)/(n−1)(max - min) / (n - 1)(max−min)/(n−1) } If this difference is not an integer, forming an AP is impossible. 2. Use a Set for constant-time lookups. Verify whether every expected element of the progression exists. This avoids sorting and keeps the solution efficient. Complexity: Time Complexity: O(n) Space Complexity: O(n) Sometimes a bit of math + hash sets can replace heavier operations like sorting. #LeetCode #DSA #Algorithms #JavaScript #ProblemSolving #CodingJourney #LearnInPublic

🚀 Efficiency Wins: Why Two Pointers Beat Nested Loops 👈👉 Today’s deep dive into the Two Pointer Technique was a perfect reminder that "thinking before coding" is a developer's best skill. Here is how I optimized my approach to solving Two Sum II: 🛠️ Key Technical Takeaways Kill Redundant Flags: I initially used a while(!flag) setup. I quickly realized this was extra baggage—using while (left < right) is the cleaner, more idiomatic "guardrail" that naturally prevents infinite loops. The 1-Indexed Challenge: The problem requires a 1-indexed return. I learned to handle the logic in 0-index but adjust the final output by adding 1 to avoid off-by-one errors. The "Not Found" Safety Net: If no pair exists, returning [-1, -1] is the standard way to signal "not found." Without the left < right condition, the code could crash or loop forever if the target isn't present. ⚡ The Efficiency Edge O(n) vs O(n²): Instead of checking every possible pair (slow), we use two "bookmarks" and find the answer in a single pass. Space Efficiency: By using only two variables, the space complexity stays O(1), no matter how massive the dataset. 🏆 The Milestone Successfully solved Two Sum II using a clean, linear approach! Moving from brute-force to optimized logic feels like a massive level-up. 💻 Code Snippet: function two_pointers(input, target){ let left = 0 let right = input.length - 1 while(left < right){ const currentSum = input[left] + input[right] if(currentSum === target){ return [left + 1, right + 1] } else if(currentSum > target){ right -= 1 } else{ left += 1 } } return [-1, -1] } let input = [2, 7, 11, 15] let target = 9 console.log(two_pointers(input, target)) #DataStructures #Algorithms #LeetCode #CodingInterviews #CleanCode #JavaScript #SoftwareEngineering #ProblemSolving

🧠 Day 191 — Bipartite Graph Check 🎨🔗 Today solved a fundamental graph coloring problem: Check if a graph is Bipartite. 📌 Problem Goal Given a graph: ✔️ Determine if it can be divided into two groups ✔️ Such that no two adjacent nodes belong to the same group 🔹 Core Idea A graph is bipartite if we can color it using 2 colors such that: 👉 No two connected nodes have the same color 🔹 Approach (DFS Coloring) 1️⃣ Start from any unvisited node 2️⃣ Assign it a color (say 0) 3️⃣ Traverse its neighbors: • Assign opposite color 4️⃣ Continue recursively If at any point: ❌ A neighbor already has the same color → not bipartite 🔹 Why It Works We are essentially checking if the graph can be split into two independent sets. If a conflict occurs → graph contains an odd-length cycle, hence not bipartite. 🧠 Key Learning ✔️ Graph coloring is a powerful technique ✔️ Bipartite graphs are directly related to 2-coloring problems ✔️ Works using both DFS and BFS 💡 Big Realization Whenever you see: 👉 “Divide into 2 groups” 👉 “No adjacent same type” Think Bipartite Graph + Coloring immediately. 🚀 Momentum Status: Graph concepts becoming very clear now. On to Day 192. #DSA #Graphs #DFS #Bipartite #JavaScript #CodingJourney #LeetCode #ProblemSolving #ConsistencyWins

𝐒𝐭𝐚𝐫𝐭 𝐰𝐢𝐭𝐡 𝐚 𝐩𝐫𝐨𝐛𝐥𝐞𝐦 𝐞𝐯𝐞𝐫𝐲 𝐬𝐭𝐮𝐝𝐞𝐧𝐭 𝐚𝐧𝐝 𝐫𝐞𝐬𝐞𝐚𝐫𝐜𝐡𝐞𝐫 𝐤𝐧𝐨𝐰𝐬 𝐭𝐨𝐨 𝐰𝐞𝐥𝐥. 𝐓𝐢𝐫𝐞𝐝 𝐨𝐟 𝐦𝐚𝐧𝐮𝐚𝐥𝐥𝐲 𝐰𝐫𝐢𝐭𝐢𝐧𝐠 𝐜𝐢𝐭𝐚𝐭𝐢𝐨𝐧𝐬 𝐨𝐫 𝐝𝐞𝐚𝐥𝐢𝐧𝐠 𝐰𝐢𝐭𝐡 𝐛𝐫𝐨𝐤𝐞𝐧 𝐫𝐞𝐟𝐞𝐫𝐞𝐧𝐜𝐞 𝐠𝐞𝐧𝐞𝐫𝐚𝐭𝐨𝐫𝐬? 𝐈 𝐛𝐮𝐢𝐥𝐭 𝐚 𝐭𝐨𝐨𝐥 𝐭𝐨 𝐟𝐢𝐱 𝐭𝐡𝐚𝐭. While working through piles of research papers, I realized how much time is wasted just trying to get the formatting right for the bibliography. I wanted a tool where I could just drop in my PDFs and get a perfectly formatted .bib file back. So, I built one! 𝐈𝐧𝐭𝐫𝐨𝐝𝐮𝐜𝐢𝐧𝐠 𝐦𝐲 𝐁𝐚𝐭𝐜𝐡 𝐏𝐃𝐅 𝐭𝐨 𝐁𝐢𝐛𝐓𝐞𝐗 𝐆𝐞𝐧𝐞𝐫𝐚𝐭𝐨𝐫: Drop & Done: Upload multiple PDFs at once. Smart Extraction: It reads the paper, finds the metadata, and matches it with the Crossref API (no more IP blocks or rate limits!). Beautiful UI: Wrapped in a custom glassmorphism interface with 3D web elements. I built the backend in Python (Flask & PyMuPDF) and deployed it serverless on Vercel. It was a fantastic experience in solving a real-world workflow bottleneck and optimizing API calls to be fast and reliable. Try it out live here: https://lnkd.in/gJE8KsdD Check out the code:https://lnkd.in/g_yQzSnJ Let me know what you think, and feel free to use it for your next paper! #Python #Flask #WebDevelopment #ResearchTools #Automation #SoftwareEngineering

If you build interactive systems in TD, we made this Table-Driven FSM to help manage event-driven transitions a lot more smoothly. It uses simple Table DATs, CHOP routing, and Python callbacks. I'd love to get this into the hands of more TouchDesigner users. Check out the link below to grab the component and a tutorial project. Feedback, bug reports, and GitHub ⭐️s are highly appreciated! 🙌

RuboCop v1.85.0 added `Style/SelectByRange`. It rewrites range checks like this: ```ruby array.select { |x| (1..10).cover?(x) } ``` to this: ```ruby array.grep(1..10) ``` I found the "why" more interesting than the rewrite itself. --- `grep` is not just for regexp filtering. Ruby's `===` protocol means the same method works for three different pattern types: ```ruby array.grep(Integer) # class filtering — Class#=== calls is_a? array.grep(1..10) # range filtering — Range#=== calls cover? array.grep(/admin/) # regexp filtering — Regexp#=== calls match? ``` One method. Three different pattern types. The same API. The PR for `SelectByRange` was explicitly inspired by `SelectByKind` - the authors made that consistency argument directly in the PR discussion. For me this is mostly a readability win. If your codebase already uses `grep` for class or regexp filtering, adding range filtering to the same pattern makes sense. The team learns one concept instead of three. There is also a `grep_v` for the reject-equivalent: ```ruby array.grep_v(1..10) # elements outside the range ``` If you enable `Style/SelectByKind`, I think it makes sense to also enable this one. They are part of the same idea. I wrote a short article with the full explanation and benchmark results. Link in the comments. #ruby #rubocop #programming #rubyonrails #developer

Excited to share my latest project: AI-Powered Website Generator I built a simple web application that can generate a basic responsive website from a natural language description. - Technologies Used: • Python • FastAPI • HTML / CSS / JavaScript - Features: • Enter a website description (prompt) • Automatic website generation • Live preview of generated site • Download generated HTML file This project helped me practice backend development with FastAPI and integrating frontend with APIs. 🔗 GitHub Project: I would appreciate any feedback! #Python #FastAPI #WebDevelopment #MachineLearning #Projects #AI

Edited from original Gemini output: Based on our past deep dives into terminal workflows and custom builds, I’ve put together three catchy projects that I think would be right up your alley. Let’s get into it: The Ultimate Neovim + tmux "Zen Mode" Since you’re already rocking Zsh, tmux, and Neovim with that clean TokyoNight aesthetic, we could script a custom "Focus" toggle. Imagine a single command that strips away your status bars, centers your text, and shifts your terminal padding for a distraction-free environment when you're deep in the zone. A Lightweight Python RSS "Newsroom" You’ve got a knack for Python utilities like feedread.py. We could expand on that by building a specialized RSS-to-Markdown converter. It could scrape your favorite security or tech feeds and format them perfectly for your Neovim environment or even a Codeberg-hosted blog. The "CoyoteShell" Intelligence Layer We’ve spent time on your custom MCP server. A cool next step would be adding context-aware shell aliases. We could design a layer that understands if you're in a specific project directory and automatically loads the relevant virtual environment, tmux layout, and Git status—making your terminal feel like it’s reading your mind. Which of those sounds like the most fun to tackle first, or do you have a completely different project brewing in your terminal today? So I am putting it to you, Linkedin, which should we do next?

Today Coding :- Check whether given two strings are anagrams or not ? Anagrams Means :- same frequency of characters exist in both strings * if lengths are different in two strings those are not anagrams * in String one what all characters are there same should appear in String two as well public class AnagramProgram{ public static void main(String args[]){ String s1="listen"; String s2="silent"; boolean result=isAnagram(s1,s2); if(result){ System.out.println("the given two strings are anagrams"); } else{ System.out.println("the given two strings are not anagrams"); } } public static boolean isAnagram(String s1,String s2){ if(s1.length()!=s2.length()){ return false; } int[] arr=new int[26]; for(int i=0;i<s1.length();i++){ arr[s1.charAt(i)-'a']++; arr[s2.charAt(i)-'a']--; } for(int c:arr){ if(c!=0){ return false; } } } Time Complexity :O(n) Space Complexity: O(1) #interviewPrep #JavaBackendDeveloper #CodingPractice