Tech Test for Software Engineer II Role - Civic Tech Practice

This is a tech test for use in Software Engineer II recruiting for BlueLabs Analytics' Civic Tech practice.

Information for Candidates

Thank you for applying for the Software Engineer II Role for Bluelabs Analytics' civic tech practice. This test will be shared with you approximately 36 hours before your scheduled technical screen with the Hiring Manager. You may choose to either complete the test on your own schedule (take home) or over zoom during the technical screen (whiteboard style) - if you would like to complete this test during the technical screen please make sure to inform our recruiting team so we can schedule sufficient time for the technical interview.

This test is designed to validate for the following skills and practices:

• basic git knowledge
• problem solving and reasoning
• thoughtful application of existing skills
• ability to read and understand unfamiliar code well enough
• communication skills (written or verbal depending on chosen test format)
• cleanliness and modularity

What this is not designed to test:

• knowledge of academic CS concepts
• memorization of exact syntax

If you would normally look something up, it's okay to say or comment "this is where I would look XYZ up"!

The test will be reviewed using the rubric below.

Special notes for take-home candidates

Our expectation is that you should spend between 1-2 hours on this. If it takes you much longer than 1-2 hours to complete the two tasks detailed in the instructions and write up a detailed narrative about your process, you may want to reconsider whether this is a position you are interested in pursuing.

Special notes for whiteboard candidates

Please make sure you are ready to interact with github ahead of the technical screen - i.e. make sure your ssh keys are set up, you have the repository cloned locally, you have an ide installed, etc. Remember: your thought process is as important as the code you produce, so our expectation is that you will verbally narrativize your decisions as you work through the test. If you are more comfortable with written communication, you may prefer to complete this as a take-home.

Assesment Rubric

Area of Competency	Level 1	Level 2	Level 3	Level 4	Level 5
Familiarity with tools and best practices	The candidate demonstrates utter unfamiliarity with relevant tools and practices.	The candidate demonstrates some familiarity but not a deep knowledge of at least one of the following: git, python module structure, testing.	The candidate demonstrates at least a basic familiarity with all of the following: git, python module structure, testing.	The candidate demonstrates basic familiarity with all of and expert knowledge with at least one of the following: git, python module structure, testing.	The candidate demonstrates expert knowledge with relevant tools and practices.
Parsing of unfamiliar code and systems	The candidate was unable to parse existing code and documentation.	The candidate demonstrates an ability to parse some but not all of the existing code. The transformed code accomplishes some but not all of the original functionality of the provided script.	Where the transformed code does not accomplish the original functionality, the candidate has provided an explanation or acknowledgement of the missing functionality.	The transformed code accomplishes all or most of the original functionality of the provided script. Where original functionlity is not preserved, the candidate has provided a detailed explanation for why it was skipped or how they might implement it.	All original functionality is preserved.
Logic	The candidate does not demonstrate sound programmatic logic.	Some logic is sound but the candidate mis-uses or neglects to use one of the following where appropriate: control flow/conditionals, looping/iteration. The candidate does not always select the most appropriate data type for the task.	The logic is sound but not always efficient. Data types are often but not always appropriate and correctly structured.	All logic is sound and is mostly efficient. The candidate demonstrates careful and purposeful data type selection.	All logic is sound and clear steps have been taken to improve performance. Data is stored thoughtfully and as efficiently as possible.
Thought process and reasoning	The candidate does not demonstrate a careful or thorough thought process. The candidate does not demonstrate an ability to use creative problem solving when issues arise.	The candidate demonstrates a somewhat careful thought process but they are not thorough in their consideration. The candidate was able to describe some of their problem solving process when facing roadblocks or issues.	The candidate is thoughful and thorough. They are able to articulate a creative problem solving process clearly.	The candidate demonstrates very sound reasoning and runs into very few issues - when they run into a problem they are able to very thoroughly articulate how they would solve it and why.	The candidate demonstrates a very thorough, careful, and thoughtful though process. They communicate their reasoning and decision making very clearly.
Cleanliness and Modularity	The code is difficult to parse and/or is not usable.	The code is parse-able but is difficult to follow or contains many instances of re-creating logic, poor naming conventions, and/or copy-pasting.	The code is parse-able and readable. It contains a few instances of re-creating logic, poor naming conventions, and/or copy-pasting.	The code is clean and well organized with a clear eye toward modularity and minimal instances of re-created logic.	The code is truly object oriented in its design and implementation. It could be incorporated into an existing codebase with minimal refactoring.
Communication	The candidate did not communicate throughout the process. And/or the code lacks all documentation.	The code contains some comments or explanatory notes. The candidate has explained some of their thought process. There is minimal documentation.	The code is commented and the candidate has explained most of their thought process. The documentation provided meets the requirements set.	The code is well commented and the candidate has thoroughly explained their thought process. The documentation provided meets the requirements set.	The comments are exemplary. The candidate has thoroughly explained their thought process. The documentation goes above and beyond in format or readability.