Turjoy Saha

Yeah, the same screen is showing the first question again. Should I answer it? Yes. The timer is running out. Let me ask, Okay. I have to not refresh it. Okay. So, I cut everything I said before. I was having technical difficulties. So, cut everything I said before. Here is the answer, and it starts like this. I have three years and six months of experience with React Native and BondStack. And I have built web apps and mobile apps in fields ranging from ecommerce apps, fitness apps, wedding event management apps, e-payroll management apps, ecommerce ERP management apps, and several other small apps. I worked as part of a great team. I worked as a team lead, and I have also built projects from scratch. Other than that, I am used to writing scalable and maintainable code using low-level and high-level design concepts.

Yes. I work with Next.js or React, and I have worked with Next.js and headless CMS also. I work with headless CMS like Storyblok and Strapi. So, in case of Strapi, or Storyblok, what it does is the headless CMS manager manages all static and dynamic contents, and we can control the number of pages to display, the number of pages, and component content to display page contents to display those type of stuff. In case of Strapi, we use GraphQL or REST APIs for the content. In case of Storyblok, we can connect with the Next.js frontend using REST APIs or GraphQL APIs. We can also use the Storyblok library for frontend and provide the app tokens of Storyblok CMS headless CMS backend. And thereby, we can call the Storyblok in-built fetch calls to get or to perform cloud operations of the content. We can also build dynamic components. We can control the navigation of the frontend from the headless CMS. We can generate block contents and stuff. And we can anything related to content; the frontend can rely on Storyblok. Now, in case of block contents, we can optimize the frontend and Storyblok by passing the Storyblok API calls in static props. And thereby, the Storyblok APIs are called at the build time, and the pages are rendered. Then the pages rendered are stored with the API data during build time only and stored in the backend. So when the client side asks for the pages, it gets the page with the data without any API call on the client side. This makes the page load very fast. In case of dynamic components, of course, we want to render the API calls on the server side. And for that, we can use getServerProps. And within getServerProps, we can call the Storyblok APIs using direct API call or using the Storyblok library.

Storyblock has specific guidelines to build the plug-ins. Suppose I am building a plugin for auto-saving when I'm editing a document, but not for publish. Just auto-saving and not publishing. Then the plug-in will have access to the markdown or SQL that saves the content temporarily. It will be executed every time there is new content added to the story block using the story block UI, also known as the content manager UI. Thereby, it stays. We can connect the plug-in with Storyblock, and the plug-in will start working on the temporary update. Only when we publish, the permanent update is delivered to the main markdown or SQL. To ensure compatibility, we must follow an adapter pattern. So if Storyblock upgrades and the plug-in breaks, only the adapter needs to be updated. This way, all the plug-ins dependent on that functionality of Storyblock won't break or if there are breaking changes in the update. We can also use, like, adapters for that.

The most complex websites in base use are usually dashboards and drag and drop creations. So, there was this website which had a lot of dynamic table contents. I used a table builder component to ensure that in the future, whenever the table grew in requirements, there would be a builder in place. So, single responsibility and closed SRP and OCP were followed, and the code didn't need to be modified. There won't be any redundant code to be written. And I also built a map. There was this functionality of building the layout of a floor plan, placing the anchor locations so that the tags moving around could be shown relative to the anchor positions of the floor plan. I created a complex canvas to draw the floor plan. I used plain HTML canvas to build the map builder, and then implemented it. And, yeah, there were many complex filters and Lottie animations when the table showed updated values. So, some of the animations I made using Lottie. There were filters and complex filters, and I created a global state management using Redux and Redux tools to manage the complex filtering processes. It also helped in web prop trading for several components. The code was very scalable because of using both solid principles and atomic design patterns to structure the components. So, the components were reusable, and new progresses were not taking much time. Other than that, there was also user management. User authentication management and security were handled properly with the help of HTTP cookies and session managers and local storage. Local storage was used for some filters. Other than that, there were animations and naughty animations I implemented. And, basically, that's it. The architecture was following solid principles, dynamic design patterns with a concrete Redux with a concrete Redux store, which was a separate bundle from React. There were maps for the floor plan builder.

Storyblock.com is a headless CMS. So, what it provides us are the APIs that what it provides us is a content manager. So we can manage components, UI components. We can manage the written content to be displayed. We can manage page pages to display in the website. We can also do custom dynamic components. So, all of the frontend content, anything related to frontend content, can be controlled using Storyblok. So we can integrate Storyblok with several frontend frameworks like Vue.js and Next.js. In the case of Next.js, Storyblok provides a custom library for React, and we can call that library to fetch the API data, using the REST API or GraphQL calls. We can also have access to secure the token in the frontend side, of course, with environment variables. So, basically, Storyblocks is a very enterprise-level content manager for frontend. So, that's how I have used it in frontend in my own blog website. The navigation page and the pages to display that is the navigation that are tied to the pages, and the dynamic components, or in the case of blocks, the static components are used to get static props along with images to build pages with content using the APIs of Storyblok. I also used server-side rendering of dynamic data with Next.js. Yes. And for components of every page, it was decided by the content manager of Storyblok. The Storyblok UI Storybook also has options to add plugins to it to improve functionality and control of the user. Like, some users prefer auto-save while writing before publishing. So, we can add our plugin to Storyblock or we can build our own custom plugins also.

So, in my case, I needed the number of views in my blog. So, what I did was there was no view counter in-built, so I found the location of it in Strapi, which is a headless CMS. In Strapi, I got control of the controllers that were managing the transfer of data, like when a request is made from the client side and the controller has access to the request body. And from the request body, I can get the user's IP to detect if it's a unique user or not. Then, I created my own database in SQL and made a view scheme. I added the views in the schema of the content and increased the view whenever there was a new IP coming up. That's how I developed a new feature in the headless CMS by modifying the back-end code.

Well, Storyblock provides us with a headless CMS and a CMS as well. Developing in Storyblock has not only provided us with a content manager but also sometimes a good front end. And, if we want a custom front end, we can also integrate Storyblock with Next.js, Vue.js, or other frameworks available. In case of Storyblock, the APIs can be GraphQL or REST API. In case of WordPress is just a full CMS that doesn't provide any APIs per se. Magento is also like WordPress, and it's similar to WordPress. It's also built with PHP. Shopify is also built with PHP, but it's focused mostly on delivering ecommerce. However, it also helps bloggers. In case of Shopify, it provides us, besides providing a full-fledged CMS, it also provides APIs so that we can implement our own custom front end using our own preferred framework. In all of them, we can build our custom plugins to add functionalities based on our requirements.

The main error we can see here is that the code actually aims to define whether the age parameter is present in the user object, but the age parameter won't be present and might not be present. If it's present, it's a number. But question mark, colon age question mark, colon, number doesn't say that. This line should be age colon number hyphen undefined. So that means the age can be a number, or it might be that it's not defined. That question mark colon should not be there. The goal is to provide the type of age as number or undefined. So we will write numbers, colon, undefined. Number dash undefined.

The best way to handle this is to use promise, is to execute promises. So, independent promises should run. So we can do a promise for all, or call promises that are independent or dependent. We can group dependent promises together and call all the promises at a time using promise.all. And we can, of course, maintain a memoized update of the promised returns. And whenever there is a change in a particular promise, we only call that particular promise when there is a requirement for a particular API call. We only call that API at that moment. Otherwise, we re-render the component. Otherwise, we use the updated values. And also, since the promises are non-blocking, so if the promises are non-blocking. So if the process of the promises can run parallelly, so the promises can run parallelly without affecting the results of others if they are not dependent on each other. Then whenever a promise is resolved, only then we update the local states, and the components dependent on those local states will be updated. So, of course, we have to follow a single responsibility principle and open-close principle here. So in case of a component, we also have to avoid prop drilling. It's better to use a global state manager like Redux in case of React. Or in case of SolidJS, just use createStore. And using that global store, we have to check for transactional integrity. We have to check the data types for the operations before submitting or while submitting. And, of course, in the backend also, there should be data type checks already implemented in the CMS. And that's it for transactional integrity. All good management requires a global manager for transactional integrity. Type checking should be implemented for faster component rendering. Memoization should be used.

So Nest is basically a Net. NestJS basically runs on a server, and within the server, NestJS basically runs on a server. And when we deploy to GitLab or GitHub, we can in our pipeline code, we can ask to run the tests first. We can ask to run the Lint first, then run the Lint so that the code Linting is alright. Then only after both of these processes are successful, only the deployment, the build happens, and the build software is deployed to the port that is available to the outside world. And that's how I would automate it, like, first Linting or first testing, then deploy, then building the app, then deployment from the server.

To me the best practices for maintaining scale consistency is to use a type-safe language like TypeScript, to use a global state manager so that state groups remain independent of updates from other states and thereby don't offer multiple useless calculations. Do not perform useless calculations. Also, in case of component rendering, we should use memoization so that components don't rerender uselessly if their data or props doesn't change. And that's it.