Simone Basso

Come la vedete voi? C'è un post su #HackerNews che mi ha fatto pensare... Hi. I've been in the profession (SW Eng) for about 18 yrs now. A few years from my 50s. Didn't go the managerial route. Stayed technical. My current gig is in a very difficult and complex project written in C. Been there for 2 yrs now and I'm afraid that due to the ancient tech stack and despite being a good engineer I'm loosing my marketability. After enduring bad behavior for nth time (yeah it's a toxic workplace) I decided I had enough and did a round of applications. Mostly for backend positions and mostly for golang positions. I don't have prod xp with golang but it's close to C and every time I've used it it seemed ok. But the problem is that I'm either being ignored or skipped over. All jobs are for seniors in the _specific_tech_stack_. Other positions I've applied for and got no response whatsoever are architects, tech managers and the like. Granded, this regards a turd job market (EU/Greece) but still that's where I am at. Am I toasted for good? I mean, nearing my 50s with my most recent gig writing "C" on it is as good as declaring my career over? Link nel primo commento...

14

16 commenti

Micro-Frontends or Components? Probably the most common anti-pattern in building #microfrontends architectures. I've supported many teams worldwide failing identifying the right boundaries and inevitably they have found friction further down the line. In this 10 minutes talk, I described the differences between the two and why micro-frontends are NOT components. And if you want to learn more about micro-frontends, I got plenty of free resources for you: - intro to micro-frontends: https://lnkd.in/esQ-vNic - fortnightly newsletter: https://lnkd.in/eg3sankV - video podcast: https://lnkd.in/e3Uj8mrQ #frontend #web #developers #react #angular #javascript #js #free #devs #microservices #distributedsystems #cloud #architecture https://lnkd.in/eF2tvg_S

122

2 commenti

I wrote about a fully ES/CQRS implementation on AWS serverless with Clojure. TLDR? It's complicated 😉 #serverless #aws #clojure

9

A bit more than a month ago, Bending Spoons announced their acquisition of WeTransfer, an Amsterdam-based company. Today it's reported that the new owner will lay off 75% of the staff (~260 people) and it made me feel a bit pensive. If you don't know Bending Spoons, it's an Italian tech company which acquires existing products and apps. Their strategy so far has been to buy assets that are past their high growth phase, and to make them (more) profitable. Over the last 2 years they bought a few well-known names like Hopin/Streamyard, Evernote, Meetup, and now WeTransfer, on top of lesser-known ones. Each of there products has a number of devoted users and stable revenue, most if not all of them are profitable, though at least some of them failed to meet their potential: * Evernote was valued at $1.1B back in 2013, but since then has fell of a cliff and has laid off most of their staff * Hopin raised more than $1B and was worth $8B at some point, driven by the pandemic-related need for virtual events; since then they shut down all their original products, the only one remaining were acquired apps like Streamyard * Meetup is still the go-to place for finding local hobbyist events to attend, but changed owners 3 times in the last 7 years Bending Spoons' model is similar after every acquisition – lay off most or all of the staff and bring the development in-house to lower the costs. Their operations and development in Italy is significantly cheaper than in US, and their products have trusted, if maybe sometimes tarnished, brands that can keep their existing users and potentially bring new ones. Does this work? Private equity companies have proven that acquiring companies and optimizing their costs can work, however since these transactions are private they often remain undisclosed, so it's hard to say how profitable it is. So far Bending Spoons has raised more than $500M and is valued at more than $2.5B, and this year they have been on acquisition spree. Back to WeTransfer, this one hurts a bit. While I was never a heavy user, I've always seen WeTransfer as a special company – they are a certified B Corp, they've been using their advertising platform to promote artists and culture, they commissioned a short film that won an Oscar. They were also about to go public back in 2022, but their struggled with their business model under the new reality of higher interest rates. So it stings a bit that a local, Amsterdam based, quirky company with such an impact on culture ends up as just yet another product in a large portfolio. Good luck to Bending Spoons though, it's good to see a European tech company growing so quickly!

383

52 commenti

My latest article for the Box Developer Blog has landed. Using the new Box TypeScript SDK I show how to easily create an exportable folder report with shared links to all the documents https://lnkd.in/ejA-qQKh

21

1 commento

Why #cachestampede Happens A #cachestampede occurs when a large number of requests simultaneously miss a cached item. This phenomenon is a significant challenge in the tech industry, impacting various systems and services. Three main factors contribute to cache stampedes: ⚡ Cache expiration: When a cached item expires, multiple clients request the data simultaneously. ❄ Cache invalidation: If a cached item is invalidated, multiple clients seek the updated data simultaneously. ☄ Sudden traffic surge: An unexpected spike in traffic can overwhelm the cache, leading to numerous cache misses. The Domino Effect of a cache stampede can be severe, causing: - Overloaded backend systems - Increased latency and slow response times - System instability and potential crashes - User dissatisfaction due to slow performance and errors It's crucial to address and mitigate cache stampedes, especially for systems heavily reliant on caching like web applications, gaming servers, and recommendation systems. Understanding the causes and effects of cache stampedes is key to maintaining optimal system performance and user experience. Strategies to avoid cache stampedes: 🔗 Rate Limiting: Limit the number of requests per unit of time. 🔗 Cache Warming: Pre-populate the cache with frequently accessed data. 🔗 Distributed Caching: Distribute cache load across multiple nodes. 🔗 Circuit Breakers: Implement to isolate failing components. 🔗 Asynchronous Updates: Update the cache asynchronously. 🔗 Cache Locking: Use a mechanism to ensure single process updates. 🔗 Cache Expiration Optimization: Choose cache expiration times carefully. 🔗 Monitoring and Alerting: Implement robust monitoring. #TechIndustry #CacheManagement #SystemPerformance #DevOps #DesignThinking #Cloud Links for further insight: 1. https://lnkd.in/g6h3Zjrh 2. https://lnkd.in/gj2KRCRU

4

I came across a post from Jakob Jenkov (Thank you, for the insights) regarding OOP & FP. I felt it was worth delving into the details and sharing my openion: ✴️ 1. OOP and FP Are Not Opposites: OOP and FP are not inherently contradictory. Both paradigms aim to build modular, reusable, and maintainable systems, though their approaches differ: FP emphasizes pure functions, immutability, and stateless computation. This formalism naturally leads to composable systems, as smaller, predictable units are easier to combine. Modern OOP has shifted toward composition over inheritance, emphasizing modularity and composability. The key is how OOP concepts are applied in practice. ✴️ 2. OOP Is Evolving: Inheritance: Once central to OOP, inheritance is now often avoided due to the tight coupling and complexity it introduces. Many prefer composition or interface-based design to achieve flexibility. Encapsulation: While foundational, modern OOP recognizes that strict encapsulation can be impractical. In real-world systems, breaking encapsulation (e.g., sharing internal state where it makes sense) can simplify code. This evolution reflects a pragmatic shift: use OOP as a means to an end, not a rigid ideology. ✴️ 3. Composability as the Common Goal: In FP, composability is often explicit (e.g., function composition, higher-order functions). In modern OOP, composability can be achieved through patterns like dependency injection, modular design, or component-based architectures. The focus is less on adhering to OOP "purity" and more on creating adaptable systems. ✴️ 4. OOP's Original Theory Has Limitations I agree with your critique of classical OOP theory. Its emphasis on: Hierarchies (overuse of inheritance) often result in rigid, overly complex systems. Encapsulation for its own sake can obscure the bigger picture and hinder performance or flexibility. Modern programming has demonstrated that loosening these constraints leads to better outcomes. ✴️ 5. Practicality Over Purity In practice, many modern languages (e.g., Python, Kotlin, JavaScript) and frameworks blend OOP and FP principles. Examples: Python’s standard library uses both FP (e.g., map, filter, lambdas) and OOP (classes, inheritance). Functional concepts like immutability and first-class functions are increasingly embraced even in traditionally OOP languages (e.g., Java’s Streams, C#’s LINQ). What matters is achieving composability and maintainability, not strict adherence to one paradigm. ✴️ ✴️ Final Take: OOP and FP each offer valuable tools for building composable systems. The key is understanding the strengths and weaknesses of both: Use FP when we need immutability, statelessness, and predictable behavior. Use OOP when we need encapsulated state and modular abstractions. In practice, a hybrid approach—embracing the best ideas from both paradigms—is often the most effective way to write clear, composable, and maintainable codebases. Please share your thoughts as well. 🙏

17

2 commenti

𝗪𝗵𝘆 𝘀𝗵𝗼𝘂𝗹𝗱 𝗔𝗥𝗣𝗨 𝗯𝗲 𝘆𝗼𝘂𝗿 𝗽𝗿𝗶𝗺𝗮𝗿𝘆 𝗔/𝗕 𝘁𝗲𝘀𝘁𝗶𝗻𝗴 𝗺𝗲𝘁𝗿𝗶𝗰?  💸 There are neat frameworks for finding comprehensive and elegant complex metrics for later stage testing, such as North Star Metrics. But if you are just starting out your testing, don’t worry about any of that. These more complex metrics are usually activation/engagement/retention-related, and it’s too soon for you to focus on those as primary testing goals. I’m going to try to read your mind a bit, but I’d guess you care about 𝗿𝗲𝘃𝗲𝗻𝘂𝗲 the most as a startup still early in your growth journey and trying to keep the lights on. And based on my expert mind-reading abilities, I’ll now offer you the single metric that is almost certainly the most relevant for you:  𝗔𝗥𝗣𝗨, 𝗼𝗿 𝗮𝘃𝗲𝗿𝗮𝗴𝗲 (𝗻𝗲𝘁) 𝗿𝗲𝘃𝗲𝗻𝘂𝗲 𝗽𝗲𝗿 𝘂𝘀𝗲𝗿 💸 “Uhh, is it really that simple?” If you are an early stage business and just kicking off your experimentation program—yes. 9 times out of 10 this is what matters most to you. Why? Because you’re probably just starting to move from the 0 → 1 of getting product-market fit to the 1 → 10 of scaling your business. 𝗥𝗲𝘃𝗲𝗻𝘂𝗲 𝗶𝘀 𝗮𝗹𝘄𝗮𝘆𝘀 𝘁𝗵𝗲 𝗳𝗶𝗿𝘀𝘁 𝗮𝗻𝗱 𝗺𝗼𝘀𝘁 𝗶𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝘁𝗵𝗶𝗻𝗴 𝗵𝗲𝗿𝗲, assuming you are a business that relies on your monetization, not just your fundraising, to scale and survive. And ARPU is the most complete metric there is for revenue. Bring in more money for each new user, and you bring in more money for the business.  Read on for a few tips on how to wire up and use ARPU the right way. ⚗️𝗛𝗶, 𝗜’𝗺 𝗝𝗲𝘀𝘀𝗲. I help teams to establish and accelerate their experimentation and product-led growth programs, from analytics to product processes to growth design. Follow me for more tips 🏆

6

1 commento

⚡ "We're Looking for Senior Developers" - The Biggest Lie in Tech After conducting hundreds of interviews, I've discovered something shocking: Most companies don't need senior developers. They need problem solvers who can code. The uncomfortable truth: 1. A mid-level who ships > A senior who perfects 2. A junior who learns > A senior who knows 3. A team player who adapts > A guru who dictates Why do companies still post "Senior Only" roles? Fear. Plain and simple. 🎯 For Hiring Managers: Stop filtering by years of experience. Start filtering for growth potential. Have you seen this pattern at your company? Share your experience 👇 *** P.S. Hit that 🔔 on your way out if you believe experience is overrated but still put "15+ years" in your bio anyway.

736

200 commenti

Stuck in a feature factory? 4x thoughts for better work + less frustration 𝟭. 𝗨𝗡𝗗𝗘𝗥𝗦𝗧𝗔𝗡𝗗 𝗬𝗢𝗨𝗥 𝗠𝗔𝗡𝗗𝗔𝗧𝗘 • Speak with the CEO / your boss / stakeholders • What do they actually want you to do? • Do they want you to be a Marty Cagan style PM? • Or do they just want you to ship stuff? This is important because: • You need to build credibility by doing the job expected of you before you can do anything else. • Complaining that they "don't understand product" will only lead to frustration all round. • Your job isn't really your title. Your job is solving problems for your boss. Let's assume they basically want you to ship stuff. How do you add more value and mature the culture? Read on ... 𝟮. 𝗗𝗜𝗚 𝗙𝗢𝗥 𝗖𝗢𝗡𝗧𝗘𝗫𝗧 You've just been told to build something. What next? • You need to know you're talking about the same thing • You need to build personal conviction to build it well • Don't just take a 1 sentence request and start building • Insist on a kick off, and mine them for context first    Questions to ask: • Why do they want to build this? • What do they expect to happen when it ships? • What references are they thinking of? • How much time do they want to invest in this? • Is this a test to learn, or a scalable solution? • What made them think this is a good idea? • Which risks do they want you to handle, if any? (value, feasibility, usability) Write this all down in a PRD / 1 pager You should all have a MUCH better idea of what you're building now. You should be able to evangelise this to engineers. This will lead to better outcomes all round. 𝟯. 𝗠𝗔𝗞𝗘 𝗜𝗧 𝗖𝗢𝗠𝗠𝗘𝗥𝗖𝗜𝗔𝗟 • PMs help stakeholders make smart investments in technology • Do this by converting feature requests into investment language • Express time to build as a $ cost • Convert expected outcomes into $ impact (where possible) • Calculate expected and actual ROI on the build (where possible) • If you can't calculate ROI, what would someone need to believe for this to be ROI positive? Is it believable? This will: • Make you seem very commercial (always a good thing) • Expose features where the ROI doesn't stack up • Expose big financial risks that could be mitigated with discovery 𝟰. 𝗗𝗜𝗦𝗖𝗢𝗩𝗘𝗥𝗬 𝗔𝗦 𝗔 𝗦𝗘𝗥𝗩𝗜𝗖𝗘 By this point, you should be able to offer "discovery as a service" • Have mistakes been made in the past? • Have you exposed big risks in the feature request? • Suggest ways to reduce risk with some lean discovery • Don't be partisan. Let the stakeholder decide whether they want this. • Discovery is a tool to solve a problem • The problem it solves is excess risk • Highlight the problem (risk) and stakeholders will want the solution (discovery) Hustle Badger is the best place to accelerate your product career with a wiki, courses and community.

136

9 commenti

Yesterday was the Frontend Performance Day from WeAreDevelopers, where three fascinating talks took place: - Catching up on the basics - you don't really need that much code from Chris Heilmann - Snappy UI needs no Single-Page Application from Clemens Helm - Leveraging Server-Sent Events (SSE) for Efficient Data Streaming in UI Development from Rainer Stropek Personally, my key takeaways from these talks are: - Review your code, tools, and frameworks regularly. Browsers are constantly evolving, and many features are already available, so trust the browser to do it for you. This will reduce the JavaScript required to maintain and the cost of maintaining it. Adopting this mindset will boost your customer and developer experience. - The browser has changed significantly over the years since its early days when we started, but all these patterns used to optimise the user experience are still very viable. Clemens provides a great recap and practical application of this. - I wasn't familiar with Server-Sent Events (SSE). Rainer's talk was a great introduction to this protocol and how to use it. I learned a lot about its usage and its similarities with streaming responses. It's well worth watching as it gives us another tool in our belt to provide the best solution for our customers when given the use case. #webperformance #frontenddevelopment #wearedevelopers #frontendarchitecture

5

My take: software engineers will still be much needed in the era of LLM-aided software development. Their role may evolve, but their contribution will be indispensable. Here's why: - Software engineers are coming up with novel and useful design patterns for LLM based architectures. This shows that humans already started "abstracting themselves away" from the thinking plane that LLMs are overtaking. - LLMs will enable small engineering teams to construct incredibly complex solutions, heralding another golden era of software engineering. Together with AI, humans will be building *more* software, not less.

43

3 commenti

𝐒𝐭𝐮𝐜𝐤 𝐰𝐢𝐭𝐡 𝐚 𝐥𝐞𝐠𝐚𝐜𝐲 𝐬𝐲𝐬𝐭𝐞𝐦 𝐭𝐡𝐚𝐭'𝐬 𝐢𝐦𝐩𝐨𝐬𝐬𝐢𝐛𝐥𝐞 𝐭𝐨 𝐜𝐡𝐚𝐧𝐠𝐞 𝐰𝐢𝐭𝐡𝐨𝐮𝐭 𝐛𝐫𝐞𝐚𝐤𝐢𝐧𝐠 𝐞𝐯𝐞𝐫𝐲𝐭𝐡𝐢𝐧𝐠? 𝐁𝐮𝐛𝐛𝐥𝐞 𝐂𝐨𝐧𝐭𝐞𝐱𝐭𝐬 could be the game-changer you’re missing! Developed by DDD expert Nick Tune, 𝐁𝐮𝐛𝐛𝐥𝐞 𝐂𝐨𝐧𝐭𝐞𝐱𝐭𝐬 allow you to modernize aging monoliths without risking your entire system. Instead of overhauling everything at once, you create a “bubble” of modern, clean code around the legacy system, introducing new features gradually. For example, instead of touching a 15-year-old monolithic CRM and risking chaos, build a new feature (like customer segmentation) inside a 𝐁𝐮𝐛𝐛𝐥𝐞 𝐂𝐨𝐧𝐭𝐞𝐱𝐭. This modernized feature interacts with the old system through an 𝐚𝐧𝐭𝐢-𝐜𝐨𝐫𝐫𝐮𝐩𝐭𝐢𝐨𝐧 𝐥𝐚𝐲𝐞𝐫, keeping both parts separate and safe. Over time, the bubble grows, and the legacy fades away – one piece at a time. 𝐁𝐮𝐛𝐛𝐥𝐞 𝐂𝐨𝐧𝐭𝐞𝐱𝐭𝐬 let you modernize incrementally, with less risk and disruption. Don’t let legacy systems hold you hostage. Break free, one feature at a time! Have you tried Bubble Contexts? Let’s hear your war stories! 👇 ——— BTW, I’m Michael, and I help small and medium businesses modernize their legacy Microsoft .NET systems. DM me or use the link in my profile to get a free consultation. #legacymodernization #cloudmigration #softwarearchitecture #softwaredevelopment #problemsolving 📸 Image credit: 'Patterns, Principles, and Practices of Domain-Driven Design' by Scott Millett & Nick Tune.

7

4 commenti

Fundamentals of software architecture! Every decision in software architecture is a trade-off. If you think you found a solution that isn't a trade-off - it just mean you haven't identified what that trade-off is yet! https://buff.ly/3Mr50LT #saas #webdev #SoftwareArchitecture #ProductDevelopment

4

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 commento

Android Studio Meerkat | 2024.3.1 Canary 1 is now available. But this sparked significant backlash from developers. Why? They want to put back Clean Project and Rebuild Project buttons! Many argue that these features are essential for effective development, especially when dealing with complex projects or resolving build issues. Here’s why developers are frustrated: 1. Android Studio should avoid creating situations where these buttons are needed. 2. Full-time developers use Clean/Rebuild multiple times a day. 3. Making it harder to use your computer's CPU for clean/rebuild tasks is frustrating. 4. Issues with views or Dagger/Hilt often require a clean/rebuild to resolve. 5. Google’s changes seem to make simple tasks more complex. 6. Removing these options ignores the real needs of developers. 7. Developers feel disconnected from those making these decisions. 8. Burying useful functions makes life harder for new developers. What are your thoughts on this change? Have you experienced similar frustrations with recent Android Studio updates? #android #mobile

7

"What should I put into my events"? Very common event-driven architecture question. What goes inside the envelope is up to you. What does the envelope look like itself? This is where CloudEvents can help I created a visual here to help you understand more https://lnkd.in/e249CGND

46