Razvan Marescu

JetBrains just announced they're moving to a single, unified IntelliJ distribution starting with version 2025.3. No more choosing between Community and Ultimate - it's one IDE with features unlocked by subscription. Why does this matter? • Some previously paid features (Spring support, database tools) are becoming FREE • The open-source commitment remains, but with a twist • This signals bigger changes in how dev tools compete in the AI era I spent time analyzing the announcement and its implications. This isn't just about IntelliJ - it's about the future of IDEs in a world where AI assistants are changing how we write code. Full analysis here → https://lnkd.in/gBpSNWUu Curious: How many of you are using IntelliJ Community Edition today? What's your take on this change?

161

4 Comments

PSA: if you want to make your software 100x easier to debug, design it with deterministic randomness. Almost every system you build has some form of randomness baked in: • random IDs and UUIDs • shuffling lists of results • load balancing requests That is all fine. But the problem is that it’s hard to get the same "random" behavior to happen again when you spot a bug. The solution is to build your stack with deterministic randomness. Haven’t heard of it? It’s what it sounds like. Most random generators are not fully random, but pseudo-random. Pseudo-random generators (like java.util.Random) are driven off an internal state: • when you ask for a random value, it looks at its internal state • it uses that state to compute the next value and returns it • it advances its internal state • repeat    So when you ask Java's Random object for values and it gives you unpredictable results, it's because Random's *initial state* has been randomly set for you already.      💡 If you want deterministic randomness, just set its initial state yourself. This is called setting the seed. Nothing explains this better than code, so just look at the screenshot and you'll see what I mean. (But if you do this, take care to use deterministic randomness everywhere! Missing it in just one place will break determinism. In my product, I have an entire "random API" that proxies into a deterministic set of functions so I won't mess it up.)

336

58 Comments

🔑 𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗦𝗢𝗟𝗜𝗗 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝗶𝗻 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗗𝗲𝘀𝗶𝗴𝗻 Writing clean, maintainable, and scalable code isn’t just about syntaxit’s about design. That’s where SOLID Principles come in. These five timeless guidelines help developers build robust applications that are easier to extend, test, and maintain. Let’s break them down with practical detail: 1️⃣ 𝗦𝗶𝗻𝗴𝗹𝗲 𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗦𝗥𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: A class should have only one responsibility or reason to change. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: - Classes that do too much quickly become fragile and hard to - maintain. Changing one responsibility might accidentally break another. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Focused classes are easier to understand, test, and reuse. 2️⃣ 𝗢𝗽𝗲𝗻-𝗖𝗹𝗼𝘀𝗲𝗱 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗢𝗖𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: Classes should be open for extension, closed for modification. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: - Keeps existing code stable while allowing new features to be added. - Prevents bugs from creeping in when requirements change. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Future-proof code that supports growth without breaking existing features. 3️⃣ 𝗟𝗶𝘀𝗸𝗼𝘃 𝗦𝘂𝗯𝘀𝘁𝗶𝘁𝘂𝘁𝗶𝗼𝗻 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗟𝗦𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: Subclasses should replace their base classes without breaking the application. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: Violations lead to unexpected behavior and broken inheritance chains. Ensures your abstractions actually behave as promised. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Reliable and consistent code with true polymorphism. 4️⃣ 𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 𝗦𝗲𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗼𝗻 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗜𝗦𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: No client should be forced to depend on methods it does not use. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: - Large interfaces become “fat” and force implementing classes to provide dummy methods. - Leads to unnecessary coupling. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Flexible contracts that encourage clean, modular design. 5️⃣ 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗜𝗻𝘃𝗲𝗿𝘀𝗶𝗼𝗻 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗗𝗜𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: Depend on abstractions, not concrete implementations. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: - High-level modules shouldn’t be tied to low-level implementation details. - Makes code easier to test, mock, and extend. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Enhances testability, reduces coupling, and increases flexibility. 💡 Next time you write a class, ask yourself: Am I following SOLID? 👉 Follow me Kanaiya Katarmal, and hit the 🔔 on my profile so you don’t miss upcoming .NET tips and deep dives. 𝗧𝗵𝗮𝗻𝗸𝘀 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 𝗹𝗲𝘁’𝘀 𝗰𝗼𝗻𝘁𝗶𝗻𝘂𝗲 𝗴𝗿𝗼𝘄𝗶𝗻𝗴 𝗮𝗻𝗱 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴 .𝗡𝗘𝗧 𝘁𝗼𝗴𝗲𝘁𝗵𝗲𝗿! 👉 𝗦𝘂𝗯𝘀𝗰𝗿𝗶𝗯𝗲 𝘁𝗼 𝗺𝘆 𝗻𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿: https://lnkd.in/dp7tz_3V #SoftwareEngineering #SOLIDPrinciples #CleanCode #DesignPatterns #Programming #CodeQuality #Developers #SoftwareDesign #OOP

399

29 Comments

"So, how will the task scheduler execute the tasks?" asked the interviewer in a system design round for building a distributed task scheduler. Interviewee: "It will poll the database for tasks scheduled in the current minute and send them to executors (workers) for execution." Interviewer: "Are you saying it would give tasks directly to workers?" Interviewee: "It can... but we’re executing 1 billion tasks a day. Considering that scale, and the spikes at times, we’ll need something to decouple the scheduler and the workers." Interviewer: "So, what will you do?" Interviewee: "I’ll use events via Kafka." Interviewer: "Great. So, tell me, how will it work?" Interviewee: "We’ll need a large number of partitions in Kafka so that we can have more consumers processing tasks in parallel." Interviewer: "Do you see any challenges with this setup, especially for long-running tasks?" Interviewee: "Hmm, I think I know what you’re hinting at… You mean that if a Kafka consumer picks up a long-running task from a partition, it blocks other tasks in that partition, since Kafka enforces strict ordering per partition." Interviewer: "Yes, exactly. Now if that task takes an hour, no other tasks from that partition can be executed, even though they should start in the current minute." Interviewee: "Agreed. We definitely need to start executing them in the current minute to meet the SLA. While we can’t guarantee completion within the same minute, execution must at least begin." Interviewer: "Exactly. So what will you do?" Interviewee: "I wouldn’t use Kafka here. I’d use an eventing system with non-blocking message consumption, like RabbitMQ or SQS." Interviewer: "Spot on. Which one would you pick?" Interviewee: "If I’m already on AWS and want to focus on business logic rather than managing infrastructure, I’d go with SQS. Otherwise, RabbitMQ. And given the scale, I’d prefer a managed queue anyway." Interviewer: "Agreed. Focus on solving the business problem first. By the way, how will you scale the workers in case of SQS?" Interviewee: "I’ll use SQS metrics like ApproximateNumberOfMessagesVisible." Interviewer: "Great." 𝘛𝘰 𝘣𝘦 𝘤𝘰𝘯𝘵𝘪𝘯𝘶𝘦𝘥… Many engineers treat Kafka as a panacea for system design problems. That’s a big mistake. While it solves many problems, it’s not always the right fit. - When you need non-blocking event consumption, or complex event routing, Kafka isn’t ideal. - For low-throughput event publishing, Kafka is often overkill. Use tools based on the problem statement and what they’re designed for, not just because everyone else is using them. If you’re preparing for mid-senior SDE or EM system design interviews and need help, DM me COACH.

55

15 Comments

Flaky tests feel random. They’re not. The patterns are clear: * Timing issues (async workflows, race conditions) * Shared state (bad test isolation, order dependencies) * Environment drift (things that work locally but fail in CI) By definition, though, they’re not obvious to spot. A missing await, an unseeded random number, a fragile assertion. These problems tend to show up after the developer who wrote them has moved on to the next thing, reducing the likelihood that anyone will take time to fix them. AI is going to multiply these issues. It’s *also* going to help us catch them faster. The challenge for leaders: don’t accept flaky tests as inevitable. They’re just tech debt we’ve been too slow to pay down.

43

Mid-level devs are great at solving the problem in front of them. Seniors start spotting the patterns of problems. Example: 🔹Mid-level: “I fixed the timeout bug on this API call.” 🔹Senior: “This timeout happens on three services - we need a retry/backoff strategy across the board.” If you want to grow into senior, practice lifting your head up. Don’t just fix the issue. Ask: Where else could this happen?

116

14 Comments

"I’ve been writing tests first since before it had a name, and have trained and coached thousands of other developers in these disciplines. If there’s one thing I’ve learned from all that TDD experience, it’s this: if you don’t want to learn TDD, you won’t." This course book will be 10 years old next year, and due for retirement to coincide with the launch of... well, something new. It's in Goodread's top 5 TDD books, despite never having been for general sale. (If you bought a signed copy, thank you.) I don't track stats, so I don't know how many downloads it's had. But I did order every printed copy, so I know there are about 2,000 sitting on shelves somewhere. I ran an onsite course last year for a regular client, and was gratified to see a bunch of them in their library. Some clients, like Redgate, ordered a box of them. But when you read it, you'll see that it needs updating. The principles are timeless, but the implementations move on. Same chords, different arrangements. In the meantime, get 'em while you can :-) https://lnkd.in/eVm7ghCc

57

8 Comments