Developer Tests

Exercise: Real-time chat application

​

You have been tasked with building a real-time chat application using React and a server-side technology of your choice (e.g., Node.js, Django, etc.). The application should allow users to:

• Create an account and login

• See a list of active chat rooms

• Join a chat room and see all messages in real-time

• Send messages in real-time to a specific chat room

• Receive notifications when a new message is received in a chat room they are in

The project should be completed within 3 hours and you should provide the following:

• A working application that meets the requirements

• Code that is easy to read and maintain

• Unit tests for critical parts of the code

• Documentation on how to run the application and any other necessary instructions

The project should be completed without the use of any pre-built chat libraries or frameworks, and should demonstrate your proficiency in building complex, real-time applications using React and your chosen server-side technology. Good luck!

Project Description

You are tasked with building a simple API that allows users to view, create, update, and delete notes. The notes should be stored in a JSON file on the server, and the API should be able to handle multiple users.

​

Requirements

1. Create a Node.js server that listens on port 3000.

2. Implement the following endpoints:

   • GET /notes: Returns an array of all notes.

   • GET /notes/:id: Returns the note with the specified ID.

   • POST /notes: Creates a new note with the provided title and content.

   • PUT /notes/:id: Updates the note with the specified ID with the provided title and content.

   • DELETE /notes/:id: Deletes the note with the specified ID.

3. Store the notes in a JSON file on the server. Each note should have an id, title, content, and user_id field. The id field should be a unique identifier for each note, and the user_id field should be used to associate notes with users.

4. Implement user authentication using JSON Web Tokens (JWT). Users should be able to sign up, sign in, and sign out. Only authenticated users should be able to access the API.

5. Implement error handling for all endpoints. If an error occurs, the API should return an appropriate HTTP status code and a descriptive error message.

6. Write unit tests for the API using the Jest testing framework.

​

Evaluation

To evaluate the candidate's proficiency in Node.js, you should assess the following:

• Whether the candidate's implementation follows best practices for Node.js development, such as asynchronous programming and error handling.

• The candidate's ability to implement user authentication using JWT.

• The candidate's ability to write unit tests for the API.

• The quality and completeness of the code.

• The candidate's ability to complete the project within the given time frame.

​

Additional Instructions

1. Please provide a README.md file with instructions on how to run the server and the tests.

2. Please provide a brief explanation of your design decisions and any tradeoffs you made.

3. Please upload your code to a public GitHub repository and share the link

Create a Python program that can generate a maze and solve it using the A* algorithm. The program should be able to take user input for the size of the maze and the starting and ending points, and it should display the solution path visually.

​

The maze should be randomly generated, but the user should be able to specify the density of walls. The A* algorithm implementation should be done from scratch (i.e. not using a library like NetworkX) and should be optimized for performance.

​

Additionally, the program should include the ability to export the maze as a PNG image and the solution path as a GIF animation.

​

This exercise will require proficiency in Python programming, algorithms, data structures, and image processing.

Problem Description

You are tasked with building a console-based application that allows users to manage a simple inventory system. The application should allow users to add, remove, and update items in the inventory, as well as view the current inventory. Each item in the inventory should have a unique identifier, a name, a description, and a quantity.

Your task is to implement the Inventory class, which will contain the logic for managing the inventory. You should also implement a Main class that allows the user to interact with the Inventory class via a console-based user interface.

​

Requirements

• The Inventory class should contain the following methods:

  • addItem(String name, String description, int quantity): void - Adds a new item to the inventory with the specified name, description, and quantity.

  • removeItem(String itemId): void - Removes the item with the specified identifier from the inventory.

  • updateItem(String itemId, String name, String description, int quantity): void - Updates the item with the specified identifier with the new name, description, and quantity.

  • getItem(String itemId): Item - Returns the item with the specified identifier.

  • getInventory(): List<Item> - Returns a list of all items in the inventory.

• The Item class should contain the following fields:

  • id: String - A unique identifier for the item.

  • name: String - The name of the item.

  • description: String - A description of the item.

  • quantity: int - The quantity of the item in the inventory.

• The Main class should allow the user to interact with the Inventory class via a console-based user interface. The user should be presented with a menu that allows them to add, remove, update, and view items in the inventory.

​

Constraints

• You may assume that all item identifiers are unique.

• You may assume that all user input is valid and well-formed.

• You may use any standard Java libraries.

• You may not use any external libraries or frameworks.

• You may not modify the Item class or the Main class.

​

Evaluation Criteria

• Correctness: Does the program produce the correct output for a given input?

• Code quality: Is the code well-structured and easy to read? Does it follow best practices?

• Efficiency: Does the program use the minimum amount of resources necessary to solve the problem?

• Robustness: Does the program handle unexpected inputs and edge cases gracefully?

​

Additional Notes

• You should write unit tests for your code.

• You should submit your code as a single ZIP file, including any necessary build scripts and documentation.

Problem Statement

You've been asked to build a simple console application that reads a CSV file containing information about employees in a company and outputs some basic statistics.

​

Input

The input CSV file will have the following columns:

• Name (string): the employee's name

• Department (string): the employee's department

• Salary (float): the employee's salary

​

Output

The application should output the following statistics:

• The total number of employees in the CSV file.

• The average salary of employees in each department.

• The name of the employee with the highest salary.

​

Constraints

• The input CSV file will have at most 1 million rows.

• The application should be able to handle CSV files with any number of columns, but you can assume that the first three columns will always be Name, Department, and Salary, in that order.

• You can assume that the CSV file will always be well-formed (i.e., no missing values, etc.).

• You can assume that the CSV file will fit in memory.

​

Example

Suppose you have the following input CSV file:

 

Name,Department,Salary Alice,Marketing,50000 Bob,Engineering,80000 Charlie,Engineering,75000 David,Marketing,60000

​

The output of the program should be:

​

Total employees: 4 Average salary (Marketing): 55000 Average salary (Engineering): 77500 Employee with highest salary: Bob (80000)

​

Tips

• You can use the CsvHelper library to read the CSV file.

• You can use LINQ to calculate the statistics.

• You can assume that the input CSV file will always exist and be readable.

​

Evaluation

You can evaluate the developer's proficiency based on the following criteria:

• Correctness: Does the program produce the correct output for the given input?

• Efficiency: Does the program handle large input files efficiently?

• Readability: Is the code easy to understand and well-organized?

• Maintainability: Is the code easy to modify and extend?

 Use parallel processing to improve efficiency or to write unit tests for the program.

Project Description

You have to create a web application that allows users to manage their tasks. The application should allow users to:

• Create new tasks

• Edit existing tasks

• Delete tasks

• Mark tasks as completed

• View all tasks

• View completed tasks

• View pending tasks

​

Requirements

• The application should be built using ASP.NET MVC or ASP.NET Core MVC.

• The application should have a responsive user interface that works well on desktop and mobile devices.

• The application should use a database to store task data. You can use SQL Server, MySQL, or any other database of your choice.

• The application should have a login and registration system.

• The application should have role-based access control. There should be two roles: "admin" and "user." The admin should be able to perform all the operations listed above, while the user should only be able to view their own tasks and mark them as completed.

• The application should be secure and protect against common security threats like SQL injection and cross-site scripting (XSS) attacks.

• The application should use best practices for performance and scalability.

​

Evaluation Criteria

• Code quality: Is the code well-structured, easy to read, and maintainable?

• Functionality: Does the application meet all the requirements listed above?

• Security: Is the application secure and protected against common security threats?

• Performance: Is the application fast and responsive?

• Scalability: Can the application handle a large number of users and tasks?

​

Instructions

• You have 3 hours to complete this exercise.

• You should fork this repository and create a new branch for your changes.

• Once you have completed the exercise, create a pull request to merge your changes back into the main branch.

• You should include a README file with instructions on how to build and run your application.

• You should also include any additional information that you think is relevant, such as decisions you made while designing the application or any limitations you encountered.

Exercise: Build a Simple Social Network

You are tasked with building a simple social network that allows users to create accounts, make posts, follow other users, and see their own and other users' posts.

​

Requirements

The social network should have the following features:

1. User registration and authentication

2. User profile pages, showing the user's name, username, and a list of their posts

3. A news feed page, showing the user's own posts as well as posts from users they follow, with the ability to create new posts

4. The ability to follow and unfollow other users

5. A search functionality to find users by name or username

6. Basic error handling and validation of user input

7. Basic styling with CSS

​

Technical details

You should use Ruby on Rails to build this application. Here are some specific technical requirements:

1. Use the Devise gem for user authentication

2. Use the Paperclip gem for user avatar uploads

3. Use Bootstrap for styling

4. Use PostgreSQL as the database

​

Evaluation

We will evaluate your submission based on the following criteria:

1. Functionality: Does the application meet all of the requirements?

2. Code quality: Is the code well-organized, easy to read, and free of major bugs?

3. Best practices: Does the code follow best practices for Ruby on Rails development, including proper use of MVC architecture, RESTful routing, and database migrations?

4. Styling: Is the styling clean and visually appealing?

5. User experience: Is the application easy to use and understand?

​

Instructions

You have 3 hours to complete this exercise. Fork this repository and submit your solution as a pull request. Please include instructions for setting up and running your application.

Problem Statement

Your task is to implement a simple web server in Go Lang that provides a REST API for managing a list of books. The server should allow users to perform the following operations:

1. Get a list of all books

2. Get a single book by ID

3. Add a new book

4. Update an existing book

5. Delete a book

The book data should include the following fields:

• ID (string)

• Title (string)

• Author (string)

• Publication Date (string)

The server should store the book data in memory (i.e., no database required). The API should return JSON-formatted responses.

Your solution should include the following:

• A README file that explains how to run your code and any dependencies required.

• Well-organized and documented code.

• Unit tests for your code.

• An example client that demonstrates how to use your API.

You have 3 hours to complete this exercise.

​

Requirements

• Use the standard Go library for HTTP server and JSON encoding/decoding.

• Use the mux package for routing.

• Use the testify package for unit testing.

• Write clear and concise code with meaningful variable and function names.

• Use git for version control and commit your work regularly.

​

Bonus Points

You can earn bonus points by implementing any or all of the following:

• Add support for pagination and sorting to the GET /books endpoint.

• Implement authentication and authorization for the API using JSON Web Tokens (JWT).

• Containerize your application using Docker.

• Deploy your application to a cloud provider (e.g., AWS, GCP, Azure).

• Use a third-party API to get additional data about each book (e.g., Goodreads API).

​

Evaluation Criteria

Your code will be evaluated on the following criteria:

• Correctness: Does your code fulfill the requirements of the problem statement?

• Code Quality: Is your code well-organized, easy to read, and maintainable?

• Test Coverage: Do your unit tests cover all the important use cases and edge cases?

• Documentation: Is your code well-documented with clear comments and a README file?

• Efficiency: Is your code efficient and scalable?

Exercise: Build a REST API for a NoSQL database

You are tasked with building a REST API that interacts with a NoSQL database. The NoSQL database is a simple key-value store with the following requirements:

1. The keys are strings.

2. The values are JSON objects.

3. The API should support the following operations:

   • POST /data: Accepts a JSON object and saves it to the database. The key should be generated automatically and returned in the response body.

   • GET /data/:key: Retrieves the JSON object associated with the specified key.

   • PUT /data/:key: Updates the JSON object associated with the specified key.

   • DELETE /data/:key: Deletes the JSON object associated with the specified key.

​

Requirements

1. Use any NoSQL database of your choice (MongoDB, Cassandra, etc.).

2. Use any programming language of your choice.

3. Use any web framework of your choice.

4. Use any libraries or tools that you deem necessary.

5. The API should be documented with clear instructions on how to use it.

6. Write unit tests to verify the functionality of the API.

7. Ensure that the API is secure and handles errors gracefully.

8. Ensure that the API can handle large amounts of data.

9. Ensure that the API is performant and scalable.

​

Evaluation

You will be evaluated based on the following criteria:

1. Correctness: The API should work as expected and meet the requirements.

2. Code quality: The code should be well-structured, easy to read and maintain, and follow best practices.

3. Documentation: The API should be well-documented with clear instructions on how to use it.

4. Unit tests: The unit tests should cover the functionality of the API and be well-written.

5. Security: The API should be secure and handle errors gracefully.

6. Performance: The API should be performant and scalable.

​

Submission

Please submit your code as a ZIP file containing the following:

1. The source code.

2. The documentation.

3. The unit tests.

4. Any instructions on how to run the code.