Andrei Zhozhin

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

Gave a talk at work on "Dependencies" today, trying to externalise and make explicit some of the background awareness that shapes my everyday practice as a software developer. It takes time for this awareness to develop. I remember the first time someone talked to me about how Gradle uses a topological sort over a graph of dependencies to determine a build order for tasks, and what a revelation that was. I remember the first time I was shown how to get IntelliJ to scan a Java project for cyclic dependencies between packages, and coming to understand why one might want to avoid them and how to unpick them if they arose. Now DAGs (directed acyclic graphs) are a comfortable piece of my mental furniture, but I don't know that more junior developers are often directly introduced to them - they might come up as a data structure with associated algorithms in CS courses, but is it explained that they're fundamental to the way compilers and build tooling assemble working software from many related pieces? Many developers are aware at some level that transitive dependencies can balloon out into bloat (and an ever-expanding attack surface for vulnerabilities), but how many can articulate this clearly? A large part of my practice as a Principal Engineer is mentoring individuals and looking out for knowledge gaps in teams. It can be hard to recover a "beginner's mind" and remember what it was like not to know (or to be only vaguely aware of) something that became second nature to you over a decade ago, but it forces you to make your implicit knowledge explicit - which also gives you opportunities to reflect on it. Teaching is learning: you go back and retread old paths, and are confronted again with long-forgotten questions. Like everyone at the moment, I wonder what the impact of LLMs is going to be on the way developers acquire the background awareness and instincts that guide accomplished practitioners. Will they help to make implicit knowledge explicit, or will they paper over gaps in knowledge and obstruct the process of learning?

12

2 Comments

Awesome well well-detailed article about Transactional outbox pattern from Krzysztof Atłasik. 1. instead of directly making requests, we just save the message as a row to the new table. Doing an INSERT into the message outbox table is an operation that can be a part of a regular database transaction. If the transaction fails or is rolled back, no message will persist in the outbox. 2. create a background worker process that, in scheduled intervals, will be polling data from the outbox table. If the process finds a row containing an unsent message, it now needs to publish it and mark it as sent. If delivery fails for any reason, the worker can retry the delivery in the next round. https://lnkd.in/dJNJ-6aa

1

🚀 Code quality matters! Whether it's fixing bugs, optimizing performance, or aiming for perfection, ensuring high-quality code in mobile apps is crucial for delivering the best user experience. I loved this article from Stack Overflow about the challenges and strategies for pushing code quality in mobile development. A must-read for developers looking to refine their craft! Check it out here: https://lnkd.in/dNGeJ2EW What are your go-to strategies for maintaining top-notch code quality? I'd love to hear your thoughts! 💬 #Tech #TechRecruitment #ProfessionalDevelopment #CareerGrowth #CareerInsights #Networking

19

1 Comment

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

Thread behavior in the JVM. The #JVM does what it wants to do, so how can you predict the order of thread execution? #programminglanguages #itnews #jdk

2

Thread behavior in the JVM. The #JVM does what it wants to do, so how can you predict the order of thread execution? #programminglanguages #itnews

1

Interesting investigation of transaction cost of Pull Requests by Dragan Stepanović with Dave Farley Continuous Delivery Ltd Interesting with some data about: * 10 lines of code => 10 issues. * 500+ lines of code => LGTM :-D == Impact of Pull Requests on Work/Wait ratio == Wait time in processes, is the time it takes for work to wait at a station/gate before moving forward. A pull request is such a station. This wait time is what we want to reduce in Lean. And want to reduce in Agile methodology. This translates to ratio for time to make a change and create a pull request vs. wait time to get it approved and merged. As an example. If a change takes half an hour to make, but 2 hours to get approved, that is a ratio of 1/4. This means tasks are waiting by a factor of 4 to progress further. Or, viewed from a different angle, developers potentially getting a WIP factor of 4 to "keep busy". (Note that the best work/wait is ∞ or wait/work ratio is 0 which is more useful) The are many different goals and means that work counter to each other. A complex system of interdependent watt governors. To improve the work/wait ratio, require more frequent interruption of work/flow of team members. To lower the impact of the wait (and keep "producing") requires more WIP, which increases risk of and frequency of merge conflicts as well as inducing burn-out and decreasing quality of work. The bigger the Pull Requests are, the less valuable the review. The smaller the Pull Requests are, the worse the effect is on interruptions and on parallel WIP. The worse the Work/Wait ratio is - the slower the iteration speed and feedback cycles become. I.e. opportunity cost and impacts ability to deliver. Pull Requests should AT LEAST have net positive value of the expected benefits from reviews, quality increase, impact on burnout, opportunity cost, quality decrease, bugs, incidents, and Software delivery performance in general. I believe Pull Requests have a considerable net negative value, when all these aspects, unintended side effects and impact on work and people are taken into consideration. Which they should. To paraphrase Jon Arild Tørresdal: "If you and your team do not notice friction with Pull Requests, you are not moving fast enough" A way to reduce the negative impact of reviews is to strive for for a non-blocking review approach. This can be done by: * tool support (e.g. reviewing each commit individually on the reviewers own schedule - but without blocking the committer). * doing holistic review sessions of code walkthrough * doing pair programming when appropriate and meaningful. Here is a more in depth write up about removing blockers and friction: https://lnkd.in/dcBiZWdG And a bit more in depth tirade about pull requests: https://lnkd.in/d9bs77uK https://lnkd.in/dueY4Bkx

57

14 Comments

My LeadDev talk from the Berlin conference has just been published on YouTube: https://lnkd.in/eCtuf8_S I talk about two different approaches of managing software architecture that I've experienced (a more self-organized "guild" approach, and an "enabling team" as in Team Topologies), and some observations I've made. Let me know what you think in the comments. #softwarearchitecture #architecturemanagement #engineeringmanagement #flow #teamtopologies

37

3 Comments

Jez Humble test for whether you are practicing Continuous Integration or CI theater 1. Do developers commit to a shared mainline at least once a day? 2. Do the commits trigger automated build and test? 3. If the automated build and test are broken, are they repaired within ten minutes ? #continuousintegration https://lnkd.in/eS65jAWZ

3

If your teeth hurt, would you go to a psychiatrist? No? Then read further, because I AM ABOUT TO BLOW YOUR MIND!!! Proper role separation in software development teams yields a huge productivity and quality boost. Traditional separation of roles and concerns sorts developers in two main blocks: backend and frontend. Let me say plainly: this is just wrong. There are a lot more layers, and the cutting lines should be put elsewhere. The first layer is design+HTML/CSS. Professionals working in this layer create and implement the UX, both the Interaction Design and the Visual Design. The ideal situation is achieved when the designer is free to code for fastest iteration cycles. The second layer is the API layer. This spans across the frontend and backend systems. Implementing a feature at this layer requires processing data, exposing it (securely) via the API, and then consuming this data in the frontend with the right business logic. The extremely tightly coupled integration between the two requires fast iteration, and having a (sometimes bureaucratic) separation here is the worst efficiency killer. Developers here are software engineers experts in concurrency, high-frequency/low-latency processing, and security. The second layer is ridiculously complex and should be treated with respect. The third layer is the background processing layer. This is the layer that makes sure that data is synchronized between all the data sources such as external ERPs, product catalogues, CMSes, etc. as well as our own local data stores (hopefully a normalized good DB like Postgres and a document DB like Elastic). The processing here is asynchronous and in the background, so there is not a lot of pressure on high frequency/low latency even though of course incremental concurrent processing of large data syncs such as to and from an ERP must be done intelligently or you might end up with latencies of 24h (the 90's called and want their ridiculous delays back). Data people (architects/engineers/scientists) are the ideal professionals to work on this layer. Finally, DevOps. Whenever DevOps is done by a backend engineer who "likes DevOps", a DevOps fairy falls from the sky. DevOps is a specialization and should be done by experts, especially if using the mega overkill of Kubernetes: old school Linux SysAdmins are Kings and Queens here, they know how to turn a 200k a year Kubernetes into a faster, simpler, safer, 30k a year Docker cluster.

12

I wanted to share an interesting article I read yesterday and really recommend everyone in my network - CTOs, Heads of Engineering and Software Developers - to really understand the benefits of #Kotlin in server-side development if: 1. You haven't had a play around with the language before 2. Are considering modifying your existing tech stack and looking at more modern and performant options Compared to #Java, the Kotlin programming language developed fantastically by JetBrains removes a lot of the 'nitty gritty' work you would otherwise have to work through and requires WAAAAY fewer lines of code than doing the same work in Java! Not to mention, the incredible features around #NullSafety and #Coroutines. Have a read to understand more on the positives of using Kotlin in the JVM languages as well as the benefits of migrating your tech stack to this optimised language. #Tech #SoftwareDevelopment #Coding

3

👉We have been chatting to a couple of new clients in Germany this week, about using freelance Developers/Engineers outside of Germany (Nearshore), the same questions pop up; ✔How do we know if they are good or not? ✔How much can we save? ✔How quickly can they start? 👀Like anything, there is pros and cons to everywhere, but we have built a network of Freelance Nearshore Engineers who have been rigorously vetted with technical expertise guaranteed, that could save you a 50% reduction on your current freelance rates. If you are interested to understand more about this option and how this could help your business. 🚨Feel free to book a call in my Calendly and let’s see if we can help - https://lnkd.in/eygXyhaz

8

3 Comments

Blog post #11 - Becoming a better manager – The Power of Pair Programming https://lnkd.in/eYRpXkDX In this post, I dive into the concept of pair programming and share my personal experiences with it. Pair programming involves two engineers working together on the same problem, often boosting productivity and code quality through real-time collaboration. I discuss how pairing has enhanced my understanding of team workflows, reduced single points of failure, and allowed me to support my team’s growth as an engineering manager.

2

Since our industry is developing rapidly, there's always an opportunity to make things better. But in a large enterprise-grade company with many issues, it is challenging, extremely tough, and takes so much effort that far not everyone will be mentally able to push for it. You can change the company, or change the company ;) Which game do you go for? Here's my story Valentina (Cupać) Jemuović shared in her newsletter today: https://lnkd.in/drVqxmRK

40

13 Comments

SAFe works as well as TDD Different companies use them: SAFe • Large scale • Low tech culture • Revenue focused (large contracts) TDD • Medium Scale • High tech culture • Tech focused (incl. non-tech teams) Both are great in their niches. This builds their ideology. Most engineers are somewhere in between. In need of pragmatic solutions, For their context alone. TDD or SAFe may work, but: There are no silver bullets in tech. -- PS: I'm back to writing the newsletter! Join Thinking in Tech to find order in the chaos of tech https://lnkd.in/e72CwPkJ

64

82 Comments

99% of CTOs I speak to avoid hiring software engineers for this reason: If you can’t: > Accept constructive feedback > Talk about a project that went wrong > Take accountability for mistakes > Acknowledge contribution of others It’s time to reassess- fast Less ego, more modesty

16

9 Comments

I actually really enjoy working with AI tools, particularly in my development environment. But there is a caveat - AI tools don't always know what is really going on. It frequently makes wrong suggestions. And that isn't a problem for me at all. In fact, I can usually see with a glance why it made the not-so-hot suggestion in the first place. But it does seem like it is only a matter of time before the joy of: AI-just-saved-me-an-hour by-writing-test-variations or saved-me-a-few-trips-to-the-documentation, is made not-so-fun by perhaps not-so-thinking-well folks. If you've ever known a software/web developer who thought google and/or stack overflow could "solve all the things", without the need for those pesky reasoning steps... AI starts feeling a bit more scary. Yep, I can tell you exactly why googling a file path or module name unique to your own system isn't going to turn up much on google... search engines are powerful tools but you do need to reason about the results it gives you and what you are putting into it. The cynical part of my brain is already imagining a future where I get asked to look at someone's code who may have gotten carried with an AI tool and can't figure out why it 'doesn't work.' Code that was perhaps never designed to 'work' in the first place. Powerful tools are still only as good as their user's ability to wield them.

1