Norbert Sienkiewicz

Supercede programmers at Lambda Days conference in Kraków, Poland 🇵🇱 I thought I would win the most-appropriate-tshirt contest, but I think Luke has the edge on that one. I gave a quick lightning talk on primitive obsession in persistent types. Long story short: you should be using `checkMMap` liberally in Yesod forms, and your persistent types shouldn’t contain a load of primitives. Otherwise those primitive values float through your system and there are many more places for things to go wrong. #haskell #functionalprogramming

35

I'll be talking about building future-proof React applications on the 30th of May in Bucharest. Everyone needs to have a set of principles they follow so they don't have to think about every problem from scratch. I'll tell you how I've been building React applications for the last 8 years. What works. What doesn't. What to focus on to make sure you don't have to rewrite your application every year. Because programming is about solving problems. But engineering is about maintaining those solutions over time.

100

3 komentarze

Developer Experience is still a problem! I listened to this podcast https://lnkd.in/eZPvJnGE on how LastPass tries to make local experience much easier in the area of microservices. They went from the usual suspect of Docker compose but it requires you to build Docker images before being able to run things. Then they went to local kubernetes but it adds another layer and it doesn't help with the extra Docker build step. They decided to use nix which is Docker without Docker, universal package manager. This is something I looked at when working on codefly agents. One goal of codefly is to provide great Developer Experience, a developer starts any service, it will run any dependent services, do all the networking, and even provide hot-reloading for languages that don't have it (golang for example). I found nix to be too complicated so I am relying on Docker and spent quite some time getting that right: you really don't want to start/stop containers all the time and it's actually not that trivial to start and stop processes inside a Docker container. But the pain is worth it: - dependency is minimal, Docker is OK, nix is another story - performance hit is minimal since we try very hard to keep the containers around And agent can also use local stack if available. The philosophy of codefly is that your code needs some "co-pilot" for everything from setup, package maintenance, to networking, Docker build, kubernetes manifests. We do all the annoying stuff so you can just focus on writing code, writing tests that can depend on your full stack without any change of code, or mocking -- just that is a game changer and that's it. We take care of all the painful stuff so you can do the fun stuff!

1

Choosing the right tools and packages can make a big difference in your projects. Here are some of my favorites that I use regularly: 1. ramda 2. generic-pool 3. nestjs 4. kafkajs 5. mongoose 6. luxon 7. opossum 8. jest 9. playwright 10. ajv 11. cdktf 12. commander 13. ulidx 14. ioredis What about you? What are some of your go-to tools and packages that you simply can't do without? #nodejs #softwareengineering

7

10 Essential Skills for the Modern C++ Developer 1. Embrace the Modern C++ Standards 2. Become a Template Wizard 3. Memory Management: Think Smart, Not Hard 4. Concurrency is King 5. Build Systems: More than Just Makefiles 6. Test, Test, and Test Again 7. Debug Like a Detective 8. Performance is Everything 9. Secure Coding: Because Vulnerabilities Are Not an Option 10. Stay Current with the Ecosystem Want to stay ahead in the C++ world? Check out the full article link in the first comment. #CPlusPlus #SoftwareDevelopment #Programming #TechSkills #ContinuousLearning What's your favorite modern C++ feature? Share in the comments below!

2

1 komentarz

Episode 430 - How Short String Optimizations Work https://lnkd.in/ga5AkNvJ

72

Choose refactoring over rewriting, unless you are well prepared for these: ==== 1. Everything takes longer and costs more We chronically underestimate the effort required to reimplement existing functionality in a new architecture. Even with the best-laid plans, unforeseen complications inevitably arise. Changing requirements, unexpected dependencies, and scope creep can stretch initial timelines by months or even years. Meanwhile, the opportunity cost is immense as new feature development grinds to a halt, leaving the business unable to respond to market needs. Data migration poses a particularly thorny challenge that's easy to brush over during initial planning. Rearchitecting datastores and schemas requires carefully mapping and migrating every data element while maintaining compatibility between old and new systems. Comprehensive migration testing is a project unto itself. Budget overruns are all but guaranteed as these "minor details" end up consuming major engineering resources. 2. Subtle knowledge gets lost in translation Mature software contains a wealth of wisdom in the form of edge cases, bug fixes, and subtle behaviors accumulated over years of real-world usage. While happy path functionality is usually well-understood, the long tail of nuanced behaviors is rarely documented in detail. When rewriting, it's almost inevitable that some of these subtleties will be missed - often not discovered until the new system is in production. Even with the most diligent QA, flipping the switch on a completely rebuilt system is always a nerve-wracking experience. Unexpected issues have a way of cropping up at the worst times, sending teams scrambling to fix showstopper bugs while stakeholders wonder why the new system seems worse than the old one. The fact is, it's nearly impossible to achieve true parity with a battle-tested codebase within any realistic rewrite timeframe. Some degree of regression is inevitable. 3. The human toll is high Rewrite projects are notoriously high-pressure environments. As timelines slip and stakeholder patience wears thin, teams often find themselves working unsustainable hours for months on end. Burnout and churn become endemic, further undermining velocity. Recruiting for long-running rewrites is challenging, so teams frequently end up understaffed. Those who remain must shoulder an ever-increasing workload with no end in sight. In any multi-quarter / year project, shifting company priorities pose a constant threat. What began as a strategic imperative can quickly become an expensive distraction in the eyes of new leadership. Funding gets cut, deliverables get descoped, and engineers grow demoralized as the vision they signed up for appears increasingly unattainable. Many grand rewrites end up abandoned partway through, having burned untold engineering effort for little gain. #softwareengineering #softwaredesign #techlead #softwarearchitecture

31

1 komentarz

Boost your productivity with IntelliJ IDEA! Watch Anton Arhipov's game-changing session filled with tips and tricks on refactorings, shortcuts, fast navigation and more. Explore the latest additions, including the AI assistant plugin. View talk @ https://lnkd.in/eqdFMxHX

24

The Big Release Roundup: IntelliJ IDEA, Quarkus, Hibernate, and much more! - JVM Weekly vol. 95 by Artur Skowronski via JVM Weekly (by vived.io) ([Global] autonomous oracle) URL: https://ift.tt/TOz3F0N There have been several releases, so today's edition will be dedicated solely to them. I still hope you'll be satisfied, as besides the standard projects, I managed to dig up some exciting ones. IntelliJ IDEA 2024.2 Let’s kick off our Release Radar with a bang, as the new version of IntelliJ IDEA has just been released. Thanks for reading JVM Weekly! Subscribe for free to receive new posts and support my work. IntelliJ IDEA 2024.2 brings some significant updates for JVM developers, especially those working with Spring, beyond the usual generic functionalities. To start, support for Spring Data JPA has been significantly enhanced. Now, you can run Spring Data JPA methods directly in the IDE, making it easier to test and customize repositories without leaving your coding sanctuary, which JetBrains certainly aims to make the IDE. Additionally, managing cron expressions has become much simpler—let’s face it, cron expressions are "silent but deadly" sources of production errors. The cron syntax has never been the most intuitive one. IntelliJ IDEA 2024.2 now offers inline descriptions and autocomplete with ready-made examples when configuring Spring, Quarkus, or Micronaut scheduling services. Moreover, if you’re debugging @Scheduled methods in Spring, you can now run them in debug sessions. No more manually tweaking schedules and waiting to see if everything triggers correctly. We also have another crossover episode. The IntelliJ HTTP client now operates based on GraalJS. Thanks to this move, the latest JavaScript standards are fully supported, and startup times are significantly faster. So if anyone ever asks what Truffle is used for, it turns out you might be using it every day. But that’s not all. In IntelliJ IDEA 2024.2, Kotlin developers will find a new, improved K2 mode, designed to increase stability and prepare for future Kotlin language features. To clarify the terminology a bit—unlike the Kotlin K2 compiler, which is for compiling code specifically for Kotlin 2.0 or later, K2 mode in IntelliJ IDEA is about making day-to-day coding smoother and faster. It leverages the advanced capabilities of the K2 compiler to enhance code analysis, offering more reliable and faster code highlighting, autocomplete, and other key IDE features, without affecting the actual code compilation. However, note that some third-party plugins might not yet be compatible with K2 mode due to recent changes in the Kotlin plugin API. Scala developers will also benefit from many improvements in this release. IntelliJ IDEA 2024.2 enhances support for Scala 3, improving handling of the "fewer brackets" syntax, export clauses, and extension methods. Additionally, the performance of compiler-based error highlighting has been improved, and Scala compiler d...

1

Have you ever wondered how you can testdrive your aggregates and use cases based on what you discovered in the EventStorming session? Join our next techexcellence.io session!

17

Continuing my journey of rewriting an old web application using AdonisJS, today I talk about database migrations and how Lucid ORM can help us track database changes. #database #migrations #adonisjs #lucidorm https://lnkd.in/ehcriygW

3

🚨 4:23 AM: The Battle with Gradle 🚨 Yes, it’s 4:23 AM, and I’m still here, battling through a stubborn "Gradle Error" that decided to crash my app build. Hours of effort—updating plugins, tweaking gradle-wrapper.properties—and finally, the app is back on track. Coding isn’t just about knowing how to fix things; it’s about persistence, patience, and understanding why issues happen. Tonight (or should I say this morning), I pushed through, learned a ton, and emerged a little stronger as a developer. Sometimes the late nights pay off in lessons learned. Here’s to the grind and the growth that comes with it. #code

43

3 komentarze

Did you know you can easily and automatically get all your repositories aligned on the latest version of Gradle?🐘 In this video, we'll show you how to update the version of Gradle used in an existing Gradle wrapper, commit the results, as well as create pull requests.💡

8

https://lnkd.in/dZ8_fyHA Back in 2020, while working at ozon.ru (Russian version of Amazon), I noticed a recurring pattern in our services for rendering SERP pages: spawning goroutines to send gRPC requests to multiple services, waiting for their completion, processing errors, and implementing fallbacks when necessary. I created a simple, lightweight library with an API similar to errgroup, but with different semantics. That's how syncgroup was born. :) Now, I’ve finally structured it according to Open Source standards and am excited to share it with the world!

6

😯 Very few developers know that in DDD! 𝐓𝐰𝐨 𝐒𝐜𝐡𝐨𝐨𝐥𝐬 𝐨𝐟 𝐓𝐡𝐨𝐮𝐠𝐡𝐭 𝐨𝐧 𝐀𝐠𝐠𝐫𝐞𝐠𝐚𝐭𝐞 𝐑𝐨𝐨𝐭𝐬 𝐢𝐧 𝐃𝐨𝐦𝐚𝐢𝐧-𝐃𝐫𝐢𝐯𝐞𝐧 𝐃𝐞𝐬𝐢𝐠𝐧 (𝐃𝐃𝐃) In the world of DDD, there’s an intriguing discussion about how we perceive Aggregate Roots (AR). I’ve been reflecting several years ago on this, and I wanted to share insights from two prominent schools of thought: 1. 🔥 Udi Dahan’s Perspective: • Contextual Aggregate Roots: According to Udi Dahan, an entity can serve as an Aggregate Root in one use case and not in another—even within the same bounded context. This means the exact same class might act differently depending on the scenario. • Non-Structural Property: He argues that being an Aggregate Root is not a structural property of the system. Instead, it’s determined by the specific needs of EACH use case. • Avoid Rigid Annotations: Annotating a class permanently as an AggregateRoot might limit flexibility. Since an entity’s role can change, rigid annotations could hinder the model’s adaptability. Udi Dahan introduced this idea to the community around 2009 with his article « Don’t create Aggregate Roots » (google for it), and it has significantly influenced how some practitioners handle immediate consistency and model complex domains. 2. 💦 Vaughn Vernon and Eric Evans’s Perspective: • Fixed Aggregate Roots: In contrast, Vaughn Vernon and Eric Evans advocate that an Aggregate Root is a structural property of the domain. An entity designated as an AR remains so across all use cases within the bounded context. • Consistent Boundaries: This approach emphasizes clear and consistent aggregate boundaries, which can simplify understanding and enforcing invariants. • Structural Annotations: Using annotations like AggregateRoot aligns with this perspective, as it reflects the entity’s consistent role in the domain model. This school of thought focuses on stability and predictability within the domain model, which can be advantageous for maintaining invariants and ensuring clarity. Why I Favor Udi Dahan’s Vision 🔥: I’ve leaned towards Udi Dahan’s approach for a few reasons: • Flexibility in Modeling: It allows for more adaptable models that can cater to varying business processes and transactional requirements. • Simplified Consistency Handling: Immediate consistency across related entities becomes more manageable without complex coordination between fixed aggregates. ****That point is so GREAT! 🔥 I can assert**** • Optimized Performance: By adjusting aggregate boundaries per use case, we can optimize further for performance and scalability, loading only what’s strictly necessary. If you have any question, feel free to ask me. #ddd #aggregate #aggregateroots #schools #tips

47

15 komentarzy

Today I'm closing the book on Rust 🦀 📕 Context: After 10+ years professionally programming in Java, C, C++, Python, JS and Go I decided to give Rust a try. I started and worked for 4 months on a webservice project using Rust, Actix and SeaORM. The Best: - The build tools hands down are the best part of it. Cargo is excellent and the compiler hints are incredibly smart. So much better than C++ The Good: - Build times are not as bad as I was led to believe. - Rust can be concise! - No garbage collector downtimes - Box and Optional really help you write better code (as long as you don't unwrap without checking). Things I did not like: - Error handling is too verbose when using `match` - Argument types can escalate quickly to the point where the argument type definition is longer than the function itself. - Macros are pretty complex/ intense to write. Also never managed to get VSCode to parse them without showing errors. All in all Rust felt more like an artisan tool where it takes much longer to do the work but the outcome is amazing. For now though I'd prefer sticking with power tools (Go).

232

43 komentarze