📚

Languages & Quiz Syllabus

We test a broad range of programming fundamentals, runtime environments, memory structures, and concurrency protocols. Learn what to expect at each level.

C

C Programming Language

C is the foundation of modern system engineering, operating systems, and resource-constrained environments. Quizzes test direct memory allocation, compilation phases, and CPU instruction mappings.

Difficulty Breakdown:

  • EASY: Primitive data types (`int`, `char`, `float`), loops (`for`, `while`), basic mathematical expressions, and simple functions.
  • MODERATE: Pointers, array indexing, structs, basic preprocessor directives (`#define`, `#include`), and standard input/output (`printf`, `scanf`).
  • HARD: Dynamic memory allocation (`malloc`, `calloc`, `realloc`, `free`), double pointers, memory leaks, bitwise manipulation, union structs, function pointers, and custom header file linkage.
C++

C++ Language

C++ extends C with Object-Oriented features, templates, and deterministic resource management (RAII). Testing covers class design, copy/move constructors, and the Standard Template Library (STL).

Difficulty Breakdown:

  • EASY: Namespaces, basic I/O (`cin`, `cout`), function overloading, reference variables, and simple class syntax.
  • MODERATE: Standard OOP concepts (encapsulation, inheritance, polymorphism), access specifiers, basic STL containers (`std::vector`, `std::string`), constructors, and destructors.
  • HARD: Template classes, virtual functions, abstract classes, move semantics, smart pointers (`std::unique_ptr`, `std::shared_ptr`), diamond inheritance, exception handling safety, and advanced STL algorithms.
J

Java Language

Java is an enterprise-grade, platform-independent language running on the JVM. Tests evaluate compile-time vs runtime checks, thread states, collection frameworks, and memory models.

Difficulty Breakdown:

  • EASY: Class structure, variables, primitive types vs wrapper classes, string manipulation, and loop statements.
  • MODERATE: Interfaces, abstract classes, encapsulation, standard collections (`ArrayList`, `HashMap`), method overriding, checked/unchecked exceptions, and basics of generics.
  • HARD: JVM memory divisions (Stack vs Heap, Garbage Collection algorithms), Multithreading (`synchronized`, `volatile`, ThreadPools), reflection API, Java Streams, lambda functions, and class loaders.
Py

Python Language

Python is a dynamically typed, high-level language popular for scripting, web development, and AI. Quizzes verify scopes, interpreter internals, comprehension lists, and functional design patterns.

Difficulty Breakdown:

  • EASY: Syntax rules, indentation, basic list/dictionary operations, type conversions, and simple file handling.
  • MODERATE: List comprehensions, scope levels (LEGB rule), exceptions, default parameter behavior, built-in functions (`map`, `filter`, `zip`), and simple class structures.
  • HARD: Decorators, generators, context managers (`with` statement), metaclasses, dynamic object attributes (`__getattr__`, `__slots__`), GIL (Global Interpreter Lock), and asyncio coroutines.
Ko

Kotlin Language

Kotlin is a modern, statically typed language that is the first-class choice for Android. Tests cover compile-time null safety safeguards, Kotlin extension systems, and lightweight thread constructs (coroutines).

Difficulty Breakdown:

  • EASY: Variables (`val` vs `var`), smart casts, basic nullability checks (`?`, `!!`), string interpolation, and function syntax.
  • MODERATE: Data classes, companion objects, extensions, collection operations (`filter`, `map`), default parameters, and scope functions (`let`, `run`, `apply`, `also`).
  • HARD: Coroutines and Structured Concurrency (dispatchers, channels, flow), delegation (properties and classes), inline classes, reified type parameters, DSL builders, and Java interoperability.
C#

C# Language

C# is a modern object-oriented language developed by Microsoft for enterprise, desktop, web, and game development. Quizzes evaluate garbage collection, LINQ expressions, asynchronous control flows, and delegates.

Difficulty Breakdown:

  • EASY: Basic types, syntax structure, namespace uses, console manipulation, properties, and standard control statements.
  • MODERATE: Abstract classes vs Interfaces, structures vs classes, delegates and events, basic LINQ queries, and basic generics.
  • HARD: Asynchronous patterns (`async`, `await`, `Task`), memory management (`ref struct`, `Span`), expression trees, advanced LINQ mechanics, reflection, and garbage collection configurations.
Go

Go (Golang)

Go is built by Google for cloud-native backends and networking services. Tests explore concurrency structures (channels), memory layouts (slices vs arrays), interface designs, and defer patterns.

Difficulty Breakdown:

  • EASY: Struct definitions, variables, simple loops (no `while`), import dependencies, and standard arrays.
  • MODERATE: Pointers, slices (length vs capacity, backing arrays), maps, struct tags, error handling paradigms, and interfaces.
  • HARD: Concurrency tools (`goroutines`, buffered vs unbuffered `channels`, `select` blocks), `sync` package (mutexes, WaitGroups), context propagation (`context.Context`), memory allocation (escape analysis), reflection, and `defer` stack sequencing.
JS

JavaScript Language

JavaScript fuels the dynamic functionality of the web. Testing centers on modern ECMAScript standards (ES6+), lexical execution contexts, prototype chains, and asynchronous loop operations.

Difficulty Breakdown:

  • EASY: Variables (`var`, `let`, `const`), function scopes, loop basics, array functions (`push`, `pop`, `shift`), and primitive types vs object mutations.
  • MODERATE: Closures, lexical `this` context, basic ES6 features (destructuring, spread operator, template literals), DOM manipulation basics, and JSON operations.
  • HARD: Prototype inheritance patterns, event loop lifecycle (microtasks vs macrotasks), asynchronous handling (promises, async/await generators), custom modules (CommonJS vs ESM), currying, and memory leak patterns.