Raul Mangolin

What countries have an 8-4 hour working time overlap with the US and a huge pool of Fullstack Engineers? 👇👇👇 🇧🇷 Brazil: 180,000 software engineers -> EST: 8 hours overlap -> PST: 5 hours overlap 🇦🇷 Argentina: 48,000 software engineers -> EST: 7 hours overlap -> PST: 4 hours overlap 🇲🇽 Mexico: 40,000 software engineers -> EST: 8 hours overlap -> PST: 6 hours overlap 🇨🇴 Colombia: 32,000 software engineers -> EST: 8 hours overlap -> PST: 6 hours overlap 🇨🇱 Chile: 18,000 software engineers -> EST: 7 hours overlap -> PST: 4 hours overlap ---------------------------------------------------------------------------- 💬 Drop a comment and I’ll shoot you a report on US startups hiring full-stack devs—where, how, and the $$$! ---------------------------------------------------------------------------- P.S. If you want to learn more about how YC, A16z, and other startups are climbing to the top, consider following me.

4

2 Comments

🚀 What’s New in Node.js for 2025? The latest Node.js update is here, packed with features that make it even more reliable and efficient for developers and businesses alike. Here’s what you can look forward to in 2025: ✅ HTTP/3 Support: Experience faster, more secure connections with native integration for the latest internet protocol. ✅ Enhanced Debugging Tools: Pinpoint issues in real-time with upgraded diagnostics that make error tracking simpler than ever. ✅ ESM Improvements: Modern JavaScript developers will love the updated support for ECMAScript modules, allowing for smoother integration in projects. ✅ Resource Optimization: Smarter memory management means better performance and a focus on sustainable development practices. These upgrades ensure Node.js remains at the forefront of server-side development, enabling developers to build high-performing applications for any industry. What’s your favorite feature from this update? Share your thoughts in the comments below! #NodeJS #TechUpdates #WebDevelopment

18

Test Driven Development & Developer Advocacy - Interview With Guilherme Ferreira You're not a real developer unless you do TDD. Gui Ferreira is a TDD expert -- but no, not even he would tell you this. In our chat together, we covered a lot of ground. It was great to sit down with a fellow Dometrain course author to go over: - His career journey - Developer advocacy - Test-driven development - And MUCH more! Huge thanks to Gui for the talk, and I'd love to do more in the future! 👇Check the comments for the video link!👇

39

3 Comments

New edition on the Lodgify Tech Blog! 🚀 We're excited to share our latest blog post authored by Luiz: "Implementing Cache with the Decorator Pattern". In this article, Luiz explores how to leverage the Decorator Pattern to efficiently implement caching, enhancing both performance and scalability in your applications. Whether you’re an experienced developer or just getting started, Luiz’s insights and practical examples will be invaluable for your next project 😉. Check out the full post here: https://lnkd.in/d5pkvAXR Explore careers at Lodgify and join us on the innovation journey! https://lnkd.in/g46Ghnr #TechBlog #SoftwareDevelopment #Caching #DecoratorPattern #LodgifyTech #ProgrammingTips

27

🚀 Hi Masterclass #41 is a wrap! Alexandre Maia shared expert tips on mastering Observables in Angular, from smoother data streams to better app performance. 🎥 Missed it? Watch it at https://lnkd.in/d3eRxBgg #HiMasterclass #Angular #Frontend #Observables

9

Five years ago, we started MuukTest with a question: Could we make "Great Software Testing and Automation" easier? My cofounder Renan Ugalde & I each have 20+ years of Software Development & QA experience. We've seen Bad Software Testing and Great Software Testing - way too much of the former, not enough of the latter: Bad Software Testing:  - Nonexistent professional testing team, expecting "developers to do all their own testing" (which 'works' until it doesn't) - Wild, non-disciplined, exploratory testing that doesn't help  - Testing that's treated as a second-class citizen in an engineering org, not as a partner - Reactive, under-resourced testing teams  - Testing with deficient coverage and no automation at all - Testing that's treated as the last step in an assembly line - Massive teams of testers, treated like a boiler room - Testing that slows engineering down I spent years of my life in Software QA and Testing roles like this… where I spent my Christmas holidays frantically, manually running regression tests across an entire application that *had* to be released yesterday. This is bad Software Testing. It is stressful for everyone and doesn't lead to good outcomes. Great Software Testing is:  - Proactive - A mix of (smart, disciplined, strategic) manual exploration and automation - Partner to engineering - Happens throughout the engineering cycle - Performed and coordinated by small teams of testing experts  - Employs amazing tools - Helps engineering move faster - Delivers insights, not more work Since 5 years ago, we have always believed that 'Great, Fast, Efficient Software Testing' will be made possible by AI. Bad testing happens because of bad ideas and bad tools, but with AI helping with a lot of the heavy lifting of test automation and maintenance, 'Great, Fast, Efficient Software Testing' is possible for more teams. Proud of our work in AI, making Great Software Testing possible for ANY software team. Great Software Testing means better software, faster development, happier customers, and better outcomes for all. 

25

🚀 Exciting Breakthrough in Mobile Development! 🚀  At Janea Systems, we pride ourselves on pushing the boundaries of mobile software innovation. Three of our expert software engineers, Jaime Bernardo, Denis Bogomolov, and Adam Kaczmarek recently tackled a tricky issue: updating the SQLite3 native module within Cordova Node.js Mobile Apps. This integration was crucial for a client delivering government-related geolocation services, enhancing the functionality of their mobile applications.   🔍 In our latest blog, we dive deep into the technical hurdles and our strategic solutions:  Adapting Build Environments: Tailoring node-gyp for mobile-specific requirements.  Cross-Platform Compatibility: Ensuring seamless functionality across iOS and Android.  Open Source Contributions: Sharing our advancements to benefit the wider developer community.  Read more about how we enhanced mobile app capabilities and broadened Node.js's reach in less than a week! 🌐https://lnkd.in/dujcg_Ze #NodeJS #MobileDevelopment #OpenSource #SoftwareInnovation #TechCommunity #Cordova #NodejsMobile #SoftwareEngineering #Interoperability #CrossPlatform #AppDevelopment #Android #iOS #SQLite3 #Ionic  

14

Delba de Oliveira crushed it with an awesome talk on the future of UI development using React's #useClient directive, even though she couldn’t be with us in person! Check out how to optimize your web apps with better bundling and server-client harmony: https://hubs.li/Q02Td5hV0

5

Software Engineering Mistakes [3/5] Building only features - neglecting tech debt Customer-facing features are great! That’s how companies deliver value and make money. 💵 However, one cannot build features forever. When teams try to do this, quality decreases, complexity increases, and life becomes miserable. 💀 At this point, most teams have to stop and handle the tech debt, which can be painful. (By "tech debt," I mean investment in any activity that helps the team move faster.) What’s a better model? Do this sustainably, not in fits and spurts. 1️⃣ Use the right words to describe the types of work. The Flow Framework is a great tool here. It uses Features, Defects, Debt, and Risk. 2️⃣ Make it clear to stakeholders that software engineering *requires* these other types of work. 3️⃣ Implement backstops in your process, such as “no more than so many items in each category at the same time”, “when bugs are greater than X, we pause feature work” or “at least 30% of time spent on tech debt”. 4️⃣ Think of tech debt broadly. Anything that improves your delivery speed can be in this category: new tech, updating processes, refactoring or rebuilding, etc. 💡 Building things does not suffice; you constantly need to get better at building. If you don’t, your competition will, and they will take your lunch.)

2

A real simple case of how TDD from the inside-out can lead to poor design... I was working on a simple function to nest one data structure inside another based on parent and child relationships. I created the following simple test, and got AI to pass it: > parents = [{'id': id, 'name': 'mother'}, {'id': 2, 'name': 'father'}] > children = [{'name': 'child', 'parent_id': id}] > assert nest_children(parents, children) == [{'id': id, 'name': 'mother', 'children': [{'name': 'child', 'parent_id': id}]}, {'id': 2, 'name': 'father'}] GenAI did a good enough job. It created a list of parents by id: > parent_lookup = {parent['id']: parent for parent in parents} And then looped the children by looking up the parent in the list. > parent_id = child['parent_id'] It worked so in the spirit of red, green, refactor I began to refactor. First thing I decided was that the function knew too much about the data structure. Really this should be passed in. To provide maximum control I decided to provide a lambda. I refactored in steps (extract variable, variable to parameter etc.) Now I ended up with a function which looked like this: nest_children(parents, children, lambda p: p['id'], lambda c: c['parent_id']) Test passed. Job done. Not quite so fast! Look what just happened. The signature reflects the algorithm. Do you see? I'm passing two lambdas because that's how the algorithm works. This is what happens when we drive design based on implementation. I needed to stop and think again what my test should look like from a client perspective. And then make the test pass with the right algorithm. Once I thought about it, a much neater and more idiomatic function would follow the style of map: > nest_children(myfunc, parents, children) or: > nest_children(lambda p, c: p['id'] == c['parent-id'], parents, children) Now I have to change my algorithm (or GenAI does) to pass the test. See the difference testing from the outside makes to your design?

1

5 Comments

After leading several architecture decisions at different companies, I wanted to share some real talk about the eternal debate: Microservices vs. Monolithic Architecture. Let's cut through the hype and get practical about what actually works. Monolithic Architecture: The OG Approach 🏛️ Think of it as building one robust house rather than a village. Everything's under one roof, which honestly made my life easier when: - Rapid prototyping was crucial for our MVP - Our team was small and needed to move fast - We needed quick debugging sessions (saved me countless late-night debugging headaches!) But here's the catch - as our product grew, so did our deployment anxiety. Every small change meant redeploying everything. Been there, sweating through those releases! Microservices: The New Kid on the Block 🏗️ Breaking things down into smaller, independent services sounds great in theory, and it really shined when: - Different teams needed to work independently (helped us scale from 5 to 50 developers!) - We needed to scale specific features (our authentication service was getting hammered while the rest was chilling) - Tech stack flexibility was crucial (let each team pick their best tools) Real talk though - microservices aren't a silver bullet. The distributed debugging sessions can make you question your life choices! 😅 What I've Learned the Hard Way: 1. Start with a well-structured monolith. You can always break it down later. 2. Don't jump on the microservices bandwagon just because Netflix does it 3. Consider your team size and DevOps capabilities - microservices need serious operational muscle Recently transitioned a 5-year-old monolith to microservices, and whew, what a journey! Would love to hear your war stories. Have you made the switch? Sticking with monolith? Let's share some battle scars in the comments! 💪 #SoftwareArchitecture #Engineering #TechLeadership #SoftwareDevelopment #TechCommunity #30DaysOfTech

4

Sometimes when we think about technical debt, the immediate reaction is to want to stamp it out. Fix things, upgrade everything, refactor. Now. But sometimes you have to pause and ask: will an application gain value when we refactor it? Try flipping that question around: does a badly written app have enough value that it's worth refactoring? Maybe that's the question you need to ask.

16

Several "bad smell" in this post: - "A code that embraces the inability of our mocking tools to mock classes (so we end up with a lot of nonsensical interfaces that bear no meaning and are only there to allow mocking), tests that spend most of their effort mocking other classes rather than testing their logic, and the worst: tests that enforces a specific implementation by checking that the code called the mocked dependencies at the right time with the right parameters." If you have "a lot of nonsensical interfaces", your Object-Oriented design is bad, not the testing itself. Mocks should be used to mock other system stuff that is too complex to test with your code. Not all test have to be unit-tests, some can be test of a limited bunch of your classes. So testing the right invocation of mocked class make sense, not the testing of your implementation. Should implement test of functionalities, not of implementations. - "When introduced to unit testing, we were promised that the value of these tests would be that we could later change the code and detect the regressions by re-running the tests. But none of this is even remotely true! Every time we change the code, we break a LOT of tests, and these are just indications that the tests were assuming a specific implementation, and hardly ever that we accidentally introduced a regression!" If *your implementation of unit testing* are too fragile, it is the case you're testing *the wrong thing*: again, you are testing the implementation, not the functionality. For that reason your test broke so frequently. You just say that yourself: *"these are just indications that the tests were assuming a specific implementation"*. - "What are your testing exactly? That the compiler works?" Nope. That is how *you* wrote your tests. - "you can’t refactor your code anymore by fear of having to rewrite the tests as well" It's exactly the opposite, when you write the tests in the real, good, manner: you continuously are grateful to yourself that wrote that tests *before* start refactoring such a bunch of code. - "upgrading to a new major version of a library will break all the tests because you now need to re-mock everything from this library." Why should break all tests? Only if you *heavily modified the functionality exposed by your API*. Are you sure you really want that? You are broking such a lot of contracts, and good written test are advising you. Implementing something in the wrong manner shouldn't be an excuse on blaming years and years of developers using something with profit.

1

Calling all Rails developers! 🛤️ Want to learn efficient techniques for handling errors in your Rails applications? We're thrilled to announce that the recording of Talysson Oliveira's presentation at RailsConf 2024 is now available. 👉 Watch it here: https://lnkd.in/dNSuid5p Thank you to everyone who joined us at RailsConf, and a special thanks to the organizers for making this event possible. Don't forget to share your key takeaways in the comments below! #Codeminer42 #RailsConf2024 #Rails #ErrorHandling #RubyOnRails #SoftwareDevelopment #Innovation #DeveloperTraining

16

Check out our newest BLOG! "How to implement validation with captcha" by our own David Moreira! .NET Developers will find this very interesting and useful for their work with .NET and Blazor tech as we learn new things every day! https://lnkd.in/dPWvC3Wv #blazor #components #blazorise #dotnet #csharpdotnet #programming #opensource #development

22

How to build a Monolith that does its job well: * Create internal contracts and separation of concerns * Organize your code to allow for parts of the system to be worked on in isolation * Pay attention to application performance metrics and move expensive operations to the background * Figure out horizontal scaling early, before you need it * Watch your slow query log and keep your database healthy * Don't be afraid to use multiple data stores to avoid overloading a single one * Create strong conventions to keep the codebase consistent Oh, and make sure it's doing something people want because efficiently doing something no one cares about is pointless.

3

Zillow on Codeium 🎉 Why Codeium? Zillow cites: - Personalization that works with their source code management - Detailed telemetry & analytics - IDE compatibility, for example with XCode - SSO support Some select quotes: - "From some quick testing I just did, it’s clear that for my work (iOS in Xcode), Codeium is way better than other tools we have looked at. I suspect that’s just a function of the tooling being a bit more mature" - "For me it’s been a big help in ramping up to learn new technologies and codebases … Since around the time I joined, Zillow adopted using Codeium which made the learning curve a lot easier for someone who’s new to the job." We are proud to have been supporting Zillow's development for the last 6 months, and look forward to continuing to make them more and more successful with Codeium. Read the full case study: https://lnkd.in/dpkV49Bb

65

3 Comments

Most companies struggle to hire killer senior engineers. So what should the ideal interview process for finding this talent look like? Whenever I advise early-stage tech startups, I tell them to include the following questions and steps in their interview process for senior engineers: 1. Have them interact with stakeholders in the company You need proof that a senior engineer can work well with stakeholders. They must be able to delegate and empower engineers to make various decisions. Any engineer who can communicate well and work with stakeholders is a solid hire. 2. Have them speak to a designer or product manager Senior engineers will be speaking to designers and product managers frequently. If you can get a designer or product manager involved in the interview process, you want your colleague to assess whether that engineer is someone they can work with. Some questions they can think about include: - Can I have a conversation about what’s valuable to the business with this engineer? - Can this engineer communicate well? Do they complicate things? Do they oversimplify? - How do they react if there’s an ask from design or marketing? What is their thought process? 3. Figure out their attitude toward junior engineers A senior engineer’s attitude toward junior engineers is a good bellwether of their attitude toward communication and documentation. One sign of a poor senior engineer is someone who can’t explain their work — or doesn’t feel like they have to. They feel no need to document what they’re doing and they assume everyone around them, like their junior engineers, will just get it. If you ask an engineer, “How do you communicate your work to others?”, and they say “I don’t really see the value in that,” that’s not someone you want to hire. It’s incredibly important to an early-stage organization to prioritize clear documentation and communication. I’ve advised too many companies that did this too late and had to waste time parsing the code of engineers who didn’t bother to document anything. Any startup can avoid this fate by hiring good senior engineers who explain their work every step of the way. 4. Figure out how they plan for the future Developing a good product isn’t just about good design or code. It’s also about future-proofing your code. I think a big thing about seniority is balancing making good decisions quickly while not shooting yourself in the foot. It means seeing beyond the future and recognizing the implications of their decisions, such as: - Is this code future-proofed or not? Am I creating technical debt? - Has this particular solution created any new problems for the team? Who knows how to solve them? Am I the only one who knows? You especially don’t want your company to deal with technical problems that can only be solved and documented by one person on the team. That can lead to a crisis if that person ends up leaving. cont. 👇

3

1 Comment