Rajat Malik

In a recent project, I implemented the Strategy design pattern to handle data downloads in multiple file formats. Specifically, I developed a FileDownloadStrategy interface with a download method to facilitate the downloading of data in Word and PDF formats. To manage the different strategies, I created concrete classes for each format—PDFDownloadStrategy and WordDownloadStrategy. Furthermore, to dynamically select the appropriate strategy based on the content type specified in the API request, I designed a factory method. This approach not only streamlined the process of downloading files in varying formats but also enhanced the system's flexibility and maintainability by decoupling the file downloading capabilities from the main application logic.

3

The 4 most common design patterns used in LLD interviews are: Strategy pattern, Observer pattern, Factory pattern and Singleton Pattern. In below blog I have written about these design patterns and their use cases from LLD interviews https://lnkd.in/dJh4hY-3

3

I have used GraphQL for 3 years extensively & along the way I realised there are a few misconceptions around it 1. GraphQL is a protocol - No its not a protocol. Its just a convention on top HTTP protocol as REST is. - In fact its a trimmed down version of REST where every request is a HTTP POST and all responses are HTTP 200 regardless of whether your backend was able to successfully do the operation or had encounter runtime error/unhandled exception or was able to complete transaction to DB. - It help you by taking away some of the very common logic from backend viz to paginate your data, push new data to client as its available to avoid polling from client, filter out data based on what all fields were requested by client - I also takes away complex type/input payload validation and authorisation to certain extent if you are leveraging GraphQL decorators for the same which can be reused in multiple places on GQL server side. 2. It makes your APIs performant and secure - No it does not make APIs performant nor does it make your apis secure - it just helps you with fetching related data in one go and in parallel of you write your resolvers in that way. But if your db is the major bottolneck then you wont see performance benefits of using GraphQL - If you dont have field level authorisation you application is prone to data leak as hacker can simply take a look at browser dev tool and guess what other data they can fetch and in that process you may end up leaking PII data of your users. When is GraphQL useful? - The main purpose of graphql is to fulfill many different data requirements that can arise based on UI/UX design and user feedbacks. - Viz on facebook when you are on your profile, facebook shows you all your friends list and count of mutual friends between you and each of friend on list. - but when you are visiting a users profile, facebook shows you only list of mutual friends and count of mutual friends between you and the friends profile you are on and the person listed in the list. - To fulfill these two requirements the backend most likely will be interactinog with same data sources just the filtering logic will change. so such cases makes it easy on UI as well on backend if written as graphql apis When should you not choose graphql? - When you know you always want to respond with certain amount of fixed set of data. like in authentication you always want to respond with id_token, access_token and request_token in majority of cases - When you dont have requirement of displaying many permutation/combination of tightly related entities. Like books by authors, authors by books, count of books by authors, books by publication and author etc. - You should not use GraphQL for authentication. Your authentication better be on REST as it will help you debug any authentication related issues just based on HTTP response status

46

1 Comment

🚀 Understanding API URLs: A Quick Guide Ever wondered how to break down and understand an API URL? Let's take a closer look at an example URL and dissect its components: 🔗 Example URL: `http://localhost:3000/sampleAPI/v1/products/productsId/services/subService/:subServiceId` ❓ Question: How do you break down and understand this URL? ✅ Answer: 1. 🌐 Protocol: `http` - This indicates the protocol used for communication. 2. 🏠 Host: `localhost` - This is the domain name or IP address of the server. `localhost` refers to the local machine. 3. 🔢 Port: `3000` - This specifies the port number on the server where the application is running. 4. 🛣️ URI Path: `/sampleAPI/v1/products/productsId/services/subService/:subServiceId` - This is the path that specifies the resource on the server. Let's further break down the URI Path: - 🛤️ Base Path: `sampleAPI/v1` - This typically represents the main module or service and the version of the API. - 📦 Controller: `products` - This part of the path indicates the specific controller handling the request. - 🗂️ Resource Path: `productsId/services/subService` - This part of the path specifies the hierarchical structure of resources. Here, it seems to be referring to specific products, their services, and sub-services. - 🔄 Path Variable: `:subServiceId` - This is a placeholder for a specific sub-service ID that will be provided when making the request. 🆔 URN (Uniform Resource Name): - A URN is a unique and persistent identifier for a resource, independent of its location. Unlike URLs, which provide a way to locate a resource, URNs provide a way to uniquely identify a resource. In this context, `productsId` and `:subServiceId` can be considered as parts of a URN, uniquely identifying specific products and sub-services within the system. 📝 Summary: - 🌍 Full URL: `http://localhost:3000/sampleAPI/v1/products/productsId/services/subService/:subServiceId` - 🌐 Protocol: `http` - 🏠 Host: `localhost` - 🔢 Port: `3000` - 🛤️ Base Path: `sampleAPI/v1` - 📦 Controller: `products` - 🗂️ Resource Path: `productsId/services/subService` - 🔄 Path Variable: `:subServiceId` - 🆔 URN: Unique identifiers like `productsId` and `:subServiceId` This URL is structured to access a specific sub-service within a product, where `:subServiceId` will be replaced with the actual sub-service ID when making the request. Understanding these components can help you navigate and utilize APIs more effectively. Happy coding! 😄👨‍💻

7

**LinkedIn Post:** **System Design Challenge: Real-Time Ride-Sharing Platform** **Problem Statement:** Design a scalable system for a real-time ride-sharing platform similar to Uber or Lyft. The platform should efficiently match riders with drivers in near real-time, ensure low latency for ride requests, and handle peak traffic smoothly. Key features include: 1. Real-time location tracking for drivers and riders. 2. Efficient driver allocation based on proximity and availability. 3. Scalable architecture to handle millions of concurrent users. 4. Dynamic pricing for surge times. 5. Robust data storage and retrieval for ride history and user profiles. 6. Reliable payment processing and transaction logging. **Solution:** To tackle this problem, we can leverage a microservices architecture to ensure scalability, fault tolerance, and maintainability. Heres a high-level overview of the system design: 1. **Microservices Architecture**: Split the system into microservices such as User Management, Ride Matching, Location Tracking, Payment Processing, and Pricing. This allows easy scaling and independent deployment. 2. **Data Storage**: Use a mix of databases to cater to different needs. A NoSQL database like MongoDB or Cassandra for user profiles and ride history, an in-memory data store like Redis for transient data like current ride status, and a relational database like PostgreSQL for transactions and payment logs. 3. **Real-time Communication**: Utilize WebSockets or gRPC to maintain persistent connections with clients for real-time tracking and updates. This reduces latency and enhances the user experience. 4. **Load Balancing & Scaling**: Employ cloud-based load balancers (e.g., AWS Elastic Load Balancing) and auto-scaling groups to handle varying traffic loads efficiently. This ensures stability, especially during peak demand. 5. **Dynamic Pricing Algorithm**: Implement a machine learning model to adjust pricing based on factors like demand, supply, location, and time. This helps in managing surge pricing and driver incentives. 6. **Efficient Matching**: Use geospatial indexing and algorithms to quickly match riders with the nearest available drivers. This can be further optimized with predictive analytics to pre-position drivers in high-demand areas. 7. **Monitoring & Logging**: Deploy robust monitoring using tools like Prometheus and Grafana for system health and reliability. Use centralized logging with tools like ELK Stack for debugging and auditing. By designing a system with these components, we build a platform that is robust, scalable, and capable of offering a seamless service to both drivers and riders around the clock. #SystemDesign #Architecture #RideSharing #Microservices #Scalability #RealTime #Uber #Lyft

1

𝗧𝗵𝗲 𝗯𝗲𝘀𝘁 𝟭𝟬 𝗥𝗲𝗽𝗼 𝗼𝗻 GitHub 𝗳𝗼𝗿 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗣𝗿𝗲𝗽𝗮𝗿𝗮𝘁𝗶𝗼𝗻 𝟭- 𝗧𝗲𝗰𝗵 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗛𝗮𝗻𝗱𝗯𝗼𝗼𝗸 Curated coding interview preparation materials for busy software engineers. Repo Link: https://lnkd.in/dNwgUhAF 𝟮- 𝗦𝘆𝘀𝘁𝗲𝗺 𝗗𝗲𝘀𝗶𝗻𝗴 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 This repository has outlined all the System Design concepts in an easily understandable way. This repo is an organized collection of resources to help you learn how to build systems at scale. Repo Link: https://lnkd.in/dX7pfnv4 𝟯- 𝗝𝗮𝘃𝗮𝘀𝗰𝗿𝗶𝗽𝘁 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 List of 1000 JavaScript Interview Questions & Answers. Repo Link: https://lnkd.in/dcdjZsn4 𝟰- 𝗥𝗲𝗮𝗰𝘁𝗷𝘀 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 List of top 500 ReactJS Interview Questions & Answers. Repo Link: https://lnkd.in/d7isimkv 𝟱- 𝗩𝘂𝗲𝗷𝘀 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 List of 300 VueJS Interview Questions & Answers. Repo Link: https://lnkd.in/dVXiz_Nh 𝟲- 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 List of 300 Angular Interview Questions & answers. Repo Link: https://lnkd.in/dbfh42ji 𝟳- 𝗡𝗼𝗱𝗲 𝗷𝘀 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 List of Node Js Interview Questions & answers Repo Link: https://lnkd.in/dEwii8ag 𝟴- 𝗔𝗦𝗣.𝗡𝗘𝗧-𝗶𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄-𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 List of 500 ASP.NET MVC Interview Questions & answers. Repo Link: https://lnkd.in/d35u93N3 𝟵- 𝗔𝘄𝗲𝘀𝗼𝗺𝗲 𝗜𝗻𝘁𝗲𝗿𝘃𝗶𝗲𝘄 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 A curated awesome list of interview questions and All Programming and Technologies. Repo Link: https://lnkd.in/gtZV7SkJ 𝟭𝟬- 𝗧𝗵𝗲 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝘀 Algorithms and Data Structures implemented in all Languages for beginners, following best practices. Repo Link: https://lnkd.in/dDjtxsx9 Don't miss to follow Mohamed Hashem to get more #datastructures #github #algorithms #javascript #cs #interviews #reactjs #software #tech #project #reactjs #coding #programming #nodejs #angular #vuejs #js #aspnet #aspdotnet #systemdesign

305

13 Comments

Here is a step-by-step process to pick apart any low-level design question. ----- 𝑆𝐷𝐸 1+ ----- 𝟏. 𝐒𝐂𝐎𝐏𝐄 𝐓𝐇𝐄 𝐏𝐑𝐎𝐁𝐋𝐄𝐌 As you speak with the interviewer, you may list 5-10 requirements for the question. You cannot satisfy these requirements in 45 minutes. Decide on what is important to the system. Pick JUST ONE important requirement, and start with it. The rest can be picked later, if time permits. 𝟐. 𝐋𝐈𝐒𝐓 𝐓𝐇𝐄 𝐀𝐏𝐈𝐬 𝐅𝐈𝐑𝐒𝐓 Users interact with the system using APIs. That's what matters most. Name the APIs sensibly. Walk through how a user will use these APIs to meet the given requirement. Example: In a booking system, how does a customer temporarily lock, pay for, and permanently book a seat? They do it using APIs. Your job is to explain the request flow and interactions. 𝟑. 𝐍𝐎𝐖 𝐃𝐄𝐅𝐈𝐍𝐄 𝐓𝐇𝐄 𝐎𝐁𝐉𝐄𝐂𝐓𝐒 List the request and response parameters. Most of your system's objects will surface here. At this point, you can write the skeleton code, with objects and services. ----- 𝑆𝐷𝐸 2+ ----- 𝟒. 𝐂𝐎𝐍𝐒𝐈𝐃𝐄𝐑 𝐂𝐎𝐍𝐂𝐔𝐑𝐑𝐄𝐍𝐂𝐘 You won't be expected to code a concurrent system. But you will be expected to talk about "how will this system handle concurrent requests?" The usual problems with concurrency are dirty reads and out-of-order processing. Even identifying these problems (without a clear solution) is a big green flag. ----- 𝑆𝐷𝐸 3+ ----- 𝟓. 𝐂𝐎𝐍𝐒𝐈𝐃𝐄𝐑 𝐓𝐄𝐒𝐓 𝐒𝐔𝐈𝐓𝐄𝐒 A system is going to have edge cases. It's the tricky ones that matter most. Noting edge cases, and adapting the system to solve them, is a clear green flag. 𝟔. 𝐂𝐎𝐌𝐌𝐔𝐍𝐈𝐂𝐀𝐓𝐄 𝐂𝐎𝐍𝐒𝐓𝐀𝐍𝐓𝐋𝐘 Walk your interviewer through the code while you write it. You don't need to say everything on your mind, but you DO need to explain everything that's important. In general, over-communication is harmless. Undercommunication leads to confusion. ----- 𝑅𝑒𝑠𝑜𝑢𝑟𝑐𝑒𝑠 ----- 1. Read your writes: https://lnkd.in/dJYZ3Z_7 2. Asynchronous Processing with Futures: https://lnkd.in/d55-j-G8 3. Request Collapsing: https://lnkd.in/dFbJmwJC 4. What are threads? https://lnkd.in/dF4q9ez2 5. Event Bus Publishers and Subscribers: https://lnkd.in/dcciJ4vM 6. Classes and package structuring: https://lnkd.in/dqagPDG9 7. Dependency Inversion: https://lnkd.in/djU2uw4K #SystemDesign

514

7 Comments

 𝗔𝗿𝗲 𝗮𝗻𝗶𝗺𝗮𝘁𝗶𝗼𝗻𝘀 𝗴𝗼𝗼𝗱? This elegant, seamless animation shared in the post below is very appealing. But is it comforting when users are browsing the site and toggling between pages multiple times, especially on a site like Airbnb? Such intense animation will surely cause discomfort to motion-sensitive people. Especially for a travel app, when users are walking or moving in a vehicle if they constantly see these animations for a long duration, they may experience motion sickness. 𝗗𝗼𝗲𝘀 𝘁𝗵𝗮𝘁 𝗺𝗲𝗮𝗻 𝗮𝗻𝗶𝗺𝗮𝘁𝗶𝗼𝗻𝘀 𝗮𝗿𝗲 𝗻𝗼𝘁 𝗴𝗼𝗼𝗱? In my opinion, animations are beneficial when you are trying to convey an experience or tell a story about your product. However, if your website or app provides a large catalogue of items where users are expected to browse through many options before making a purchase, then it is not a good decision to have animations on your website. Be very particular when adding animations to your website. While animations might enhance the look and feel and make your site very appealing, they might also impact the overall interactive time on your website, which you definitely want to increase. Some supporting research says: 1. 𝗗𝗶𝗴𝗶𝘁𝗮𝗹 𝗘𝘆𝗲 𝗦𝘁𝗿𝗮𝗶𝗻 (𝗗𝗘𝗦): Prolonged use of digital screens, including viewing animations, can lead to digital eye strain (DES), characterized by symptoms such as dryness, irritation, blurred vision, headaches, and difficulty focusing. This is especially prevalent among individuals who use computers and smartphones extensively. 2. 𝗠𝗼𝘁𝗶𝗼𝗻 𝗦𝗲𝗻𝘀𝗶𝘁𝗶𝘃𝗶𝘁𝘆: Users with motion sensitivity can experience discomfort and even nausea from intense animations. This is particularly problematic for applications used in dynamic environments, such as travel apps, where users might be on the move and more prone to motion sickness. 3. 𝗜𝗺𝗽𝗮𝗰𝘁 𝗼𝗻 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝘃𝗶𝘁𝘆: Digital eye strain affects comfort and reduces productivity and accuracy in tasks performed on digital devices. Continuous exposure to animations and other dynamic elements can exacerbate these issues. 4. 𝗗𝗲𝘀𝗶𝗴𝗻 𝗥𝗲𝗰𝗼𝗺𝗺𝗲𝗻𝗱𝗮𝘁𝗶𝗼𝗻𝘀: To mitigate these effects, it is advised to use animations sparingly and strategically. Simple and purposeful animations that enhance user experience without overwhelming them are recommended. Additionally, providing users with options to reduce or disable animations can help cater to those who are sensitive to motion. #UserExperience #WebDesign #UXDesign #MotionSensitivity #WebDevelopment #Accessibility #TechHealth #Productivity #TechTips #WebAccessibility #DesignThinking #UserComfort #WebAnimation

17

This really showcases the power that cloud-based IDEs can eventually provide the rest of the world, outside of Big Tech. Google, much like other large companies has tons of internal tooling for build systems (similar to Bazel or Buck), caching, version control, virtual file systems, dependency management, containerization, logging and monitoring, etc. Making tools like this more accessible outside of these companies with less maintenance required (meaning less engineering resources for tool development and maintenance) will be exponentially more powerful for engineering delivery as a whole. We are seeing this within many tools from GitHub, AWS, StackBlitz, GitPod, and many others. We are also seeing many Open-Source Build tools for monorepo management that rival these companies, such as Nx.dev, Turborepo by Vercel, Pants, Buck and Bazel. Docker and K8s has enabled containerization and scaling across the world via a single machine or multi-region + multi-cluster deployment strategy. We are now also seeing tech like WASM enter the space for building near-native applications that run in the browser. Soon, native desktop apps and developer experience will fully be automated by the cloud and I am excited to see this. #softwareengineering #devops #buildsystem #tooling

1

The fastest and most fun way to get better at system design (both HLD & LLD) is to actually build things. While preparing for interviews, I've seen most people consuming videos and articles to improve their understanding of system design. However, have you ever thought that you can learn most (probably not all) of these skills and concepts by building something that's production scale? When I say production scale, I mean production scale. Build something that has live users or is designed for live users. Solve their pain points. Iteratively evolve the system. You will organically watch all the system design concepts mentioned in the videos and books come to life as you implement stuff. Most importantly, the problems you will end up solving won't demand textbook solutions but innovative extensions or adaptations of existing solutions. Think of building a newsletter, an API platform, or a SaaS tool and develop features like subscription tiers, rate limiting and authentication! At work, one useful tip is to do "concept recall" during brainstorming sessions. Identify general problems in the software domain that correspond to the problem everyone is discussing and think of applying standard patterns and principles. Rework these principles and patterns from first principles and come up with unique solutions! Don't forget to write down your research somewhere! Have you tried learning system design by building things? Let me know your experience in the comments section! ✨ #SoftwareEngineering #SystemDesign

2

Launching new series on Youtube - Chakde Frontend Interview 🚀 - Session 2 of "Chakde Interviews". This series will contain frontend interviews for all rounds - Javascript, React, Machine Coding, System Design, etc. Video link in the comment 👇. In case you want to give a mock interview, please do comment below 👇 Thanks for all your love & support till now.❣️ Trust me this series will be one of the best resources on the internet to prepare for frontend interviews ✅ Let's make this series viral together 🔥 #interview #frontend #javascript

424

20 Comments

LeetCode coding questions ≠ Real-world coding challenges. . Many tech companies use LeetCode-style questions in their interviews. 📌 On one hand, they help interviewers see how you think through complex problems. But on the other, they do not reflect real-world situations like collaborating with others, designing, and dealing with existing codebases. So, instead of running after LeetCode problems, try this: → ⁠Learn algorithms: Don’t memorize answers—try to understand how and why the algorithms work. This will help you solve new problems. → ⁠Spot patterns: Notice common patterns as they will help you pick the right approach quickly. → ⁠⁠Do mock interviews: Use platforms like Preplaced to practice with expert SDEs and get hands-on interview preparation. Connect with them for FREE here: https://lnkd.in/gK8KK_Jp They’ll share which what kind of questions to solve, patterns to focus on and areas to improve. → ⁠Review and improve your solutions: After solving a problem, review it and think about how you can make it faster and more efficient. While LeetCode-style questions are useful, it's important to balance them with practical coding skills. However, if you are struggling to improve your coding skills, you can always reach out to senior SDEs at Preplaced for 1:1 guidance. ✅ PS: How do you prepare for coding challenges? 💬 #leetcode #DSA #collab #preplacedcollab #codingrounds #techinterviews

1,411

28 Comments

Cracking DSA rounds is the only way to prove you are a top-notch software engineer. That's what many assume. But here's what they don't see: DSA (Data Structures and Algorithms) rounds are just one aspect of the skills required in the tech industry. It's a myth that mastering DSA is the ultimate validation to your capabilities. 🔍 What people are missing: The hard work and diverse skill set required behind the scenes. Most of the time, actual software engineering involves designing, developing, and maintaining robust systems rather than solving complex algorithmic problems daily. 💪 What you need to focus on: - Building practical software projects. - Learning and applying best practices in software development. - Continuously improving your design and problem-solving skills in real-world scenarios. Here's how you can balance DSA preparation with real-world skills step by step ⬇️ 🛠️ Step 1: Understand the Importance of DSA - While it may not be used daily, DSA helps in developing a logical approach to problem-solving, which is crucial. 🚀 Step 2: Develop Real Projects - Work on projects that interest you. It could be anything from web development to mobile apps. This showcases your practical skills. 👨‍🏫 Step 3: Join Communities and Contribute - Engage with coding communities, participate in hackathons, and contribute to Open Source Projects. Networking and hands-on experience are invaluable. 📚 Step 4: Keep Learning - Technology is always evolving. Stay updated with the latest trends, tools, and technologies. Take online courses, attend workshops, and read industry blogs. 🌟 Step 5: Practice Coding Interviews - While real-world experience is vital, practising coding interviews can help you ace the DSA rounds when needed. Every journey is unique. Your value as a software engineer isn't solely defined by your ability to crack DSA rounds. It's the combination of your problem-solving skills, practical experience, and continuous learning that sets you apart. What's your take on the importance of DSA in your software engineering journey? Share your thoughts below! #softwareengineering #careergoals #dsa #interviewtips #coding #techcareer

34

3 Comments

TCA 1.10.3 got released 🚀 What's Changed ⚒️ Automatically cancel in-flight TestStore effects when its root feature is dismissed. ⚒️ Propagate current dependencies to Store.init. ⚒️ Runtime warn when stack integration is detected to be missing from store's reducer. ⚒️ TestStore.finish() should assert against unreceived actions. ⚒️ Precondition when conflicting persistence keys must match value. If you have defined a custom persistence key, you may need to explicitly conform it to Hashable after upgrading to this version. ⚒️ @Shared no longer eagerly evaluates its initial value. 🏗️ Added a brand new tutorial: Building SyncUps. => https://lnkd.in/dzSj5DS3 🏗️ Add store invalidation test. 🏗️ Document @CasePathable @dynamicMemberLookup in 1.4 migration guide. 🏗️ Document nested enum reducers. PS: Please find the link to the full changelog in the comments. --- If you're looking to improve your TCA skills, check out my free interactive tutorial on TCA best practices: https://lnkd.in/dJHaxm4E

19

1 Comment

𝐅𝐫𝐨𝐧𝐭𝐞𝐧𝐝 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 𝐈𝐧𝐭𝐞𝐫𝐯𝐢𝐞𝐰 𝐆𝐮𝐢𝐝𝐞: Whether you're preparing for an interview or looking to refine your frontend development skills, understanding the foundational and advanced concepts is essential. Here's a quick overview of some important topics and tips: 1.𝐀𝐬𝐲𝐧𝐜𝐡𝐫𝐨𝐧𝐨𝐮𝐬 𝐎𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 𝐢𝐧 𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭 𝐭𝐡𝐞𝐧(): Used for chaining multiple calls for sequential execution. 𝐚𝐬𝐲𝐧𝐜/𝐚𝐰𝐚𝐢𝐭:Provides a cleaner, more readable way to handle asynchronous code by making it look synchronous. It simplifies error handling compared to traditional promises. 2. 𝐑𝐞𝐚𝐜𝐭 𝐂𝐨𝐦𝐩𝐨𝐧𝐞𝐧𝐭 𝐋𝐢𝐟𝐞𝐜𝐲𝐜𝐥𝐞 For class components, lifecycle methods include: constructor(), render(), componentDidMount(), componentDidUpdate(), componentWillUnmount(). For functional components, the useEffect hook is commonly used for side effects like data fetching after the initial render. 3. 𝐇𝐚𝐧𝐝𝐥𝐢𝐧𝐠 𝐂𝐎𝐑𝐒 𝐢𝐧 𝐖𝐞𝐛 𝐀𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧𝐬 Cross-Origin Resource Sharing (CORS) is a security feature that restricts requests to different domains. To handle CORS issues, configure your server to include headers like Access-Control-Allow-Origin in the response. 4. 𝐒𝐭𝐚𝐭𝐞 𝐌𝐚𝐧𝐚𝐠𝐞𝐦𝐞𝐧𝐭 𝐢𝐧 𝐑𝐞𝐚𝐜𝐭 𝐮𝐬𝐞𝐒𝐭𝐚𝐭𝐞: Ideal for managing simple state logic with a variable and a function to update it. 𝐮𝐬𝐞𝐑𝐞𝐝𝐮𝐜𝐞𝐫: Best for complex state logic involving multiple sub-values or dependent states. It uses a reducer function for state transitions. 𝐓𝐢𝐩𝐬 𝐟𝐨𝐫 𝐒𝐮𝐜𝐜𝐞𝐬𝐬: Understand the fundamentals of JavaScript, CSS, and HTML thoroughly. Practice with frameworks like React and tools like Node.js for backend integration. Familiarize yourself with modern development environments like Visual Studio Code and collaboration tools like Git. By mastering these concepts and practicing regularly, you'll be well-prepared for your next frontend development interview. credit: respective owner Follow Milind Gupta for more #frontend #react #development #interview #javascript #angular

201

13 Comments

Past Interview Experience on Redux Middlewares !! Interviewer: What happens in the Action Creator? Me: The Action Creator functions generate actions – these are plain JavaScript objects that describe what happened. For instance, it might look something like { type: 'INCREMENT' }. Interviewer: So, these actions need to go somewhere, right? Me: The actions are then dispatched to the Store. But before they reach the reducers, they pass through Middlewares. Interviewer: Middlewares, you say? What role do they play? Me: Middlewares is between the action dispatch and the reducers. They can intercept actions and perform tasks such as logging, making asynchronous API calls, or modifying actions before they reach the reducers. Essentially, they're like filters. Interviewer: So once the middleware is done with the action, what happens next? Me: Once the middleware processes the action, it's forwarded to the Reducers. The reducers are pure functions that take the current state and the action as arguments and return a new state based on the action. This is where the state transformation happens. Interviewer: And what does the new state do after the reducer updates it? Me: The new state is then stored in the Store. The store holds the entire state of the application. When the state updates, the view re-renders to reflect the changes. This closes the loop, showing the user the updated state. Interviewer: And what about the API call? Me: If an action involves an API call, middleware can handle that too. For instance, thunk middleware allows action creators to return functions instead of actions. These functions can perform asynchronous operations like API calls, then dispatch actions based on the results. Interviewer: So, to summarize, the flow goes from View to Action Creator, then through Middleware, to the Store, through the Reducer, and back to the Store, which updates the View. Did I get that right? Me: Perfect! You've got it. It's a continuous loop that ensures the state and view stay in sync. . . . . . If you find my explanation effective, give it a like, and share any observations or suggestions in the comments.     For more insightful content checkout below: 🟦 𝑳𝒊𝒏𝒌𝒆𝒅𝑰𝒏 - https://lnkd.in/dwi3tV83 ⬛ 𝑮𝒊𝒕𝑯𝒖𝒃 - https://lnkd.in/dkW958Tj 🟥 𝒀𝒐𝒖𝑻𝒖𝒃𝒆 - https://lnkd.in/dDig2j75 or Priya Frontend Vlogz 🔷 𝐓𝐰𝐢𝐭𝐭𝐞𝐫 - https://lnkd.in/dyfEuJNt #frontend #javascript #react #reactjs #html #css #typescript #es6 #interviewquestions #interview #interviewpreparation

334

15 Comments

🚀 The Growing Importance of System Design in Software Engineering Interviews for Germany 🇩🇪 In the ever-evolving landscape of software engineering, mastering system design has become a critical factor for those aspiring to advance their careers internationally, particularly in Germany. 🏆 As the demand for scalable, efficient, and robust software solutions continues to rise, companies in Germany are increasingly prioritizing system design skills during their interview processes. Here are a few reasons why this shift is happening and why it's essential for international software engineers: 1. Complexity of Modern Applications: Today's applications are more complex than ever, requiring engineers to design systems that can handle vast amounts of data and traffic seamlessly. German companies, known for their precision and quality, expect engineers to craft solutions that are both scalable and maintainable. 2. Integration of Advanced Technologies: With the integration of AI, IoT, and big data, having a solid understanding of system design principles ensures that engineers can effectively incorporate these technologies into their solutions, maintaining high standards of performance and security. 3. Collaboration and Communication: System design interviews often involve explaining and defending your design choices. This process not only evaluates technical proficiency but also communication skills—crucial for collaborating within diverse, international teams. 4. Future-Proofing Careers: As system design becomes a staple in technical interviews, engineers who invest time in honing these skills are better prepared for future opportunities, making them more competitive in the global job market. For those looking to make a move to Germany, investing in system design knowledge is more important than ever. Whether you’re designing scalable web services, architecting data pipelines, or developing fault-tolerant distributed systems, demonstrating your ability to think critically and design efficiently can set you apart in the hiring process. 🌟 Pro Tip: Practice by solving real-world problems, participate in system design discussions, and seek feedback from peers or mentors. Resources like mock interviews, online courses, and technical blogs can also provide valuable insights and preparation. If you want to learn more about finding a job in Germany as a Tech & IT professional get in touch with me here! 🌐💼 #SystemDesign #SoftwareEngineering #CareerGrowth #TechInterviews #Germany #InternationalEngineers #TechIndustry #ProfessionalDevelopment #Fajig

42

1 Comment

𝐖𝐡𝐚𝐭 𝐚𝐫𝐞 𝐃𝐞𝐬𝐢𝐠𝐧 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬 𝐢𝐧 𝐉𝐚𝐯𝐚?? > Design patterns are typical solutions to common problems in software design. They are like templates that can be applied to real-world programming situations to solve recurring design problems. > Design patterns can speed up the development process by providing tested, proven development paradigms. There are several types of design patterns: Creational, Structural, and Behavioral patterns. 𝟏. 𝐂𝐫𝐞𝐚𝐭𝐢𝐨𝐧𝐚𝐥 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬 These patterns provide ways to create objects while hiding the creation logic, rather than instantiating objects directly using a new operator. - **Singleton**: Ensures that a class has only one instance and provides a global point of access to it. - **Factory Method**: Defines an interface for creating an object, but lets subclasses alter the type of objects that will be created. - **Abstract Factory**: Provides an interface for creating families of related or dependent objects without specifying their concrete classes. - **Builder**: Separates the construction of a complex object from its representation so that the same construction process can create different representations. 𝟐. 𝐒𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐚𝐥 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬: These patterns deal with object composition or the way to compose objects to form larger structures. Structural patterns use inheritance to compose interfaces to obtain new functionalities. - Adapter: Allows objects with incompatible interfaces to work together by wrapping an interface around one of the existing objects. - Composite: Composes objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly. - Decorator: Adds additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality. - Facade: Provides a unified interface to a set of interfaces in a subsystem, making the subsystem easier to use. 𝟑. 𝐁𝐞𝐡𝐚𝐯𝐢𝐨𝐫𝐚𝐥 𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬 These patterns are concerned with algorithms and the assignment of responsibilities between objects. - **Chain of Responsibility**: Passes a request along a chain of handlers. Each handler decides either to process the request or to pass it to the next handler in the chain. - **Iterator**: Provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. - **Observer**: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. - **Template Method**: Defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps of the algorithm without changing its structure. Understanding these patterns and knowing when and how to use them can greatly enhance your design and coding efficiency. #job #designpattern

16