ASM Technologies | C++ Developer | 3 YOE

ASM Technologies | C++ Developer | 3 YOE | 3 Rounds | Selected

Recently, I interviewed with ASM Technologies for a C++ Developer position. The overall process consisted of 3 technical rounds and was heavily focused on Core C++, OOP, Design Patterns, Multithreading, and problem-solving.

Sharing my interview experience here. Hopefully, it will help others preparing for similar C++ roles.

---

Round 1 - Coding + Core C++ | ~45 mins

The interviewer started with a brief introduction and quickly moved to a coding problem.

Coding Question

Find the maximum length substring containing all unique characters.

The interviewer expected a complete working solution.

I first explained the brute-force approach, implemented it in C++, and walked through the logic. He tested my solution with multiple test cases, and it passed successfully.

After that, most of the discussion was around Core C++.

Questions included:

• Smart Pointers
  • What are smart pointers?
  • Why do we need them?
  • Implement any one smart pointer from scratch.
• What is the mutable keyword? Where is it useful?
• Virtual Functions
  • Why do we need virtual functions?
  • How does runtime polymorphism work?
  • Explain with a small C++ program.
• Explain the SOLID principles.
• Design Patterns
  • Explain any one design pattern.
  • Give a practical/real-world use case.
• Explain the Rule of 3.
• Explain the Rule of 5.
• Why do we need copy/move constructors and assignment operators?

One thing I noticed was that the interviewer was more interested in code-based explanations than textbook definitions. For almost every C++ concept, I was expected to explain it and then demonstrate it with a small program.

Result: Cleared Round 1

---

Round 2 - Core C++ + Multithreading + Design Patterns

The round started with introductions from both sides.

The first question was:

"Tell me about a key contribution you made in your current project."

There were a few follow-up questions based on my answer and the technical decisions involved.

Another interesting question was:

"How are you using AI in your daily life/work?"

After that, the discussion moved toward C++.

Some of the questions I remember:

• Explain the four pillars of OOP.
• Demonstrate runtime polymorphism using a C++ program.
• Write a template function.
• Write a template class.
• How do you pass a unique_ptr to a function?
  • Passing by value
  • Passing by reference
  • Using std::move
  • Ownership implications
• Several other Core C++ questions.
• Multiple questions related to multithreading.
• Implement the Singleton Design Pattern.
• What design patterns do you use in your current project?
• Explain any design pattern of your choice.

Again, they were interested in whether I could write code and explain practical use cases, rather than simply defining concepts.

Result: Cleared Round 2

---

Round 3 - Panel Round | Toughest Round

This was the toughest and most interesting round.

There were 3 panelists - 2 from India and 1 from Singapore.

The other two panelists focused more on design, C++ internals, and problem-solving.

Design Pattern Identification

The second panelist showed me a design/UML-style diagram and asked me to identify:

"Which design pattern is being used here?"

After I identified the pattern, there were several follow-up questions:

• Why do you think this design pattern is being used?
• What are the advantages of using this pattern here?
• What problem does it solve?
• What would happen if we didn't use this pattern?
• Are there alternative ways to design the same thing?

I found this question interesting because instead of asking:

"Explain XYZ design pattern."

they gave an existing design and expected me to recognize the pattern and justify why it was appropriate.

Multiple Inheritance

The third panelist focused heavily on C++ inheritance.

Questions included:

• What is multiple inheritance in C++?
• What problems can occur with multiple inheritance?
• Explain the diamond problem.
• How can we solve the diamond problem?
• Explain virtual inheritance.

He then gave me a design/problem that used multiple inheritance and asked:

"Can you achieve the same functionality without using multiple inheritance?"

This led to a discussion around:

• Composition over inheritance
• Interfaces / abstract classes
• Restructuring the class hierarchy
• Reducing coupling between classes

Coding Question - Random Egg Sampling

This was an interesting problem.

There is an egg tray containing 12 eggs, indexed from 0 to 11.

You are provided with a function:

rand(min, max)

which returns a random integer within the specified range.

The requirement was:

1. First, randomly choose k, the number of eggs to sample, using the same rand(min, max) function.
2. Then select k random eggs from the tray.
3. All selected egg indices must be unique.
4. The same egg cannot be selected twice.
5. The expected complexity was approximately O(k + 12).

For example:

k = rand(1, 12)

Suppose it returns:

k = 4

Then a valid result could be:

[2, 9, 5, 0]

All four indices must be unique.

The important part was that k itself was not provided as input. It also had to be randomly generated using the given rand(min, max) function.

After generating k, the challenge was to efficiently select k unique random indices without repeatedly generating numbers and checking for duplicates.

There were follow-up discussions around the approach, uniqueness, randomness, and time complexity.

---

Overall Experience

Overall, the interview process was heavily focused on C++ fundamentals and practical understanding.

This was not an interview where memorizing definitions would be enough. For many questions, they expected me to:

• Explain the concept.
• Write a small C++ program demonstrating it.
• Explain why/when it is useful.
• Discuss alternatives and trade‑offs.
• Answer follow‑up questions based on the implementation.

For anyone preparing for a similar C++ Developer role with 2‑4 YOE, I would recommend preparing these topics thoroughly:

• Core C++ / Modern C++
• OOP concepts
• Virtual functions and runtime polymorphism
• Smart pointers
• unique_ptr, shared_ptr, and weak_ptr
• Implementing a basic smart pointer from scratch
• Copy constructor and copy assignment
• Move constructor and move assignment
• Rule of 3 / Rule of 5
• Templates
• Multiple inheritance
• Diamond problem
• Virtual inheritance
• Composition vs inheritance
• Multithreading
• Mutex / locks / condition variables
• SOLID principles
• Design patterns
• Singleton pattern
• Factory pattern
• Recognizing design patterns from UML/design diagrams
• Basic DSA and problem‑solving

One major takeaway for me was:

For C++ interviews, don't just prepare "What is X?". Prepare "Show me X using code."

If you are preparing smart pointers, write a basic smart pointer yourself. If you are preparing runtime polymorphism, write the program. If you are preparing Singleton, implement it. If you are preparing multithreading, actually write programs using threads, mutexes, and synchronization.

I was able to answer almost all of the questions across the three rounds.

Final Verdict: SELECTED

Hope this helps anyone preparing for C++ Developer / Software Engineer interviews.

All the best!