Oliver Wehrens

👉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 Kommentare

I have a couple of side projects running in production. One thing that is a HUGE difference in how I have no hesitation to touch them even after months of not seeing the code (and thus losing context:) Tests. I write them for all the business logic I add / modify. Just did a refactor on a project I wrote 100% of the code of, and have not touched in several months. Confident that my changes are correct, I ran the tests, expecting all of them to pass. Instead, this happened (the below image:) Wow!! My *past self* just prevented my present self from pushing code to production that would have broken this project! Talk about me saving myself! High five to "earlier" me!! I am convinced having these tests are better than anything else that I could have added to these side projects. Coincidentally, side projects I am terrified to touch have no such tests, and I don't feel like understanding the whole codebase (my codebase!) from scratch, again. If you are wondering whether it's worth writing tests: you decide if they are. I know that I don't write these tests for my current self. It's for my future self (or for any other person who will modify the code I wrote, and added descriptive enough tests for)

1.651

107 Kommentare

Microservices architecture provides a good solution for multi-team development. Sadly, organizations are seldom aware of the associated high DevOps costs. Often a modular monolith would be more cost-effective and still support parallel development. Later, if necessary (Meaning that there are tens of thousands of concurrent users), you can migrate to a distributed (micro-)service architecture. I often see companies jumping on the microservice train and complaining later about the costs of their solution. I strongly advise: "Think big, Start small".

20

1 Kommentar

I do think that the discourse talks too much about the 10x engineers and not enough about the 10x teams! 10x engineer is a legend - that mythical creature who can churn out code at will and leap tall product roadmaps in a single sprint. But after having studied a lot about distributed engineering teams, I've come to realize that the true value unlock is in building a well-oiled team. I've seen firsthand how a team of "average" engineers, when given the right tools, processes, and culture, can outperform a squad of isolated 10xers. The analogy that comes to my mind is how ISRO has demonstrated resourcefulness - dont think most of folks at ISRO are IITians but they just know how to get GREAT work done on a budget. If you are thinking about global team, the ISRO mental model is crazy powerful in my opinion. It is a hard problem to solve. Not only do you have to hire RIGHT but also manage RIGHT. That is also the reason we are spending ton of time getting this process right for ourselves - when we partner with businesses, we want to assemble a great team for them that KILLS. Bat-signal for all “average” engineers who want to be part of a great team - would love to see how InCommon can help.

4

The buzz around TDD sucks. 😱 My take: ➡ Tests are essential, but WRITING TESTS FIRST is NOT ESSENTIAL ➡ TDD is ESSENTIAL for REGRESSION TESTS - first reproduce the bug - then fix it ➡ In regular software development I rarely do TDD - and I also don't care much. More on the topic: https://lnkd.in/gMgfkc5f YMMV - What do you think? #qa #software #tdd #development #quality #cto #tech Thanks Dmitryi Serebrich for the nice discussion yesterday!

12

1 Kommentar

📰Introducing Miniflux: A Minimalist Open-Source News Reader🚀 Ever felt overwhelmed by information overload while managing multiple news feeds? Allow me to introduce you to Miniflux - an opinionated, lightweight feed reader that's going to change your life! 😊 Miniflux is written in Go and PostgreSQL, designed for simplicity, speed, and ease-of-use. Its minimalist approach avoids unnecessary features, focusing on the core functionalities of feed management. Why go for Miniflux? - Zero dependencies: Standalone binary ensures hassle-free installation 💻 - Single binary compiled statically without dependency - No ORM or complicated framework: Clean, efficient codebase for developers 🧑‍💻 - Modern Javascript (ES6 and Fetch API): Smooth user experience 🎯 - Extensive documentation: A beginner's best friend 📚 Personally, I've fallen in love with its simplicity. With Miniflux, it's now effortless to browse through different sources and enjoy the news without distraction. I am sure you will find it incredibly useful for your projects too! 💡 Now that you know about Miniflux, I'd love to hear your thoughts on the tool. Have you tried it already? How has it streamlined your workflow? Let's discuss the beauty of minimalism in software development! Feel free to share your feedback or ask questions about Miniflux here 👇 #Miniflux #FeedReaders #OpenSource #GoLang #TechCommunity

5

Are you wasting time focused on the wrong things in code-review via PR? Many teams are. Here's the thing about human code reviews... yes, you can sometimes find a bug. But like, who cares if a human review finds a bug? That's just proof of a deeper failure in your development process. Said another way - if your code reviews of PRs routinely finds bugs, your failure to test is profound, and the logic unsound. Even if the code review finds a bug from time to time... how will you be assured of not re-introducing it, or adding new ones? More human reviews? A vast, overwhelming amount of code-review nits are completely removed with good linting/formatting/scanning, and these tools should be used aggressively. If it can't be automated with a linter/formatter/scanner... it doesn't matter as much, because it's a non-deterministic opinion at that point. Seriously, you want to enforce snake_case_vars but less than 30 characters? Don't argue about it, put it in a scanner that fails a precommit. Or don't, because it's not really that important. But please, don't have a dev go back and rename it based on an arbitrary discussion about 'appropriate variable length'. When have I seen reviews improve quality? When we changed what changes we really focused large reviews on, and what we reviewed. First - a review starts with a review of the design docs/changes. If you can't write about what you've done at the appropriate level, the code can't possibly be done, and the review is over, failed. Second - we review the integration test outputs. That is, this code has been integrated, built, and deployed to at least 2 environments, and these are the integration tests that run, and their output and performance. The tests should give clear coverage of the behaviors and modes described in the design. Routinely this is where the review really spends time, and we'll talk about other failure/load modes to test. Depending on the scope, sometimes we'll review the unit test suite details and discuss details and enhancements. Lastly - let's actually look at the implementation code and details, show us what you're proud of, and the parts that you think are a hack. There's always good discussion here, but if the docs are good and the tests are solid, we're likely logging TODO items here, because the review is already passed. Only if we find something truly heinous would we send it back for rework at this point. This changes expectations in good ways. I don't want devs to be worried about nit-picky reviews, paranoid about formatting... automate it or pick that stuff up in pairing/mob sessions and mini-reviews that people seek for 1-on-1 feedback. I suppose this creates "layers" of reviews, and that seems like the right idea too. Additionally, it depends on a number of other processes around feature flags, version control, CI/CD, architecture governance, and release management to be effective. 🤷‍♂️ #meatbasedengineer

102

24 Kommentare

One of the more requested examples: how to use the Code Interpreter SDK inside a Next.js app with streaming enabled and using the Vercel's AI SDK

10

End-to-end testing and browser automation have one common enemy: flakiness. If you missed Stefan Judis's insightful session at the Browser Conference, now's your chance to catch up with the on-demand recording. In this session, Stefan delves into the main causes of flakiness in Playwright end-to-end tests and shares valuable patterns to avoid false positives. With live coding demonstrations, he provides practical solutions to ensure your tests become reliable and trustworthy. Don’t miss this opportunity to learn how to make your end-to-end tests your best ally in automation. Watch the recording now and enhance your testing strategy. 👇👇👇               https://lnkd.in/e4bYFf-H #BrowserConference #Browserless #PlaywrightTest #AutomationTesting #WebDevelopment browserless

14

The benefits of AI code assistants are still being evaluated, but here at Deutsche Telekom we are confident that our AI strategy to continually assess COTS products, as well as developing our own products and data foundation is the right approach to yield benefits in the future. Have a look at the post below from one of our leading developers on the topic It’s exciting to think about the capabilities of the product in only a few years from now; perhaps covering all aspects of the SDLC and integration to user stories, more context in relation to existing code repos throughout the enterprise (particularly useful for very large enterprises), models optimized for dialects of the languages (GoogleSQL vs PostgreSQL etc)….to think of a few examples Regardless, the developer experience will be greatly enhanced in the next few years and at Deutsche Telekom we’ve got a front row seat! 👏

15

1 Kommentar

Would you like to use Argilla in your own language? ✋ We recently got contacted by Paul Bauriegel, a member of our open-source community who wanted to use Argilla in German, and here's what he did: 📚 Read the developer documentation to set up Argilla locally. 📁 Created a file with the translations to German. That took less than 1h. 🤝 He got help from Damián Pumar in our front-end team to make this work with the UI. 😃 His PR was accepted the following day and a few days later it was published as part of Argilla 1.27.0. 🪄 Now, Argilla automatically detects the main language of the browser and switches automatically to German. If you'd like to see this happening for your own language as well, reach us out in our slack community and we'll be happy to help. Not only you will be contributing to an open-source project, but also helping reforest sub-Saharan Africa through our partnership with JustDiggit! 🌳 Find us in our slack community: https://buff.ly/3fT0Hfx Read our developer documentation: https://buff.ly/44h4UhM You can also check Paul's PR: https://buff.ly/3UfpE58

18

1 Kommentar

𝐀𝐧𝐨𝐭𝐡𝐞𝐫 𝐦𝐞𝐬𝐬𝐚𝐠𝐞 𝐟𝐫𝐨𝐦 𝐃𝐞𝐩𝐞𝐧𝐝𝐚𝐛𝐨𝐭... In the past, I would have waived recommendations like this away. Who needs automatic scanning of your repo and getting a recommendation to update libraries? Shouldn’t it be part of your daily business to check news and update all used dependencies from time to time? Why do I need a tool for that? Might be true. When you are deep into your project, this can be fixed yourself in seconds. But I’ve learned to love tools that automate the whole workflow of checking and fixing known CVEs. Especially when a CI pipeline makes sure those changes don't break the product. (On the other hand: better a broken than a vulnerable product, because this creates pressure to fix 😬) Adding tools like #Dependabot to the workflow and using GitLab’s Dependency Scanning can provide peace of mind. These tools can help ensure that things stay efficient and secure by reducing the risk of vulnerabilities slipping through the cracks. #continuousIntegration #bestPractice #vulnerabilityScanning #cybersecurity #github #python #cpp

8

Sharing Wins is important - Engineering Kiosk on #6 in German Technology Spotify Podcast Charts 🏆 For many Podcasts, Spotify is the biggest distribution platform, even though the Podcast technology (RSS) is open and non-company-bound. The same is true for my Podcast Engineering Kiosk. In addition, the Podcasting industry is booming. Thousands of new podcasts are released daily. I am even more proud of the achievements seen below in the screenshot. The Engineering Kiosk is #6 in the German Technology Podcast Charts on Spotify 🏆 🤡 Fun Fact: In the first six places, only two German-speaking podcasts are available (Engineering Kiosk and Flugforensik by Andreas Spaeth and Benjamin Denes). Now, the big question: why am I sharing this? To remind you that ... • Podcasting is a marathon, not a sprint • You should tune into the Engineering Kiosk on Spotify to learn about Software Engineering (https://lnkd.in/eUZEy4yd) • Every project starts small, and it takes much time to spread and gain traction • I am only here to get claps on my shoulder and to get confirmation of how awesome I am • Also, we (Wolfgang Gassler and me) have regular doubts about our capabilities (#imposter) • When did the SQL developer realize they were getting too old? ➝ When they started experiencing JOIN pains. Because we are all data-driven 📈, I am sharing a few numbers of Engineering Kiosk: • Number of episodes: 133 • Every Tuesday, a new episode • Total length of content: 5 days, 19 hours, 18 minutes, 10 seconds • Avg of episode length 📏: 1.0 hour, 2.0 minutes, 50.0 seconds • Speaking distribution 🙊 (overall episodes): ➝ Andy Grunwald: 41.75% / 2 days, 10 hours, 9 minutes, 40 seconds ➝ Wolfi Gassler: 37.73% / 2 days, 4 hours, 33 minutes, 9 seconds ➝ Interview guests: All the rest

82

6 Kommentare

Is it still that simple? Native implementation of experiments is more effort and lead to less pace and the DOM injected client side is the "speedboat"? What do you think? If you ask me: I would say it's a common narrative to say "injecting variations of code with 3rd party tools in javascript is the fastest way". But is this still the case? Always? Particularly in modern organizations, claiming themselves for being "really" agile, using continuous integration and dev ops etc.? Having x-functional teams, fullstack developers and a different mindset today. I guess: It was the truth, at least if you go back 5 - 10 years where companies used to deploy code (in "major releases") once per quarter and IT departments where always overloaded with tickets. I have the feeling the latter hasn't changed. I still hear that the developers have too much work to do (with developing features or re-platforming or re-launching things) than also developing experiments in the same time. But this is today more related how you organize and prioritize experimentation, how you staff teams, evolved mindset etc. But let's leave these factors out of the equation for a second: Why should be developing an experiment within the SPA lead to less pace than injecting code with JavaScript? Against this background I would clearly say "No, native implementation of experiments should be even faster, easier to QA, more reliable and with greater possibilities in terms of using existing components, APIs, data, logic aso. So the question is: Why is then DOM Injection still on the plate 2024? In my experience because in reality you can't leave the named factors out of the equation. Companies organize themselves today along products and teams around it. They (sometimes) have common goals compared to marketeers or salees, which focus on the conversion more likely than the PO does on her or his product (which often is just a tile of the real customer journey). It's clearly a to complex topic to shrink it to that paradigm. But if you ask your selves: Why does your developers focus on developing features more than implement variations of customer journey? The answer can't be "they are not able to". The technology is there, the skills, methods, process, knowledge. The reason must be some where else. In my experience in the organization itself. An indication of this is by asking about the vision or strategy for experimentation. Usually there is none. Or at least not in a way which enables teams to priotice testing topics at least as high as other feature topics. So in the end, the "conversion guy" which still is more than often someone who has also 2-3 other topics or in best case the "center of excellence" needs to drive their testing roadmap themselves, and since there is always to less resources and time, the old fashioned speedboat is not that old at all. Sounds familiar? Yes?, No? What is your experience?

8

1 Kommentar

Let me ask all the executives at #webagencies and companies who have the final say in #websitedevelopment: Are you frustrated with constant delays 🐌 and escalating 📈 costs❓ Check out pageBody GmbH if you want to speed up🏃‍♀️your #webdevelopment! They have got the right talent and some impressive solutions to make things smoother and faster. Give them a follow❣️

3

Every new model should outperform the last. But reality often falls short. 🚫 Testing shows disappointing results. Switching models on existing APIs isn't feasible. Let's dive into the details and see why. #AIFail #TechTruth #ModelTesting #APIs #Innovation

5

Why would we write functional specifications to express a vision? 💡 In 2021, when we started working on WeTransform, we didn't write a single line of code for several months. We didn't write any long functional specifications in boring documentation either. We wrote wireframes. A wireframe is a visual representation of a user interface. It allows anyone to understand the structure of the page, the information that will be displayed, and the actions that can be performed. It quickly shows whether the user interface is intuitive, and whether the user experience is satisfying. - if there is too much text, the wireframe looks cluttered, and we know that good features don't need much explanation. - if there are too many buttons, the wireframe relations are complex, and we know the features won't be understood nor used. - if too many wireframes are required for a feature, we know that we need to challenge the way it works. Wireframes helped us to quickly iterate on the product at a cheap cost, sharing a clear vision with the team, and getting feedback from future users. Now, if you need to specify a complex feature or even a product, keep in mind that an image is worth a thousand words!

7

This is one reason hands-on experience with large and complex systems full of technical debt is a great organizational asset for engineering leaders. If you've felt the pain of technical debt that's grown over years, you'll become an awesome advocate for the power of doing things right in a sustainable way. Well-defined interfaces, contracts and schemas for passing information are great examples of how much a little up-front effort can end up saving you down the road. You never want to prematurely optimize or make architecture decisions that unnecessarily complicate things, but there's a lot of power in making the right decisions on where to expend your team's effort. Spending time in design and architecture up-front can end up making a real difference in the end. It's also about well-tested systems that give you the freedom, as a group, to maintain and refactor systems whenever needed, without crippling engineering output or creating uncomfortable risk.

9

2 Kommentare