Adhithyan Vijayakumar

I'm a full stack back end engineer with about 6 years of experience in startups and big companies. I've worked in a wide variety of software development life cycles, including planning, development, maintenance, testing, deployment, and debugging issues in production. I've also done front end development, so I'm capable of doing both back end and front end work. But throughout my career, I've worked on full stack roles, although they were back end heavy.

I think some of the libraries that are used in finance are Pandas, NumPy, and SciPy. So, for example, Pandas helps in CSV manipulation. There is an inbuilt library in Python called a CSV. Like, the inbuilt library in Python takes around 5 lines to open a CSV file, but with pandas, we can just read a CSV file with a single line like this. There are many such useful operations in pandas and NumPy that help to simplify while we work with large datasets.

As it refers to consistency, isolation, durability. So, atomicity refers to each transaction being independent from other transactions. Either a transaction happens or it does not happen. For example, during a transaction when power goes out, the transaction state won't be recorded in the system. That is atomicity. Consistency is when we enter data, it stays in the database. As long as we don't modify the data, it stays the same. So, what we are entering into the database is the data that we receive when we issue a query. Isolation: each transaction should not affect any other transaction, so every transaction should execute within its own sandbox. Each transaction does not know other transactions are occurring in the system. So, durability: whatever data we input on the system, it stays there. The data is not corrupted. It stays there as long as we delete it from the system.

Self, cloud computing, continuous integration helps to maintain the quality of code, ensure that new features do not break the existing features like we'll be writing unit tests, integration tests, functional tests. So, a continuous integration pipeline will check the quality of code, find and report any lending issues. It will run our test suite to get test coverage and ensure that the code is of high quality and nothing is breaking. In terms of continuous deployment, many companies are opting for a two-week development life cycle. They plan the start of the first week, first day of the first week, and develop things in the first week. Then, in the second week, they give it for testing. At the end of the second week, they'll deploy it in production. Discontinuous deployment ensures that new features and bug fixes are getting released constantly, improving the system over time.

First, I understand that in finance, the finance product, getting real data or logging the user data will be causing privacy issues. So logging won't be an option here. We'll be having the system monitoring systems like New Relic and some error tracking systems like Sentry. We can get the error trace and try to debug why the error is happening, whether it's due to a runtime error, or whether we have failed to handle a case or edge case, or if it's due to an external library that we are using, or it's due to irrelevant data or something like that. First, we need to identify whether the issue is being caused by our code or third-party code. Once we find that it's a third-party code, we can raise an issue in the tracking system, and we can fast-track fixing that issue. If it's an issue from our side, we can try to fix it as fast as possible.

I have used AWS Lambda to enhance performance and responsiveness of a Python application. I have deployed the APIs in a serverless land application because APIs won't need a constant running server and Lambdas are serverless. It helps to give the response in a very quick time. So, yes.

So the given code is a recursive function. So it has two blocks. One is the terminating condition for the recursive block that returns 1 if the input number is less than or equal to 2, and the else part is the recursive block. It branches into two divisions, n minus 1 and n minus 2. The function tries to calculate the value of n when n is given. For example, we are passing calculate 3. So it goes to the if block, 3 is not less than 2, so it goes to the else block. So here, it recurs and branches into two. Calculate 3 minus 1 and calculate 3 minus 2. So two branches are called calculate 2 and calculate 1. So here, calculate 2 is called. So we'll go ahead in the recursion again. N is less than or equal to 2. It will return 1. So we are here again. We already have 1 record and block calculate 1. N is less than or equal to 2. 1 plus 1 returns to. Okay. Then, let's add another example. Calculate 4. It goes here. Calculate 3 plus calculate 2. Calculate 3 plus calculate 2. 2 plus 1. So this function returns the value of n minus 1. When we give 3 as an input, the answer will be 2. When we give 4 as an input, the answer will be 3.

Yes, in the try block, we are returning a JSON that is a dict object, but in the accept block, we are returning an exception. So the return signature is not matching. Either we should return a dict in both cases or string in both cases. So we should change the return statement in the Excel block to return, open parenthesis, key message, colon key. So we should give it like that. Also, I am thinking of one improvement. Before returning the response to JSON, we should check if the response has yielded a 2xx response. Whether the response was successful and yielded a status code between 200 and 299. We should check them using if response.ok, return response.json.

So, in the context of cloud architecture, components should be loosely coupled. One cabinet should not be tightly coupled with each other. In one of my companies, I was working on this big Python project where everything was tightly coupled. Using this architecture, I suggested to the management to disintegrate everything.

So, the one way I am thinking of is that while integrating data from various sources into an unified system after inserting data, we should run a background job to check if the data inserter is being present. Is the data inserter and the data that came from the data source the same. So we should verify this once by running a background job. And also, we should ensure that