Choosing the Right Language for Your Technical Interview
Let’s cut to the chase: Use this decision tree to make a quick decision and start practicing with the language you have chosen.
Read on to understand the rationale behind this decision tree.
What language for when?
When preparing for technical interviews, consider two main scenarios:
- Online assessments where you solve coding questions under time pressure.
- Technical interviews where you code in front of an interviewer.
While you can technically use different languages for the two scenarios above, it is highly unadvisable. Stick to a single language so you don’t need to double your interview prep efforts.
Online assessments
For online assessments, you can usually choose any language you want, as long as it’s available on the platform. However, the more obscure the language, the less likely you’ll be able to use it. Languages like Python and Java are almost always available. Swift? Not so much.
Most companies use popular online assessment platforms like HackerEarth, HackerRank, CodeSignal, and CoderPad, which support many languages (70+ languages!). However, companies can still restrict the programming languages available to you. Sticking to mainstream languages is the safer choice. For example, Google’s online assessments allow only Python, Java, C++, and JavaScript.
Technical interviews
For technical interviews, the languages you can or should use are more limited. Here are some considerations:
- Familiarity: Choose a language the interviewer is familiar with so they can help debug and follow along. It’s hard to know what language the interviewer prefers, but you can make an educated guess based on the industry and the company’s tech stack. If unsure, stick to popular languages.
- Domain-Specific Languages: For certain roles, you’ll need to use the appropriate language. For example, if you’re interviewing for an iOS developer role, your interview will likely be in Objective C and Swift. For a web development role, JavaScript is essential.
Here’s a table of roles and their likely corresponding languages:
Note on SQL: Some roles, like data science, require both Python and SQL. If you’re proficient in Python but haven’t practiced SQL, you could fail the SQL component and ultimately the interview.
How to pick the best programming language
When choosing a programming language for technical interviews, consider these factors:
- Implement things fast. In online assessments where time is of the essence, or in live coding environments where you don’t want to test your interviewer’s patience, you need to implement solutions quickly. Languages like Python have a standard library that supports many common data structures out of the box, saving you hassle of implementing them yourself.
- Easy readability. Choose a language that allows you to explain your solution clearly to your interviewer. This helps them follow along as you code. While good coding practices like commenting and proper naming are essential, a language that’s inherently more readable will always be helpful.
- Familiarity with the language. The importance of this varies with how much time you have until your next interview. If your interview is in three days, this is crucial. You don’t want to stumble over basic syntax of a language you just learned in front of an interviewer. If you’re prepping for the hiring season in half a year, consider learning and preparing with one of our recommended languages, especially if your current language is lower-level e.g. C.
Tips
Don’t assume familiarity equals proficiency. Just because you use a language daily at work doesn’t mean you’ll have no issues coding a solution in an interview. At work, you have the luxury of reading documentation and searching for how to use certain data structures or algorithms. In technical interviews, the solution might skew towards using a specific data structure, like a Priority Queue, and you might find yourself unfamiliar with its syntax. To solve this, practice is key. Ensure you’re familiar with common data structures and their syntax.
Go beyond syntax. Understand the underlying implementations of data structures and algorithms in your chosen language. For instance, knowing the space and time complexity of Python’s sort function will allow you to articulate the space time complexity of your solution.
Communicate with your interviewer. This advice holds true across all interviews, but it’s especially crucial in this particular situation: encountering a question where your chosen programming language lacks built-in support for specific data structures required for the optimal solution. If you face this situation during an interview, clarify whether the interviewer expects you implement the data structure from scratch or if they have a sample/starter code you can use. In some cases, the interviewer may want you to implement a data structure from scratch even if you can import that data structure from the language’s standard library.
If the interviewer allows you to assume the existence of a particular data structure that includes necessary methods and performance specifications, you can simply describe the data structure and its efficiency characteristics instead of spending valuable time implementing it. While interviewers may permit this approach as they are still able to assess your understanding of theoretical concepts and efficient problem-solving, it’s not ideal because they typically expect a working solution. This underscores the importance of selecting a language with a robust library of built-in data structures.
Our top pick: Python
If you have the luxury of time to learn or are already somewhat familiar with Python, we highly recommend using it for your technical interviews. Here are some reasons we find very compelling:
Efficiency through simplicity: Python allows you to achieve a lot with minimal syntax, making it ideal for coding under pressure.
def greet(name):
return f"Hello, {name}!"
print(greet("Bob")) # Output: Hello, Bob!Skip the boilerplate code! Start solving the question from the first line you write.
Extensive library support: Python boasts a vast library of optimized functions and ready-to-use data structures. For instance, Python’s standard library includes robust support for advanced operations like set manipulations that are straightforward to use and efficient in performance.
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}
# Union of sets
union_set = set1.union(set2)
print("Union of sets:", union_set)
# Intersection of sets
intersection_set = set1.intersection(set2)
print("Intersection of sets:", intersection_set)
# Difference of sets
difference_set = set1.difference(set2)
print("Difference of sets (set1 - set2):", difference_set)While the JavaScript developer is busy writing additional code, debugging, and investing mental effort to implement set operations from scratch, the Python developer has already progressed to the next task.
Dynamic typing advantage: Python’s dynamic typing eliminates the need for explicit type declarations, offering flexibility in coding. This is particularly advantageous in tasks where rapid prototyping and adaptability are crucial, such as in data science, machine learning, and analytics.
For example, imagine a scenario where you initially planned to handle strings as both input and output. However, as the interview progressed and requirements evolved, you had to swiftly adapt the function to handle integer inputs and outputs.
def doSomething(a, b):
...
return result
print(add(5, 10))Did you notice the oversight in the Java function's signature? When making changes on the fly, such details can be easily missed, underscoring the advantage of dynamic typing in maintaining code flexibility and adaptability.
Consistent and intuitive APIs: Python provides consistent APIs that operate seamlessly across different data structures, enhancing code readability and usability.
my_list = [1, 2, 3, 4, 5]
my_string = "Hello, World!"
# Printing out length
print("Length of list:", len(my_list)) # Output: 5
print("Length of string:", len(my_string)) # Output: 13
# Printing out sublist
print("First three elements of list:", my_list[:3]) # Output: [1, 2, 3]
print("Last three characters of string:", my_string[-3:]) # Output: ld!Notice the consistent use of the len() function in Python for both lists and strings, compared to using different methods (size() and length()) in Java for ArrayList and String, respectively.
No time wasted on curly brace errors: Unlike languages with curly braces, Python’s syntax relies on indentation for code structure, reducing the time spent debugging syntax errors. A simple missing curly brace, unnoticed initially due to interview stress, can escalate into a frustrating and time-consuming issue.
def do_something():
for i in range(10):
for j in range(5):
if i % 2 == 0:
for k in range(3):
....
else:
...Notice the missing curly brace in the Java solution? In the high-pressure environment of an interview, such oversights can become significant obstacles, particularly without the aid of robust syntax highlighting, auto-formatting or IDE features that programmers rely on in their usual coding environments.
Readability: Python’s syntax is highly readable, often resembling pseudocode, which facilitates clear communication of solutions during interviews. Its widespread adoption also means many interviewers are familiar with Python or can easily understand it due to its pseudocode-like nature.
def find_max(numbers):
max_num = numbers[0]
for num in numbers:
if num > max_num:
max_num = num
return max_num
print("Max number:", find_max([4, 7, 2, 9, 5])) # Output: Max number: 9Which code was easier to read? Python’s code is concise and reads like natural language. In contrast, C++ demands more boilerplate, such as #include directives and explicit type annotations (int, vector). The syntax in C++ — with its curly braces, semicolons, and detailed type handling — might seem less intuitive. This complexity can pose challenges for those unfamiliar with the language’s syntax or for tired interviewers who have conducted interviews all day.
In conclusion, Python’s versatility and readability make it a standout choice for technical interviews, offering both efficiency and clarity in problem-solving scenarios.