DO NOT WASTE YOUR TIME, OR DON'T TAKE THEM SERIOUSLY.

Before explaining my experience, I want to mention:

• I have 14 years of work experience in software development.
• I have worked on 3 continents.
• I am writing this to help other people.

The recruiter reached out on LinkedIn. They spoke highly of the company, their plan to expand in Dublin, and the importance of being part of an early-stage company with career growth opportunities.

They asked for some time slots. Initially, one slot was fixed, but it was later postponed. It was a video call over Zoom.

Rules of the Exercise:

1. You can use either CoderPad or your own environment and do a screen share.
2. The objective is to write code, and there were test cases to check the code.
3. You can Google things if you want.
4. The exercise is structured such that you implement one function, and then you will be asked to implement the next function, and so on.
5. There are 3 phases (meaning function implementations), each tougher than the previous one.
6. They say you need to pass at least 2 phases.
7. They are not looking for optimization as it is not being tested.

Sounds great. Yes, they sound awesome. They want to have the test in an environment just like you code every day, hence your choice of environment. They allow using Google, Stack Overflow, etc.

My choice of language: JAVA.

The interviewer is from Canada and working remotely. He clearly mentioned all of the above.

He asked me to paste the code from CoderPad to my IDE, IntelliJ IDEA.

The code was not compiling. My Java version was 8, and it had a compile error according to that version.

I started working on my code implementation but was blocked as I couldn't run it due to the compilation error. The interviewer mentioned he had not coded in Java in a while and hence needed help. They pinged the agency from which they get the questions, and they suggested a change, and the error was gone.

(If this was a test as well, then I am surprised and happy I got flunked. I was focused on my code.)

I implemented all 3 phases of the exercise, and all test cases passed. Once I did debugging to pinpoint my copy-paste of the same code error.

You don't need to Google or anything. The questions are easy and can be done on your own.

Everything was completed and seemed fine. There was no discussion of optimization or anything else.

I received an email stating they are not moving forward with my application. There was no feedback.

A complete waste of time. The only thing I learned: all that glitters is not gold.

/**

• Step 1

• Throughout this interview, we'll pretend we're building a new analytical database.
• Don't worry about actually building a database, though -- these will all be toy problems.
• Here's how the database works: all records are represented as maps, with string keys and integer values.
• The records are contained in an array, in no particular order.
• To begin with, the database will support just one function: min_by_key.
• This function scans the array of records and returns the record that has the minimum value for a specified key.
• Records that do not contain the specified key are considered to have value 0 for the key.
• Note that keys may map to negative values!
• Here's an example use case: each of your records contains data about a school student.
• You can use min_by_key to answer questions such as "who is the youngest student?" and "who is the student with the lowest grade-point average?"
• Implementation notes:
• • You should handle an empty array of records in an idiomatic way in your language of choice.
• • If several records share the same minimum value for the chosen key, you may return any of them. */

/**

• Step 2

• Our next step in database development is to add a new function. We'll call this function first_by_key.
• It has much in common with min_by_key. first_by_key takes three arguments:
• 1. A string key.
• 1. A string sort direction (which must be either "asc" or "desc").
• 1. An array of records, just as in min_by_key.
• If the sort direction is "asc", then we should return the minimum record; otherwise, we should return the maximum record.
• As before, records without a value for the key should be treated as having value 0.
• Once you have a working solution, you should re-implement min_by_key in terms of first_by_key. */

/**

• Step 3

• As we build increasingly rich orderings for our records, we'll find it useful to extract the comparison of records into a comparator.
• This is a function or object (depending on your language) which determines if a record is "less than", equal, or "greater than" another.
• In object-oriented languages, you should write a class whose constructor accepts two parameters: a string key and a string direction.
• The class should implement a method compare that takes as its parameters two records. This method should return -1 if the first record comes before the second record (according to key and direction), zero if neither record comes before the other, or 1 if the first record comes after the second.
• In functional languages, you should write a function which accepts two parameters: a string key and a string direction.
• The function should return a function that takes as its parameters two records. This function should return -1 if the first record comes before the second record (according to key and direction), zero if neither record comes before the other, or 1 if the first record comes after the second.
• You should then use your comparator in your implementation of first_by_key. */