Artur Arêde

What if you could triage issues, fetch context, and review pull requests—managing your entire development workflow—without ever leaving your IDE? Watch how combining GitHub Copilot with the MCP Server brings GitHub context and capabilities right into your editor. 🤖⚙️

1.144

29 Kommentare

What are the Domain Objects in React/Nextjs? It's an abstraction that we need. In a nutshell, these are objects that represent our business. They come from your database/API. Examples: Key domain objects in banking: (things my team deals with at Erste Digital) ↳ BankAccount, Payment, Transaction, Credit Card, Customer. In media streaming (e.g., Netflix): ↳ Movie, Series, Episode, Subscription, Consumer. In hospitality: ↳ Booking, Hotel, Room, KeyCard, Guest. It's a good idea to always have Domain objects and operations on them abstracted away from the rest of the code. Because these will be highly reusable: (across the React/Nextjs codebase) - Hotels are within the accommodation search feature - But a single hotel is also in the guest trips feature - And in the guest reminder/notifications feature Here's what such a Service has: ✓ It contains the shape of the Domain object ✓ Provides operations on the Domain object ✓ Resolves Domain object business logic ✓ Fosters reuse across the codebase ✓ 100% covered using unit tests ✓ Retains high cohesion Business requirements change. React components change. Styling changes. Your Domain stays the same. Have it separated. // TODO: Repost to your network ♻️ P.S. What are the key domain objects in your project/business at work?⁣ ⁣

382

46 Kommentare

Are microservices dead? Microservices were once seen as the silver bullet for scalability. Engineers embraced them. Startups copied big tech in the hope of faster development. Then the bill arrived. Network hops. Distributed caching. DevOps fatigue. The architecture scaled the system, but it also multiplied the complexity. Today, most startups begin with a monolith and only move to microservices when forced to. And big tech companies have quietly obscured the complexity behind powerful developer platforms. The lesson is: Trends rise, stabilise, eventually fade away. The next decade belongs to engineers who understand the principles behind system design, not those who follow architecture hype. Cheers.

1.742

78 Kommentare

Book platform Hardcover has successfully migrated from Next.js back to Ruby on Rails using Inertia.js, resulting in dramatic performance improvements and reduced hosting costs after three years of Next.js development challenges. The migration addressed critical issues, including unclear caching behaviour, unpredictable serverless costs that grew from £30 to over £500 monthly, and slow development speeds where single-page loads took up to a minute locally. Why Rails + Inertia.js Won Over Next.js: 🔹 Server-side rendering maintained for SEO requirements whilst using React components 🔹 Direct database connections through ActiveRecord eliminated GraphQL API overhead 🔹 Familiar Rails caching with Rails.cache.fetch, providing predictable performance 🔹 Vite integration offering fast development with hot module reloading 🔹 Reduced complexity by leveraging existing Rails backend infrastructure The technical architecture combines Rails controllers rendering Inertia.js components with props, whilst Vite handles the React frontend compilation. Server-side rendering runs through a separate Vite SSR process deployed alongside Rails using Kamal. Performance improvements were immediate: Google PageSpeed scores increased significantly, Total Blocking Time dropped from over one second to much faster loads, and visit duration increased from 3 to nearly 6 minutes. Hardcover's experience demonstrates that Rails remains a compelling choice for applications requiring both modern frontend experiences and robust server-side rendering, particularly when teams already possess Rails expertise. What factors would influence your decision between modern JavaScript frameworks and Rails for new projects? We're connecting with developers experienced in both Rails and React ecosystem integration. #RubyOnRails #InertiaJS #NextJS #WebPerformance #TechRecruitment

16

1 Kommentar

I’ve interviewed several senior #Java candidates over the years. One thing I’ve never asked in those interviews is: “What’s the difference between a synchronized method and a synchronized block?” For senior roles, what matters far more is how candidates approach real-world scenarios, problem-solving, design decisions and trade-offs, not just recalling. theoretical differences. Interviews should reflect the challenges we actually face in building reliable and scalable systems. Here’s what I actually ask: Scenario Questions 1. “You inherit a legacy Spring Boot service. It’s running fine, but takes 20s to respond under load. How do you approach performance tuning?” → Looking for: Profiling-first mindset, understanding of thread pools, database bottlenecks, GC tuning 2. “Users report intermittent 500 errors in production, but logs look clean. How do you debug this?” → Looking for: Understanding of logging levels, tracing (e.g., Zipkin, OpenTelemetry), exception handling, concurrent request handling 3. “You’re asked to design a backend service for handling 10M+ user requests per day. You have limited infra budget. What’s your plan?” → Looking for: Scalability thinking, caching strategies, async processing, build vs buy decisions 4. “Your CI/CD pipeline suddenly slows down from 5 mins to 40 mins. How do you debug?” → Looking for: Ability to identify bottlenecks (dependency downloads, tests, container builds), caching strategies, parallelization and even use of AI tools like Copilot for YAML/shell optimization. 5. “Your microservice consumes messages from Kafka. Suddenly, consumer lag keeps increasing. What steps do you take?” → Looking for: Knowledge of consumer group rebalancing, partition assignment, backpressure handling, monitoring with Prometheus/Grafana, scaling strategies. 6. “A payment API you integrate with has a 2% failure rate under peak traffic. How do you ensure reliable customer experience?” → Looking for: Retry with exponential backoff, circuit breakers, idempotency handling, fallback strategies, SLAs with third parties. Interviews that go beyond surface-level questions uncover real engineering judgment. That’s how we identify professionals who can think critically, solve problems and build systems that last.. 🚀

1.318

32 Kommentare

Hey Java! Let's talk today about #42 Interfaces, how to declare, how interfaces can extends interfaces, the implicit modifiers of methods and variables, and all the interfaces methods - default, static, private and private static. A lot to see!

40

Java is brutally simple under the hood. Builds and runs even without any additional tool. We usually make things too complex. Then we hire more tools to manage the complexity we created. ``` javac berlin/yuna/deploy/HttpAgent.java native-image -H:Name=http-agent berlin.yuna.deploy.HttpAgent ``` Result: a single, executable. Fast startup. Predictable memory. No runtime surprises. You have no GraalVM? Still boringly simple - but better to hide the parameter wall in a POSIX script: ``` javac -d out berlin/yuna/deploy/HttpAgent.java jar --create --file http-agent.jar --main-class berlin.yuna.deploy.HttpAgent -C out . jlink --add-modules "$(jdeps --print-module-deps http-agent.jar)" --strip-debug --no-man-pages --no-header-files --output runtime jpackage --type app-image --name http-agent --input . --main-jar http-agent.jar --runtime-image runtime ``` * javac compiles your code * jar creates a runnable artifact * jdeps auto-detects required JDK modules * jlink builds a minimal JVM with only those modules * jpackage ships a self-contained executable I use it often when my infrastructure is small like a Raspberry PI. Linux comes with everything I need. Starting my app as a `systemd` service means I get * automatic restarts * resource limits * structured logs via journalctl * sane lifecycle management Like Kubernetes for minimalists. All those above creates a minimum of maintenance. A generic Infrastructure around it will handle rate limits, https, ssl, DDoS protection and so on. Java is still powerful, but when an ecosystem keeps confusing abstraction with evolution, it becomes tempting to reach for a language that refuses to play that game. Starting a service on nowadays hardware should not take longer than few milliseconds. I will probably give Go another serious look next. What do you think? #Java #GraalVM #JLink #JPackage #Systemd #BareMetal #NoContainers #Simplicity #DeveloperExperience #SoftwareEngineering #Infrastructure #LessToolsMoreThinking

63

17 Kommentare

I can’t stress this enough: To become a Senior engineer you don’t need to complicate things. What you need is to focus your efforts on being pragmatic, business-oriented, and solution-oriented. I’ve seen too many talented mid-level devs shooting themselves in the foot by: 👉🏻Adding unnecessary abstraction layers “for future flexibility” 🤦‍♂️ 👉🏻Implementing design patterns that solve problems that don’t exist 👉🏻Building “elegant” solutions that take 3x longer to ship. Meanwhile, senior devs are out there asking the right questions: 👉🏻”Whats the simplest solution that works?” 👉🏻”What are we actually optimizing for?” 👉🏻”Will this help the business or just my ego?” Your promotion isn’t blocked by lack of complexity, actually it’s blocked by too much of it. Save your creative energy for problems that actually need complex solutions.

678

46 Kommentare

Do you know how often developers commit tokens and secret keys to public and private repositories? Even then, they think that if they remove them in the next commit, they will be gone forever. But they will continue to appear in git logs and will be totally reachable. Sometimes creating a lot of branches confuses people even more and they might believe that the exposed secret will be hidden deep within the repository. But believe me my friends there are automated bots digging through GitHub every second to exploit your mistakes. You can test this by creating a public repository and making a dummy commit on it and then checking the traffic tab on your repository. You will be surprised. In seconds you will see your repository has already been cloned. So any mistake = no turning back.

19

Hi! Long time no see! Today, I want to share a great tool for JVM language teachers. I personally use it for Kotlin, but it also works well for Java for example 👩‍🏫 One common challenge when teaching programming theory is switching between multiple screens. I usually have a presentation open in a browser with slides and images, plus an IDE for demonstrating examples. Additionally, students often struggle to run examples from the slides at home because complex examples require hidden contextual code I’ve found Kotlin Notebooks to be a great solution for this! If you’ve ever used Jupyter Notebooks for Python, you’ll understand the concept. This tool lets you combine everything in one place, images, theory, live examples, and the ability to add new examples on the fly. I’ve attached a small example showing how easily you can visualize each step of a sequence of calls when working with Kotlin collections. Plus, since it’s used within an IDE, it supports AI tools like error explanations and code generation with AI agents 🤔 I’ve used notebooks for traditional programming classes, but now I’m exploring ways to integrate AI-based tools into them to enhance my lectures and help students learn at home. For example, I could generate exercises within notebook cells to reinforce topics or help students identify and fix errors to improve code-reading skills You can read more about Kotlin Notebooks and my experience using them on the blog - https://lnkd.in/ddEHceph. If you’re interested in trying them out or have ideas for using AI tools in teaching, let’s chat! I’m always open to experimenting with new technologies and approaches to improve course design 🙌

54

1 Kommentar

Morning coding, personal project, 05.17 - 07.22. I am creating a CI/CD boilerplate for automatic code review with Zrb. While AI is everywhere, I believe there are still special places for a more traditional software craftsmanship. Here are some arguments: - AI is damn expensive. - AI is inaccurate. I mean, 80% accuracy is good, but can you actually afford that 20% failure? - Senior programmers already face many real-life challenges; those experiences build tacit knowledge that cannot be perfectly translated into texts. The correct approach is to combine both, AI's agility and people wisdom. Zrb is perfectly about that. It is about how we, humans, don't give up our dignity to machines. We take control, accountability, and responsibility. AI assists. The CI/CD code is perfectly written in Python with some parts written in English (that's the AI part).

23

1 Kommentar

What Firms Actually Mean by “Strong C++” in 2026 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗴𝗿𝗮𝗱𝗲 𝗖++  • Modern C++ (17/20+), RAII, ownership models  • Memory safety, cache locality, predictable allocation  • Writing systems that run 24/7 under load 𝗟𝗼𝘄-𝗹𝗮𝘁𝗲𝗻𝗰𝘆 𝗳𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀  • Lock-free / wait-free design where it matters  • CPU pinning, NUMA awareness, branch prediction  • Understanding when optimization helps and when it doesn’t 𝗗𝗲𝗯𝘂𝗴𝗴𝗮𝗯𝗹𝗲 𝘀𝗽𝗲𝗲𝗱  • Deterministic behavior  • Reproducible performance issues  • Instrumentation and profiling built in, not bolted on 𝗪𝗵𝗲𝗿𝗲 𝗖++ 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝘀 𝗔𝗿𝗲 𝗕𝗲𝗶𝗻𝗴 𝗗𝗲𝗽𝗹𝗼𝘆𝗲𝗱  • Market data & feed handlers  • Execution & order routing  • Strategy infrastructure  • Core trading platforms 𝗪𝗵𝗮𝘁’𝘀 𝗖𝗵𝗮𝗻𝗴𝗲𝗱 𝗦𝗶𝗻𝗰𝗲 𝟮𝟬𝟮𝟯–𝟮𝟬𝟮𝟰  • Fewer “rewrite everything” projects  • More precise optimization of critical paths  • Tighter coupling between C++ engineers, quants, and FPGA teams  • Higher expectations per hire, smaller teams Connect & Follow to get more market insights! 

14

Rust is the only ecosystem where I hear sentences like: “I removed 200 lines of code and now I trust it more.” In most places, less code means more risk. In Rust, less code usually means someone finally understood the problem. It’s a very specific kind of confidence. Also probably explains why Rust engineers sound calm and slightly smug at the same time.

77

53 Kommentare