João Francisco Santos

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?

162

4 comentarios

Code reviews aren’t just about catching bugs. They're about raising the bar for everyone. Yes, reviews help spot issues before they reach production. But if that’s all you use them for, you’re missing the bigger picture. Too many developers treat code reviews like a game of “gotcha". Pointing out tiny errors. Flexing knowledge. Nitpicking style over substance. But here’s the truth: no one gets better by being embarrassed. They grow when they feel safe enough to ask, fail, and learn. Here’s what code reviews should not be: ✘ A place to prove you're smarter ✘ A way to score points or find faults ✘ A ritual that leaves someone demotivated And here’s what they should be: ✔ A chance to teach, not preach ✔ A chance to share knowledge and context. ✔ A moment where both the author and review learn. Your job in a review isn’t just to approve or reject. It’s to communicate. To help the next dev avoid the same bug. To explain the why, not just the what. To help juniors feel confident, not scared. Be kind to the person. Be critical of the code. That balance is where real growth happens. The best teams? They treat reviews as a collaborative learning process. Not a quality gate. Not a judgement zone. Because strong code comes from strong feedback. But only when it comes from the right place. Code is temporary. How you made someone feel during the review? That sticks. Don’t just review code. Raise the bar. Share knowledge. Uplift people. Follow Abdirahman for more on software engineering. #softwareengineering #learning #codereviews

765

88 comentarios

Here's how I approach unit testing my code. I've seen many projects fail because of poor testing practices. The codebase grows, changes become risky, and developers lose confidence in their deployments. This is especially true for Clean Architecture projects, because testability is one of the main drivers. Testing ensures our use cases work correctly - as defined by our requirements. My unit testing approach: - NSubstitute to mock dependencies - Test all the happy paths - Test all the failure paths - Verify exception handling Unit testing can help you confirm your logic is correct. I wrote a step-by-step explanation of the testing approach I use. Learn more: https://lnkd.in/eFHiTJ2B But unit testing isn't enough. You also need integration tests. Unit tests + integration tests = Max confidence --- Sign up for the .NET Weekly with 72K+ other engineers, and get a free Clean Architecture template: https://lnkd.in/e756tX44

394

27 comentarios

🔑 𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗦𝗢𝗟𝗜𝗗 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝗶𝗻 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗗𝗲𝘀𝗶𝗴𝗻 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

418

31 comentarios

𝗧𝗵𝗶𝘀 𝗮𝘀𝘆𝗻𝗰 𝗰𝗼𝗱𝗲 𝗶𝘀 𝗰𝗼𝘀𝘁𝗶𝗻𝗴 𝘆𝗼𝘂 𝘁𝗵𝗼𝘂𝘀𝗮𝗻𝗱𝘀 Async/await has been in .NET for over a decade, yet production systems still suffer from the same three mistakes that destroy performance and inflate cloud costs. These patterns appear innocent. Code reviews approve them. They pass all tests. But under load, they become system killers. The symptoms are always the same: → Thread pool starvation with low CPU usage → Random deadlocks in production → Response times growing exponentially with load → Cloud costs mysteriously tripling The most dangerous part? Standard monitoring often shows the system as "healthy" with 20% CPU usage. The problem isn't CPU - it's thread exhaustion. Each blocking call consumes a thread. With default thread pool settings, just 100 concurrent requests can bring an API to its knees. Async void swallows exceptions, causing silent failures that only surface during peak traffic. Unnecessary Task.Run calls double thread usage for zero benefit. These aren't edge cases. They're in most codebases right now, waiting for the next traffic spike. 𝗧𝗼𝗺𝗼𝗿𝗿𝗼𝘄: The fixes that enable 100x throughput improvements with the same infrastructure. 𝗛𝗮𝘃𝗲 𝘆𝗼𝘂 𝘀𝗲𝗲𝗻 𝘁𝗵𝗲𝘀𝗲 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀 𝗶𝗻 𝘆𝗼𝘂𝗿 𝗰𝗼𝗱𝗲𝗯𝗮𝘀𝗲? Did you noticed potential issue in mistake 2? #AsyncAwait #Dotnet #CSharp #PerformanceOptimization #SoftwareEngineering

401

69 comentarios

In 5 years, APIs won’t be the core software deliverable For decades, we shipped functionality, wrapped in endpoints. That era’s ending. As agentic architectures mature, the dev’s job changes: - You won’t build APIs. - You’ll assign tasks to agents. You don’t expose endpoints anymore. You expose outcomes. This breaks everything we spent years mastering: - REST patterns. GraphQL schemas. SDK wrappers. - All optimized for humans who needed to know how things worked But agents don’t care how. They just need the goal. Code isn’t going anywhere. But the interface moves up. From logic to intent. From endpoints to tasks. From API design to outcome design. It’s uncomfortable. But the teams who embrace this shift? They’ll define the next era of software, before everyone else catches up.

142

120 comentarios

3 top tips for Junior Software Developers: 1. Never let a mentor touch your keyboard: If you can't find something or don't know what to search for, have them guide you, not do it for you. Embrace the struggle. 2. Present solutions, not just problems: As a junior engineer there will be a lot you don't know, can't do or haven't experienced. Communicate how you think you might be able to overcome them, or what you might need to help solve it. Go beyond 'I don't know'. 3. Get involved with other areas of the business: One way to really stand out is to have domain knowledge deeper than code. Ask to spend a week answering calls with Customer Service, take a day to learn how Marketing does outreach, and walk through your Client archetype with the Sales team. I bitterly miss the feeling of unending learning and wonder that comes with being a Junior Software Engineer.

60

4 comentarios

🚀 Tired of waiting 15+ minutes for your Spring Boot tests to complete? Your slow test suite isn't just an inconvenience - it's killing your team's productivity and creating a culture where developers skip running tests locally. The hidden culprit? Misused Spring TestContext caching. In my latest article, I showcase how the Spring Test Profiler can help you: ⏲️ Identify which tests force expensive context recreations 📝 Get specific recommendations to maximize context reuse ⏱️ Achieve 50-80% faster test execution times 🧪 Transform test optimization from guesswork into data-driven decisions Real results: One project went from 18+ minutes to just 4 minutes (77% improvement) by optimizing context caching. The best part? It's completely open-source and works with Spring Boot 3.x + Java 17+. Fast tests enable fast development. Don't let slow tests be the bottleneck in your delivery pipeline. 📖 Read the full guide 👇🏻 https://lnkd.in/d-9NqCMu

48

AI is making code reviews faster (and better). Here’s how: Without AI, by the time a PR is reviewed, the engineer has often moved on. Context is cold. Iteration is slow. That's why CodeRabbit provided not just code reviews in pull requests, but in the IDE. They've just taken that a step further by releasing a CLI purpose-built for code reviews in the terminal. This shifts reviews to another place closer to where code is written (and generated). Here’s what it unlocks: • Catch issues before they spread ↳ Review diffs locally and flag bugs, logic gaps, and “AI slop” before a commit or PR. • Increased Automation ↳ It’s the first CLI that can hand off review context to your AI coding agent for automated fixes, when you choose. • Works with all CLI coding agents ↳ Seamless integration with Claud Code, Cursor CLI, Gemini, Codex, etc. • Stay in flow ↳ Code, review, commit, without leaving your terminal. Remember, the more eyes reviewing, the better. The earlier those reviews occur, the better. Best part? Code reviews in the CLI are free (rate limits apply). Try the new CLI here: https://lnkd.in/gXpqQsUM Thanks to CodeRabbit for building a great tool and partnering on this post. 💬 Are you using AI in your code reviews? ↓

621

44 comentarios

I often talk to #CTOs, and a common topic is #technicaldebt. They say it slows down everything, makes development risky, and developers are not happy. In the same talk, the word "#refactoring" comes up. Developers want a big refactoring to fix the code. Business wants more features. This always creates a conflict. But this is a false dilemma. The problem is that many people misunderstand what refactoring is. They think it's a huge project, where you rewrite code for weeks to make it clean. But if you read the book "Refactoring", this is not the definition. Real refactoring is making small, continuous changes to improve the code design without changing what the code does. If it takes weeks, it is not refactoring. It is a rewrite. The correct way is constant refactoring. When you work on a feature, you see something to improve? Refactor it. When you finish a feature, you see a way to make the design cleaner? Refactor it. This is the key: Constant refactoring keeps code clean and flexible. It prevents the need for a big, painful rewrite. My advice for #CTOs: * Push your developers to refactor all the time. It is part of the job, not a special project. * Protect your team from business pressure to ship low-quality code. Good quality now means more speed later. #TechnicalDebt #Refactoring #SoftwareDevelopment #CTO #Agile #CleanCode #EngineeringLeadership

57

13 comentarios

Most engineers get stumped by high-level design in system design interviews. Often, they aren't even sure where to begin. Luckily, we've put together a tried and tested framework for easily building up to a working application. 1) Identify "what the system should do" 🔶 These are also known as the functional requirements 🔶 E.g. The users can make posts, like posts, follow other users etc 💡Think about what features you would want the system to have 2) Identify "how the system should behave" under specific constraints 🔶 What are the latency requirements? 🔶 How do we ensure our servers don't crash with an increasing number of users? 🔶 How do we ensure the system is always available when it's expected to be available? 🔶 How do we ensure fault tolerance to prevent data loss? 🔶 What are the trade-offs? Why should we choose one technique over the other? 3) Start addressing functional requirements in the most basic way possible 🔶 Map the data flow for each requirement with some services. E.g. When the client makes a post, they interact with a "Tweet Service" and that gets stored in a "Tweet DB" ❌ Do not add any complicated parts - this way the interviewer can correct you early on if you've made a mistake. 4) Think about how you can use your knowledge of the core system design components when addressing the functional requirements 🔶 If we have multiple services, it probably makes sense to use an API Gateway. Think of it, you wouldn't want to expose the services directly to clients. Instead, you want controlled access. 5) Once you have a feasible "what" down, address the non-functional requirements ❌ Biggest mistake candidates make here is to not tie the recommendations back to the original non-functional requirements they identified. Think about: 🔶 How you would choose between vertical scaling and horizontal scaling, and why? In our case, we can deploy more instances of the same service so we can handle requests in parallel. 🔶 Hmm... but how would you decide traffic is distributed evenly across all instances? Maybe we should consider a load balancer. 🔶 For latency, would the system benefit from caching? Is it necessary? 🔶 Think about edge cases when it comes to preventing data loss - would it make sense to have a buffer? 🔶 How do we safeguard against a database going down? A distributed database is designed to replicate and store data across multiple nodes in a cluster. High-level design should take 15-20 minutes, which is the bulk of the interview. This is then followed by a deep dive session, which lasts another 10-15 minutes. We will be covering how to ace your deep dive session in the upcoming posts. Stay tuned! --- Put this framework into practice today -> https://lnkd.in/ecQeq-s6

104

6 comentarios

𝘞𝘩𝘺 𝘠𝘖𝘜𝘙 Automation 𝘧𝘳𝘢𝘮𝘦𝘸𝘰𝘳𝘬 𝘸𝘪����𝘭 𝘍𝘈𝘐𝘓 𝘪𝘯 6 𝘮𝘰𝘯𝘵𝘩𝘴 (𝘢𝘯𝘥 𝘩𝘰𝘸 𝘵𝘰 𝘧𝘪𝘹 𝘪𝘵) I just audited a $50M company's automation framework. Result? 73% of their tests were failing randomly. Their CTO asked me one question: "How did we go from 10 passing tests to complete chaos?" The Brutal Truth: 85% of Selenium Projects Die the Same Death Month 1: "Our automation is amazing!" Month 6: "Why does everything break when we deploy?" Here's what kills every framework (and the fix): 1️⃣ The "Everything in One Folder" Disaster ❌ Death pattern: UI, API, utils all mixed together ✅ Fix: Dedicated packages → UI, API, POJO, services separated Reality check: Good teams onboard new devs in 2 hours, not 2 weeks. 2️⃣ The "Hardcoded Hell" Problem ❌ Death pattern: URLs, data, timeouts scattered everywhere ✅ Fix: Environment property files + externalized test data Game changer: Switch DEV→QA→PROD with one command. 3️⃣ The "No POJO = No Scale" Trap ❌ Death pattern: Raw JSON strings, manual API payloads ✅ Fix: Request/Response POJOs + schema validation Impact: API tests become 10x more maintainable. 4️⃣ The "Debug Nightmare" Issue ❌ Death pattern: "Test failed" with zero context ✅ Fix: Extent Reports + screenshots + API logs Truth: Debug time drops from 2 hours → 5 minutes The Framework That Actually Scales I've built a production-ready structure that includes: 🏗️ Proper separation of UI/API/POJO layers 🔧 External configurations for all environments 📊 Rich reporting with screenshots & metrics 🚀 CI/CD ready with Docker & Jenkins support 🎯 BDD structure that business teams understand The Bottom Line: Stop building "quick automation scripts." Start building software systems that scale. Your framework should work at test #10 AND test #1000. Want the complete folder structure? 👇 Comment "𝑭𝑹𝑨𝑴𝑬𝑾𝑶𝑹𝑲" and I'll send it to your inbox! Found this helpful? Share with someone struggling with flaky tests! 🚀 -x-x- Full Stack QA & Automation Framework Course with Clearing SDET Coding Rounds: https://lnkd.in/g7tn6Uif #japneetsachdeva

157

10 comentarios

→ The Untold Truth Behind Microservices Tech Stacks What if I told you building microservices is less about code and more about orchestration? The magic happens in how every piece fits together - from development to deployment - and it’s what decides your success. → Pre-production Flow: Where Ideas Take Shape • Developers craft APIs first - using OpenAPI or Postman - to set clear contracts. • Microservices and frontends are built with trusted frameworks like Java, Node.js, React. • Rigorous testing with Jenkins and JUnit ensures stability before moving forward. • Containerize with Docker, then deploy using Kubernetes for streamlined scaling. → Production Flow: The Invisible Web • Traffic is expertly routed via load balancers (NGINX) and CDNs (Cloudflare). • API Gateway manages requests - often Spring Boot paired with Netflix Eureka. • Behind the curtain, databases, caches (Redis), search engines (Elasticsearch), and message brokers (Kafka) work in concert. • All components are continuously monitored with Postman and Kubernetes, ensuring reliability. → Unified Tooling: The Secret Sauce for Scalability • Combining containerization, CI/CD pipelines, observability tools, and modular design makes fast deployment possible. • Each microservice runs independently, yet harmonizes perfectly with others. • This orchestration prevents single points of failure and supports growth. Microservices aren’t just code - they are a living ecosystem designed for resilience and agility. follow Sandeep Bonagiri for more insights

241

14 comentarios