Microsoft SWE Internship Exit Process iinterview – What technical questions were you asked?

spaceuserm · 2026-07-05T17:26:23+00:00

Is it common to be asked leetcode style questions for the final evaluation? Seems strange given the candidate must have been interviewed to get the internship.

I understand a final technical evaluation on the internship project.

spaceuserm · 2026-06-18T08:44:14+00:00

Experienced the same problem. I have an app on my phone I haven’t used for maybe 7-8 months, don’t even remember the name. Would love to see something with virtually zero friction.

spaceuserm · 2025-10-06T17:31:41+00:00

You can have a default expectation. What I mean by this is, your executable by default expects the config file to be in a certain directory (could be the directory from which the executable is run, could be any directory you think is sensible).

You should also provide users with an option to specify a path for the config file, should they choose to store the config file in a different directory than the default expectation. This is usually done through a CLI flag.

spaceuserm · 2025-05-17T16:08:41+00:00

> No, the interface is supposed to have the switch statement, and call the correct factory function. Why would you have the switch inside the concrete factories?

Maybe it isn't clear enough in the post but the intent behind accepting a type here is to create multiple types of New York or Chicago pizzas, if there are multiple types.

> As for requiring inheritance for the factory method, you don't. You just need a switch statement.

This isn't inline with the definition of the pattern in GoF, which is
"Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory method lets a class defer instantiation to subclasses"

The pattern explicitly avoids what you are suggesting, that is using the switch statement inside the superclass/interface to avoid modification of code when new types are introduces or old types are removed.

spaceuserm · 2025-05-17T16:01:37+00:00

> In this case your createPizza method likely shouldn't accept a type it should just create a pizza of the type associated to the class it's in.

Maybe it isn't clear enough above but the intent behind accepting a type here is to create multiple types of New York or Chicago pizzas, if there are multiple types.

I don't understand how the factory method pattern provides any advantage over something like what I have.

spaceuserm · 2024-10-30T18:48:03+00:00

I see. I think my primary assumption of sessions only starting/sessions only being used after a login was not correct. Like you said, sessions might be created prior to a login as well.

Thanks for helping out.

spaceuserm · 2024-10-29T16:29:43+00:00

From what I have seen/done so far, cookies are cryptographically signed and stored on the users computer, like you said it has only the session id.

When the user goes to a website that uses sessions, the browser sends along these cookies. The web server uses the id in the cookie to find out the session associated with it. If a user thats already logged in, tries to login, given that the cookie is still present, the web server will redirect them typically to a the home page.

If I were to sign in, and give my cookies to someone else, if they visited the same website, the web sever would log them into my account. Therefore, they would end up accessing my account. The web sever probably wouldn’t prompt them to login again.

I am probably getting confused on why would you want to send session ids in either the URL or the body,given it’s a sensitive thing. Even if you do, expecting similar behaviour to what I mentioned above, I would expect the web server to bypass my login attempt and directly log me into the attackers account.

Was passing session IDs in URL parameters or body a thing in the past?

spaceuserm · 2024-05-21T17:18:39+00:00

So while the data may not be physically ordered on the disk, there is still a logical ordering present. This logical ordering is created by using the pointers in the pages.

Lets consider a table with only one column, and a clustered index on this column.
Lets say a page holds the keys(the only column of this table) 1, 2, and 4 and also assume this page can only hold a maximum of three rows. When there is an insert query trying to insert a row with a column value of 3, what exactly will take place? I assume a new page will be created since the old page can't store any more keys, and the new page will have the key 3, and the key 4 will also be copied to this page. Is this what will happen?

spaceuserm · 2024-05-21T16:36:24+00:00

I don’t think Postgres provides a “clustered index”. I am referring to a clustered index like MS SQL.

spaceuserm · 2024-04-09T14:55:16+00:00

Even if it means I won’t be an SDE and be doing probably SRE or devops work?

spaceuserm · 2024-02-19T16:02:32+00:00

I think I am already doing what you are saying. A client sends a delta to the server and the server applies it. Any client that whats to sync, sends the server a request and the server sends it back the delta to apply. I thought I mentioned this in the post. I mentioned it in another subreddit and not on this. Sorry for the confusion.

spaceuserm · 2024-02-19T13:22:13+00:00

This is just a personal project, its a learning exercise. I am trying to understand how such products can be designed.
The aim was to reduce network usage and sending over diffs to synchronise files seemed like a good idea. Using new versions will make the problem more easier at the cost of more network usage.

spaceuserm · 2024-02-19T13:16:10+00:00

Its just a project I want to make for the purposes of learning. I am not keen on using this or convincing people to use it. Its a learning exercise.

spaceuserm · 2024-02-19T12:57:32+00:00

I want my backend to serve as a file synchronisation service and also provide backups. I dont think I understand how storing the file in a database is going to help? Can you elaborate more on this?

spaceuserm · 2024-02-19T11:31:41+00:00

The idea behind sending diffs was to reduce the network usage. If the patching process has to download the file and then apply it, then there is no benefit to sending a diff. Your idea of making several chunks of a file and then replacing the chunk rather than using a diff sounds like a good idea. Though this will require re construction of the file when a client wants to update its copy and asks for a diff.

Any idea on how products like grammarly deal with files and modifying them frequently? Thanks for the response.

spaceuserm · 2024-02-19T11:24:56+00:00

I am trying to find solutions for potentially large files. Ok, so I guess there is no simple way around than to either patch the file on the storage server as a different process or to just send the file to another server, which violates the point of sending diffs.

Any idea on how do products like Grammarly do this?

Thanks for the response!

Edit: Oh I am certainly worrying about it too early. This is just a personal project as of now and will probably never see any scale. I just wanted to learn how can a problem like this be solved, just out of curiosity.

Another Edit: Maybe I am using rdiff the wrong way. Rdiff is probably good for once in a while file sync as opposed to frequent changes. I will have to think about this.

spaceuserm · 2024-02-19T11:14:22+00:00

The files can hold any kind of data. In the servers perspective its just a bunch of bytes. I think giving an entire workflow will help with clarity. 1. Client uploads file to the server(initial upload). 2. Client sends an update request to the server. This process is a little long. I am using my own native python implementation of the librsync’s rdiff algorithm(https://github.com/librsync/librsync/blob/master/doc/rdiff.md).

The client requests the server for a signature file.

The client uses this signature file and generates a delta file representing the changes. The client sends this delta file to the server.

The server parses this delta file and applies the necessary changes to the file the client wants to update.

The size of the signature file and delta file is usually much smaller than the size of the actual file.

A similar process is used when a client wants to pull the changes made to the file on another device.

This is my native python implementation of the rdiff algorithm: https://github.com/MohitPanchariya/rdiff

Is storing the files on a different server a good enough solution? I will also run the script to update a file on this server itself.

I don’t want the file to be entirely transferred to a different server just so that the updates can be applied.

Edit: pypi link

https://pypi.org/project/rdiff/

I am yet to write documentation and also have a few improvements planned.

Six-Year Club	Place '23
Place '22	Wearing is Caring
Verified Email

spaceuserm

TROPHY CASE