Ahmed Chisty

isNaN is an abomination and insult to common sense. If you care about clean code, then you can't do it with JavaScript Robert C. Martin's Clean Code: A Handbook of Agile Software Craftsmanship: Chapter 2: Meaningful Names "Avoid negatives in names." This is directly relevant to the isValid vs. isNotValid discussion. Negative logic can confuse readers and lead to mistakes, especially when combined with negations in code (e.g., if (!isNotValid)). ... And to top of it all isNaN(null) will return false, meaning null is not is not a number or null is a number. And as soon you mention this crime to some JavaScript lover, they will say something like ackchyually that is semantically correct... And as soon they say something like the word "semantically," you know they are full of it. How on earth JavaScript got where it is today? That's my rant for today.

42

25 Kommentare

Using JPA as it should requires a PhD. in wizardry. Another nice alternative to JPA besides jOOQ is spring-data-jdbc. Probably a bit closer to what the average dev is now doing with spring-data-jpa. A big plus is that spring-jdbc truly advocates #DDD

1

Scenario-based interview questions for Angular: Scenario: You need to build a large-scale enterprise application with multiple modules. Question: How would you structure your Angular application to ensure scalability and maintainability? Scenario: You are tasked with integrating a third-party library that isn’t natively supported by Angular. Question: How would you go about integrating this library? Scenario: Your Angular application needs to be upgraded from an older version to the latest version. Question: What steps would you take to upgrade your Angular application?

1

In the software industry, #QA professionals sometimes refer to themselves as "bug hunters"! Is that true? 🤔 The story of the term "bug" originated from a real event in 1947. Engineers working on the Harvard Mark II computer found a moth trapped in a relay, which was causing a malfunction. Grace Hopper, one of the pioneering computer scientists, famously documented this in her logbook, labeling the issue as a "bug." As for QA professionals referring to themselves as "bug hunters", this is more of an informal industry term and part of the #QA #culture in #software #development. Many QA testers adopt this phrase due to their role in identifying and fixing errors in software. 👇 https://bit.ly/4dLwy9U 👇

22

4 Kommentare

In my experience, integrating APIs on the frontend requires careful attention to several key practices to ensure a smooth and efficient user experience: Loading and Empty States: Implement loading and empty states wherever API calls are made to provide users with appropriate feedback while data is being fetched. 1. Form Validations: Ensure proper form validations to maintain data integrity. Formik is an excellent tool for handling this effectively. 2. Number Inputs: Prevent special characters in number inputs by using regular expressions to enforce proper input formatting. 3. Error Handling: Provide meaningful feedback to users when errors occur, guiding them to resolve issues or understand what went wrong. 4. Dynamic Data Rendering: Anticipate potential API failures or undefined responses when rendering dynamic data on the frontend. Write resilient code that gracefully handles such scenarios. 5. Pagination: Use pagination for large datasets to load data incrementally, improving performance and user experience. 6. Debouncing API Calls: Implement debouncing techniques for API calls triggered by user input to reduce unnecessary calls. For example, debounce search API requests to enhance efficiency. By adhering to these practices, you can build robust and user-friendly frontend applications that handle API integrations seamlessly.

4

𝑯𝒐𝒘 𝒕𝒐 𝑬𝒙𝒆𝒄𝒖𝒕𝒆 𝑴𝒊𝒄𝒓𝒐𝒔𝒆𝒓𝒗𝒊𝒄𝒆 𝑴𝒊𝒈𝒓𝒂𝒕𝒊𝒐𝒏𝒔 𝑳𝒊𝒌𝒆 𝒂 𝑩𝒐𝒔𝒔 Microservices are an architectural design tailored for large-scale software systems, focusing on scalability, agile delivery, and graceful failure. While comparing them to monolithic systems is like comparing apples and oranges, we've observed a rush in software teams making hasty decisions about refactoring and migration. Sometimes, transitioning to microservices makes sense; other times, it doesn't. Nevertheless, if you find yourself in the midst of such a migration—one of the most complex types—you must ensure it's executed correctly to avoid a pile-up of technical debt. The hype of microservices often leads organizations to expect smooth transitions, but many face a reality of complex systems that are tough to manage. Signs like increased errors, soaring costs, and decreased stability in monolithic systems can trigger migration considerations. However, a full-blown switch to microservices isn't always the answer, and a more gradual, thoughtful approach might be appropriate. Effective migration goes beyond mere speed; it enhances system effectiveness. Relying on KPIs like feature turnaround time can mislead, as they don't fully capture the migration's effectivenss. Adopting microservices introduces significant challenges, including managing the intricacies of distributed systems and ensuring business transactions remain atomic. Routine operations such as integration testing and managing service unavailability become crucial. Moreover, implementing a 𝗿𝗼𝗯𝘂𝘀𝘁 𝗗𝗲𝘃𝗢𝗽𝘀 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆 is essential for orchestrating the multitude of independent services. A practical migration strategy like the 𝗦𝘁𝗿𝗮𝗻𝗴𝗹𝗲𝗿 𝗙𝗶𝗴 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 can be beneficial. This approach maintains the old system while gradually introducing microservices, thereby minimizing risks and maintaining stability throughout the process. 𝗜𝗻𝘁𝗲𝗿-𝗣𝗿𝗼𝗰𝗲𝘀𝘀 𝗖𝗼𝗺𝗺𝘂𝗻𝗶𝗰𝗮𝘁𝗶𝗼𝗻 (𝗜𝗣𝗖) adapters are critical in this transition, enabling seamless communication between components and ensuring operational coherence. Deep diving into the business domain to define clear boundaries and establish a common glossary is crucial. This helps avoid the pitfall of creating overly specific '𝗻𝗮𝗻𝗼 𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀' that add complexity rather than simplification. Effective monitoring and distributed tracing are also vital, as they track request movements between services and measure task execution times, providing essential insights for optimization and troubleshooting. With careful planning and execution, transitioning to microservices can significantly boost flexibility and scalability, ensuring the move enhances rather than burdens the organization. #Microservices #Architecture #Migration #SW #DevOps #Strategy

24

1 Kommentar

*Bracing myself for the response I might get for asking this* Software Engineers: Would you ever consider working on an EQUITY ONLY basis (ie no salary, just owning a portion of the business, the value of which would increase as it progresses and scales)? Assuming: - The product is really interesting and so is the work - The product is in the "tech for good" space and would be a really positive contribution to parts of society - Seed funding is confirmed to be coming with several backers keen & they will able to offer a salary in the near future - The product is super early stage, you would be writing the software from the ground up, but the concept, design and business model once funding is received are all solid I know that there will be many who would never consider this under any circumstances and I totally get why, but just curious to hear if any of you would if it was for a product you believed in enough? And would you look at it on a full-time basis or a part-time basis? It's something I got asked about and so I thought I would throw it out to Linkedin to see what you all think rather than assuming that I know the answer on your behalf. #startup #founder #softwareengineer

39

309 Kommentare

This has to be one of the best comments I've read on LinkedIn. Personally I believe TDD is important. But it requires you to know exactly what to build. Which means extensive planning before implementation. Which is both a good and a bad thing. A downside of TDD is that the tests you write are code. Code has to be maintained. Which adds extra effort. Anyways, this comment describes TDD in the best way possible IMO.

5

The most common JUnit4 TestRules in need of migration to JUnit5, based on a sampling of ~1000 OSS repos. This is #TechStackTransparency in action. Based on an #OpenRewrite FindTypes run. To run it yourself on Moderne: https://lnkd.in/enQ24YhS

30

1 Kommentar

𝐄𝐯𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐨𝐟 𝐒𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 1. Monolithic Architecture:   Structure: All application components are tightly coupled into a single unit.   Integration: Both frontend and backend exist within the same codebase.   Challenges: As the application grows, scalability becomes difficult, and maintenance becomes increasingly complex due to the interdependencies of components. 2. Frontend + Backend Separation (Hybrid Monolith):   Structure: The frontend and backend are separated into distinct layers.   Benefits: This approach allows for more flexibility in choosing frontend technologies and decouples the user interface from server logic.   Consideration: While the frontend is separated, the backend may still be monolithic, which can limit the overall scalability and flexibility of the application. 3. Microservice Backend + Monolithic Frontend:   Structure: The backend is divided into independent microservices, each handling specific functionality.   Benefits: This separation allows for better scalability, independent deployment, and the ability to update backend services without affecting the entire system.   Challenges: The frontend remains monolithic, which can still pose limitations on scaling and may create bottlenecks in the development process. 4. Micro Frontends + Microservices:   Structure: Both the frontend and backend are divided into smaller, independently deployable units.   Benefits: This architecture promotes parallel development, technology diversity, and full decoupling of the system, making it highly modular and scalable.   Agility: Teams can work on different parts of the application simultaneously, enhancing overall development speed and flexibility.   Considerations: This hybrid approach, combining microservices on the backend with micro frontends, provides the highest level of independence and scalability. However, it also requires careful planning and management to ensure that all parts of the system integrate smoothly. Conclusion:  The evolution of software architecture reflects a move towards more modular, scalable, and maintainable systems. The choice of architecture should be guided by the specific needs and constraints of the project, such as size, complexity, and longterm goals. By understanding these different architectural patterns, organisations can better adapt to their requirements and deliver more robust and agile applications. Please let me know in comment DId i miss anything ,?

882

26 Kommentare

To implement bulk transactions with a RESTful CRUD API using #PostgreSQL and #SpringBoot, you can leverage Spring Data JPA for database interaction and Spring Data REST to expose your JPA repositories as RESTful endpoints. #PostgreSQLPerformance @MinervaDB #dba https://zurl.co/flpa

1

🌟 Trend Alert: Playwright Automation in Germany 🌟 🚀I'm excited to share that my latest project involves Playwright for automation testing, and it aligns perfectly with a growing trend I'm seeing in Germany! 🇩🇪. According to TheirStack, numerous companies in Germany are leveraging Playwright for their automation projects.🚀 GitHub Repository: https://lnkd.in/dm33Y93w 🎉 Here are some of the key implementations and features I worked on: 🔹 API Testing with Playwright: Handling GET, POST, PUT, PATCH, DELETE requests. 🔹 Playwright Page Object Model: Implemented login scenarios. 🔹 Slow Motion and Video Recording: Enhanced test visibility and debugging. 🔹 Web Elements and Assertions: Ensuring accurate test validations. 🔹 Trace View: Utilized for detailed test run insights. 🔹 Test Recording: Simplified the process of capturing test workflows. 🔹 Cross Browser Runs: Ensured compatibility across multiple browsers. 🔹 iPhone 11 Automation: Mobile device automation capabilities. 🔹 Form Automation: Automated form interactions and submissions. 🔹 Hooks: Used beforeAll, beforeEach, afterAll, afterEach for test setup and teardown. 🔹 Groups: Organized tests with describe blocks. 🔹 Annotations: Managed test flows with only, skip, skip with condition, fail, fixme, slow. 🔹 Tags: Categorized tests with @smoke. This project was a fantastic journey into the capabilities of Playwright and its robust automation features. Looking forward to leveraging these skills in future projects! 🚀 #Playwright #AutomationTesting #QA #Testing #WebDevelopment #SoftwareTesting

34

RabbitMQ VS Redis Queue Which one is right for your specific application requirements? RabbitMQ is the recommended choice for scenarios that demand complex routing, persistent messages, and advanced messaging patterns. With features like acknowledgments and message durability, RabbitMQ excels in reliable message delivery, making it suitable for high-throughput scenarios. Additionally, RabbitMQ offers SSL support for data encryption, clustering, and various messaging patterns. On the other hand, Redis is faster than RabbitMQ but lacks robust persistence features and security options. It processes messages primarily in memory, making it ideal for scenarios requiring fast message processing with short retention periods where persistence is not critical. However, Redis risks losing unread messages if the server fails and has limited security options compared to RabbitMQ. In conclusion, choose Redis if your primary need is fast data access and caching or require a simple pub/sub mechanism. Opt for RabbitMQ if your application demands reliable and complex message queuing and routing, especially in a distributed microservices architecture. Remember, the choice between the two depends on the specific requirements of your application. #redis #rabbitMq #microservice #microservicearchitecture

16

1 Kommentar

🚀 Software Engineering Tip: Write Code That Lasts! 👩‍💻👨‍💻 "Code is read far more often than it is written." 🧑‍🏫 This gem from Robert C. Martin's Clean Code reminds us of one golden rule in software engineering: Write code as if the next person maintaining it is a time-stressed developer who knows where you live! 😅 Here’s how to make your code future-proof: ✔️ Name Variables Wisely: totalAmount > x. Let the code speak for itself! ✔️ Keep It Simple: Clever code looks cool but simple code gets the job done (and understood). ✔️ Comment Thoughtfully: Explain the "why," not the "how" — your code shows the "how." ✔️ Stay DRY: Avoid repetition. One well-placed function > the same logic copy-pasted 10 times. ✔️ Test, Test, Test: Bugs found by your tests won't haunt your production servers later. 💡 Remember: Future-you or some fellow developer will thank you for clarity over cleverness! Drop your thoughts below 👇 How do YOU make your code easier to maintain? Let’s share ideas and grow together! 🌟 #SoftwareEngineering #CodingTips #CleanCode #DeveloperLife

3

Monoliths favored over Microservices! That was Gergely Orosz's prediction we acknowledged and talked about last Monday Here is my take on it broken down by engineering headcount . 👉 Small engineering HC Calm down and consider the TCO of investing in a Microservices architecture... here are the regular options: - Build #Monoliths and (maybe) a few services - Build more services *if* you have odd non-functional requirements like preparing for a large customer base besides being a small team . 👉 Big engineering HC (50+) Big engineering HC at efficiency era — you're profitable, right? Let's go with *two* usual scenarios: . 1️⃣ - Already investing towards #Microservices Please have a look at the screenshot attached to this post (from State of #DevOps 2023 report) ✨ Loosely coupled architecture is an all-star technical capability according to #DORA research ✨ Continue the investment and also consider other capabilities that might leverage higher DORA scores into #business #outcomes . 2️⃣ - Fully invested in Monoliths Happy to have an engineer from Shopify or Stack Overflow engaging with my content — please drop me a DM and let's chat 😆 -- 👋 Hey, tech exec! One quick question: — Have you been able to invest in the largest and longest-running IT research program and discover how to translate their findings into business outcomes? May I help you go through that?

6

3 Kommentare

1/10 Truths in #DistributedSystems Design applied to #ReactiveDDD: "It’s Never Just Two Boxes and a Line!" This truth highlights the risk of oversimplifying the complexity of Distributed Systems. Emergent behaviors are inevitable in such systems, making principles like modeling uncertainties crucial. It's not about achieving absolute control (e.g., deduplication or reordering) but about embracing disorder and designing systems to adapt rather than resist it. In #ReactiveSystems, bounded contexts often interact with multiple others through events. Explicitly modeling this communication is essential, as complexity stems from network latency, failures, and non-linear data flow. Reactive #DomainDrivenDesign (DDD) emphasizes bounded contexts and clear boundaries. What may appear as "just two boxes" actually represents intricate systems engaged in asynchronous collaboration. Subdomain decomposition in #DDDesign further acknowledges this complexity. Each service and its interactions reflect a model specific to the domain, going beyond mere connections to represent purposeful, tailored design. -- inspired by Gregor Hohpe's "10 Truths in Distributed Systems Design" #Microservices #EventDriven #EventDrivenArchitecture #EventSourcing

17

Get started with Testcontainers for meaningful integration tests for your Spring Boot application 🍃 This tutorial covers a first introduction to the Testcontainers library and how you can manage Docker containers with it 👇🏻 https://lnkd.in/dvAvg7SA

11

You always wanted to learn TDD but don't know where to start? Then let me break it down for you: 1️⃣ Learn the TDD cycle To write code with TDD, you need to go through three design phases, repeatedly in iterations. The three phases are: 1. Red: Write a failing test 2. Green: Make the failing test pass 3. Refactor: Improve the design and clean up the code, including your tests as well 2️⃣ Learn the three laws of TDD These are the fundamentals of TDD. They constrain us to change only one thing at a time. They force us to take baby steps. The three laws are: 1. Always start with a failing 2. Stop writing your test as soon as it fails or doesn't compile 3. Stop writing production code as soon as the test passes Memorize and strictly follow these laws when doing the TDD cycle. 3️⃣ Get started with Kata exercises Greatness comes from practicing. Katas are small coding exercises focusing on small problems. They are excellent for deepening the fundamentals of TDD. Pick a Kata exercise then start practicing the TDD flow! You can find many Katas here: https://lnkd.in/dY6YnWGP 4️⃣ Apply TDD on a real-life project After learning the fundamentals, it is time to use TDD on real-life projects. Some tips: - Clarify the requirements before writing tests - Start small - write a test for a simple function you want to implement - Strictly follow the TDD cycle, don't skip any phases 5️⃣ Don't neglect quality testing practices TDD won't work if you can't write clean tests. So in parallel, make sure you have strong fundamentals in writing quality tests, including the 5 test doubles, knowing the code smells, and writing easily maintainable tests. That's it. If you want to know WHY you need TDD, check out my post: https://lnkd.in/dnGdAJR7 Enjoy! 🙏

622

53 Kommentare