Aiko Jansen’s Post

Refactoring for Clarity: Array Manipulation in Java 👨💻 I’ve just finished a practical exercise on array manipulation. While the goal was simple (summing two arrays), I used it as an opportunity to apply improvements. - Method decomposition: Separated concerns into specialized methods (Read, Calculate, Display). - Input validation: Built a robust loop to handle invalid inputs and prevent crashes. - Data Formatting: Used printf to create a clear, readable results table. Small improvements in logic and organization make a huge difference in software quality. #Java #Algorithms #CleanCode #Backend #LearningToCode

Every agnostic lib relies in one concept, interfaces. Think twice before add any concrete type, even if you won’t expose implementations, define them. The beauty of any well architected software is not on its implementation, but how contracts are defined. #software #systemdesign #interfaces #java #oop #csharp #python #cpp

Every time I opened a new Java project in VS Code, I had to set it up from scratch. I work across multiple Java repositories. IntelliJ is my main IDE, but I use VS Code and Cursor for quick navigation and AI-first coding. Lighter. Always ready. But it doesn't pick up IntelliJ configs automatically. So every new project meant: - Mapping source folders manually - Fixing JAR paths - Setting the JDK again Same steps every time. So I tried something different. Instead of writing a script, I wrote a Markdown file. Step-by-step instructions telling the AI exactly what to do. A small snippet from the file: - Check .idea at root only (ignore subdirs) - Extract source roots from .iml files - Map them to java.project.sourcePaths Now I just type /java-vscode-setup in VS Code or Cursor Agent. The AI scans the project. Generates the correct settings.json. Confirms changes before applying them. No scripts. No extra tools. Just clear instructions. This changed how I think about automation. Instead of writing scripts to do the work, you write instructions that guide the AI to do it. Same result. Less hassle. Works across every repo. Could I have done this with a Python script? Yes. But I'm already in Claude or Cursor anyway. So I built it where I work. Still experimenting with this approach. Curious - what task have you turned into a slash command? #AI #Cursor #Claude #VSCode #DevTools

𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗝𝗮𝘃𝗮’𝘀 𝘃𝗮𝗿 Recently, I explored how Java introduced Local Variable Type Inference (var) in Java 10 and how it transformed the way developers write cleaner and more expressive code. Java has traditionally been known for its verbosity. With the introduction of var through Project Amber, the language took a major step toward modern programming practices—balancing conciseness with strong static typing. 𝗪𝗵𝗮𝘁 𝗜 𝗹𝗲𝗮𝗿𝗻𝗲𝗱: • var allows the compiler to infer types from initializers, reducing boilerplate without losing type safety. • It is not a keyword, but a reserved type name, ensuring backward compatibility. • Works only for local variables, not for fields, method parameters, or return types. • The inferred type is always static and compile-time resolved—no runtime overhead. • Powerful in handling non-denotable types, including anonymous classes and intersection types. Must be used carefully: • Avoid when the type is unclear from the initializer • Prefer when the initializer clearly reveals the type (e.g., constructors or factory methods) • Enhances readability only when the initializer clearly conveys the type. 𝗞𝗲𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆: var is not just about writing less code—it’s about writing clearer, more maintainable code when used correctly. The real skill lies in knowing when to use it and when not to. A special thanks to Syed Zabi Ulla sir at PW Institute of Innovation for their clear explanations and continuous guidance throughout this topic. #Java #Programming #SoftwareDevelopment #CleanCode #Java10 #Developers #LearningJourney

Today I explored some fundamental yet powerful concepts in Java that every developer should have a strong grip on: 🔹 Static Methods & VariablesUnderstanding how static members are shared across all objects really changed how I think about memory and efficiency. It’s amazing how a simple static keyword can help track object creation and maintain shared data seamlessly. 🔹 Constructor Overloading & this KeywordThis concept made object initialization much more flexible. Using multiple constructors and the this keyword not only improves code readability but also avoids redundancy. 💡 What I realized:Strong basics are the real game-changer. These concepts might look simple, but they build the foundation for writing clean, scalable, and efficient code. 📌 Consistency in learning > Complexity in topics I’m currently focusing on strengthening my core Java skills and building projects around them. Every small concept learned today contributes to becoming a better developer tomorrow. #Java #Programming #CodingJourney #DeveloperLife #JavaDeveloper #Learning #TechSkills #Coding #StudentDeveloper

🚀 Leetcode : 1768. Merge Strings Alternately Ever needed to merge two strings by alternating their characters? Here's a simple and optimized approach using StringBuilder in Java 👇 💡 What this solution does: Takes two input strings Merges them character by character in alternating order Handles unequal lengths gracefully 🔍 Key Highlights: Uses StringBuilder for better performance (avoids unnecessary string creation) Single loop with clean condition (i < n1 || i < n2) Easy to read and efficient 📌 Example: Input: "abc", "pqrstu" Output: "apbqcrstu" ⚙️ Complexity Analysis: Time Complexity: O(n + m) 👉 We traverse both strings once (n = length of word1, m = length of word2) Space Complexity: O(n + m) 👉 Because we store the final merged string in StringBuilder #Java #Coding #Programming #LeetCode #DataStructures #Algorithms #ProblemSolving #Developer #StringManipulation #CleanCode #Tech #TimeComplexity #SpaceComplexity #SoftwareEngineering #DevLife #CodeNewbie #100DaysOfCode #TechCommunity #ProgrammingLife #DevelopersLife #TowPointer 🚀

Day 3 of Java with DSA Journey 🚀 📌 Topic: Guess Number Higher or Lower (LeetCode 374) 💬 Quote: "Efficiency is not about doing more; it's about eliminating what doesn't matter." ✨ What I Learned: 🔹 Binary Search Beyond Arrays: Binary Search isn’t limited to arrays — it works perfectly on a number range like [1...n]. 🔹 Working with APIs: Learned how to adapt logic based on API responses: -1 → Guess is too high 1 → Guess is too low 0 → Correct answer 🔹 Power of Efficiency: Even for a huge range (up to 2³¹ - 1), Binary Search finds the answer in ~31 steps 🤯 Compared to Linear Search → practically impossible! 🔹 Complexity: ⏱ Time: O(log n) 📦 Space: O(1) 🧠 Problem Solved: ✔️ Guess Number Higher or Lower 💡 Key Insight: This problem highlights the “Narrowing the Search Space” concept. Each step eliminates half the possibilities — that’s the magic of logarithmic algorithms ⚡ ⚡ Interview Insight (3-Way Decision Logic): Unlike boundary problems, here we deal with three outcomes: 1️⃣ 0 → Found the number (return immediately) 2️⃣ -1 → Move right = mid - 1 3️⃣ 1 → Move left = mid + 1 👉 Use while (left <= right) since the target is guaranteed to exist. 🔑 Takeaway: Consistency beats intensity. Showing up daily is what builds mastery. #DSA #LeetCode #Java #CodingJourney #BinarySearch #ProblemSolving #100DaysOfCode #JavaDeveloper #Algorithms

Before Java… Writing software wasn’t “coding”. It was survival. ... You wrote a program on one machine. Tried running it somewhere else? It broke. Different OS. Different CPU. Different behavior. Same code. Completely different results. ... So what did developers do? Rewrite everything. Again. And again. And again. ... This wasn’t engineering. This was chaos. Then Java showed up. And quietly changed everything. ... Instead of running directly on the system… Java introduced something new: 👉 A middle layer. The Java Virtual Machine (JVM) --- Now the process looked like this: Write code once → Compile to bytecode → Run anywhere with JVM --- No more rewriting. No more platform headaches. No more “it works on my machine”. --- This idea sounds obvious today. But back then? It was revolutionary. --- Java didn’t just make things easier. It made software scalable. And almost every modern system today… Still follows this philosophy. --- If Java never existed… What do you think would have replaced it? Or would we still be rewriting code for every machine? Curious to hear your take 👇 #Java #Programming #ComputerScience #SoftwareEngineering #Developers #Coding #PolarisSchoolOfTechnology #MedhaviSkillsUniveristy

#4 Compiled vs Interpreted Languages: What Actually Happens When You Run Code When you hit “run,” your code has to become something the CPU can execute. The two main ways that happens are compilation and interpretation. Compiled languages-C, C++, Rust, Go You write source code → a compiler translates the entire program into machine code → you run the resulting executable file. How it feels You get a standalone .exe or binary you can run without the source. Faster execution because the CPU runs native machine code directly. Errors show up before you run the program (compile-time errors). Trade-offs: You must recompile every time you change code. The binary is platform-specific -a Mac binary won’t run on Windows. Interpreted languages-Python, JavaScript, Ruby You write source code → an interpreter reads it line by line and executes it on the spot. How it feels You can change a line and run it immediately great for experimentation. Same code runs on any OS that has the interpreter installed. Easier debugging because errors appear as you go. Trade-offs Slower execution because each line is translated at runtime. You need the interpreter installed wherever the code runs. The hybrid - Java, C# These languages compile your code to an intermediate form (bytecode). A virtual machine (JVM or .NET CLR) then interprets or JIT-compiles the bytecode to machine code at runtime. Why it matters: You get portability -same bytecode runs everywhere and near-native speed for hot code paths. Compiled languages trade convenience for speed; interpreted languages trade speed for convenience. Hybrid languages aim for both. In practice, the choice depends on whether you need raw performance or rapid development. #AGIT9 #WomaninTechnology #Buildinpublic #CompiledvsInterpreted #Masikana

Most developers read files. Fewer actually process them efficiently. Here’s a simple but powerful example using Java Streams — counting the number of unique words in a file in just a few lines of code. What looks like a basic task actually highlights some important concepts: • Stream processing for large data • Functional programming with map/flatMap • Eliminating duplicates using distinct() • Writing clean, readable, and scalable code Instead of looping manually and managing data structures, this approach lets you express the logic declaratively. It’s not just about solving the problem — it’s about solving it the right way. Small improvements like this can make a big difference when working with large datasets or building production-grade systems. How would you optimize this further for very large files? #Java #JavaDeveloper #StreamsAPI #FunctionalProgramming #CleanCode #BackendDevelopment #SoftwareEngineering #Programming #DevelopersOfLinkedIn #CodingJourney #TechLearning #100DaysOfCode