Borja Sanchidrián

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

If you’re a software engineer in your 20s, always remember that: The 10-minute Sev-1 fix will always look like brilliance, but that doesn’t mean the boring runbooks and failover drills were worthless; they are why your hands did not shake. The smooth launch will always get the applause, but that doesn’t mean two months of feature flags and canary rollouts were worthless; they turned risk into a switch. The elegant 20-line solution will always win code review, but that doesn’t mean your first brute-force plus tests were worthless; it mapped the problem so refactoring was obvious. The first-try design approval will always look like talent, but that doesn’t mean your ugly one-pager and early comments were worthless; they killed surprises when it was cheap. The 30% cost cut will always impress finance, but that doesn’t mean tagging resources and reading usage reports every Friday was worthless; the savings were hiding in that tedium. The zero-downtime migration will always feel like magic, but that doesn’t mean backfills, checksums, and a rollback plan were worthless; they made “magic” repeatable. The strong hire will always look lucky, but that doesn’t mean 40 structured interviews and a clear bar were worthless; they protected your culture. The junior shipping confidently will always look like their win, but that doesn’t mean pairing on their first bug and narrating your thinking was worthless; that is how you multiply yourself. Takeaway: it is easy to chase launches, titles, and shiny metrics. → After two decades, I can tell you the compounding sits in unsexy routines: small PRs, tests first, one RFC a quarter, p95 tracked weekly, logs read daily, a decision log, and one person unblocked every day. Consistency beats intensity. Do the quiet work, and the loud results will follow.

231

22 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

I’ve been thinking a lot about where multiplatform development is heading. With tools like Kotlin Multiplatform becoming truly practical, the expectation to share more logic across platforms is growing fast. Lately I started exploring Rust as a multiplatform option. Rust is usually aimed at C++ developers and systems programmers, but I keep coming back to this question: What if Rust were approachable for mobile developers too? One of the big reasons Rust interests me is its mix of performance and safety. You get native speed without garbage collection or ARC, strong guarantees around memory safety, and the ability to ship the same core module to iOS, Android, desktop, backend, or even WebAssembly without rewriting it per platform. That makes it another compelling option for shared business logic or core components across platforms. Some apps already use Rust as a strong core layer. I'm exploring to see how viable it is for mobile devs to try out, even if it's for a small module rather than replacing a full-blown business layer across multiple apps. I want to see how we can make it less intimidating and more accessible for everyday app developers. I’m exploring this and will share more as I go. If there is enough interest, I’ll go deeper. I'll share my findings on https://lnkd.in/emVy_hFv

96

15 comentarios

A common mistake I see: People treat message queues and streams as if they’re interchangeable. They’re not. Here’s the difference 👇 Message Queue (MQ) - Designed for delivery guarantees (at-least-once, exactly-once). - Great for sporadic workloads and asynchronous tasks. - Messages are consumed and removed. Once acknowledged, they’re gone. - Think: order processing, background jobs, retry logic. Stream - Designed for real-time, high-throughput, continuous data. - Data is append-only and replayable. - Multiple consumers can read the same stream independently. - Think: real-time analytics dashboards, fraud detection, monitoring pipelines. Why Streams fit Aaron’s case (real-time analytics for e-commerce): - Freshness matters → Streams process events as they arrive, with low latency. - Replayability matters → If a consumer goes down, it can re-read from the offset. - Scale matters → Streams partition data for massive parallel consumption. A message queue here would introduce unnecessary latency and discard historical events that analytics needs to stay accurate. Rule of thumb: - If you care about delivery → Message Queue. - If you care about freshness & scale → Stream. That’s why the right answer here is: Streams for real-time analytics.

963

68 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

𝗧𝗵𝗶𝘀 𝗮𝘀𝘆𝗻𝗰 𝗰𝗼𝗱𝗲 𝗶𝘀 𝗰𝗼𝘀𝘁𝗶𝗻𝗴 𝘆𝗼𝘂 𝘁𝗵𝗼𝘂𝘀𝗮𝗻𝗱𝘀 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

→ 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

Waiting half an hour for your tests to finish? That’s not feedback - that’s punishment 🧪 You might have been there: Every new integration test adds another minute to your overall build time. Twenty minutes turn to thirty. CI times explode. Developers stop writing integration tests and become unhappy. Flaky tests appear. Bugs slip through. Releases slow down. But what if you could slash that time, without deleting a single test? With Spring Test, that's possible. It's a hidden gem called Spring TestContext Context Caching 🏆 So, how do you know how many contexts are spinning up? More importantly, how do you figure out why they aren’t being reused? That’s why I built Spring Test Profiler ⏱️ Meet Spring Test Profiler - the free, open-source x-ray for your test suite. Integration is as simple as this three-step process: 1. Add the dependency (Maven/Gradle snippets appear on screen). 2. Run your tests. 3. Open the report at: target/spring-test-profiler/report.html. Within the report, you’ll see: • How many contexts started, and why. • Which tests are sharing configs versus starting their own. • Exact diffs: profiles, properties, or annotations blocking cache reuse. The overall goal is to help identify cache misses and align your tests to reuse contexts for faster feedback 🚤 Spring Test Profiler: Profile. Optimize. Deliver. Try it yourself: https://lnkd.in/djXVJiNE Below is a demo of a section in the report to analyze and compare two contexts 🆚

49

5 comentarios

2000: You debug code line by line, celebrate when your for loop finally works. 2010: You obsess over the perfect framework, Angular, React, or Vue? Deployments still mean SSH-ing into a server at midnight. 2015: You automate everything with CI/CD. You brag about your Docker skills and microservices architecture. 2020: You build products by wiring together APIs, Stripe for payments, Twilio for SMS, and Auth0 for login. 2024: You plug in pre-trained AI models for everything, text, speech, images, even code reviews. 2026: You swap prompts and tune LLMs instead of writing new features from scratch. 2028: We might see more changes in the dev. environment, but one thing is clear to me: No matter how much the tools change, two things will stay timeless. → The habit of clear thinking → And the drive to solve real problems, not just automate for automation’s sake. Because technology will always evolve. But engineering judgment? That’s what separates builders from button-pushers.

983

37 comentarios

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

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

From Developer to CEO Part 03: 5 to 10 years of experience Congratulations, you’re now a senior developer. But you’re not a senior just because you’ve reached 5 years of experience. You’re a senior because you’ve seen more problems— and you know how to prevent them. At this stage, you should be able to build software from A to Z. But your main focus must now shift to business impact. Not just how to code, but how to solve real business problems. Code shouldn’t be your challenge. Code should be your tool—to deliver value. For that, start asking the right questions: • What’s the real problem the customer is trying to solve? • Why does the client need this feature? • What’s the expected benefit for their business? • Is there a better solution? You’re not just a developer anymore. You should become a technical partner to your clients, not just someone who takes orders. Your new mindset: 👉 How can I maximize my customer’s success? If you follow these tips, you’ll level up faster. ⸻ After 20+ years in web development, I’m sharing what I wish I had known when I was younger. This post is a follow-up to Julien Rajerison’s post. Tomorrow, we’ll talk about developers with 10+ years of experience. ⸻ You’ve got this. I’m Toky RABESON. I’m a seasoned web developer.

94

4 comentarios

At the last weeks, I have been working in a microservices ecosystem combining C++ backend with TypeScript orchestration. I had this idea after some months working with AWS lambdas and thinking about on how to implement a toy project to learn and practice. Architecture Highlights: - Service Mesh: Independent C++ microservices with RESTful APIs - API Gateway: TypeScript-based routing and load balancing with auto-routing to C++ services - PM2 Process Management for production-grade service orchestration - Database Layer: PostgreSQL with connection pooling and migrations - Configuration Management: Multi-tier config with environment isolation DevOps Engineering: - CI/CD Pipeline: Automated build, test, and deployment - Infrastructure as Code: Self-hosted GitHub Actions runners - Security: Secrets management with environment-specific configs - Monitoring: Health checks and performance baselines Development Experience: - IDE Integration: VS Code with IntelliSense and test discovery - Dependency Management: Git submodules for third-party libraries - Testing Strategy: Unit tests, integration tests, and lab environment - Documentation: Comprehensive setup and deployment guides Performance Benefits: - Native C++ execution for compute-intensive operations - TypeScript flexibility for business logic and routing - PostgreSQL optimization for data consistency and performance Production Features: - PM2 Orchestration: Auto-restart, load balancing, and process monitoring - Hybrid Architecture: C++ for compute-intensive tasks, TypeScript for HTTP handling - Smart Configuration: Multi-tier config system (JSON → .env → env vars) - Git Submodules: Clean third-party dependency management - Health Checks: Automated service health monitoring and alerting - Zero-downtime deploys: PM2 graceful restarts with health validation Technical Roadmap: - Phase 1: Structured logging system with centralized aggregation and PM2 aggregation - Phase 2: Automated semantic versioning with GitHub Actions integration - Phase 3: Development framework and scaffolding tools for rapid microservice creation - Phase 4: Complete observability stack (metrics, tracing, alerting) Engineering Principles: - Performance-first: C++ where speed matters, TypeScript where flexibility wins - Developer Experience: Tooling that accelerates development without sacrificing quality - Production-ready: Security, monitoring, and deployment automation from day one - Scalable Architecture: Each component can evolve and scale independently This project showcases the evolution from traditional web stacks to hybrid architectures that leverage the best of both worlds: C++ performance with modern web development practices. Follow the link to github: https://lnkd.in/d3CXhngV #systemsarchitecture #cpp #microservices #performanceengineering #devops #postgresql #typescript #softwarearchitecture #backend #cloudnative #AWS

36

11 comentarios

MediatR is powerful. But here's the truth: 👉 Using it for a simple project is like using a chainsaw to slice bread. Technically possible, but massively overkill. If your team and your app are small, chances are you don't need pipelines, handlers, and all the extra complexity. Stick to direct calls, filters, and middlewares — you'll ship faster with less cognitive load. 💡 The real flex? Choosing the simplest architecture that solves the actual problem.

35

3 comentarios

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

Most engineers obsess over the code. I care more about the database. Here’s why: You can refactor code in hours. But fixing a bad database design in production can take months. Every schema shortcut or sloppy query gets multiplied across dozens of places. Code quality matters. But database design is where most long-term software pain comes from. If you want scalable, maintainable systems: Stop sweating every line of code. Start sweating the database architecture.

1397

135 comentarios