Карта знаний PHP — ornith-1.5:35b, run-25 · think: low

{"answer": "false", "explanation": "Double-quoted strings process escape sequences and interpolate variables, while single-quoted strings are treated almost literally, so they are not processed identically."}

{"answer": "yes", "explanation": "The null coalescing operator ?? follows isset semantics and does not raise an undefined variable warning."}

{"answer": "ab", "explanation": "In PHP, echo accepts multiple comma-separated arguments and outputs them in sequence, so 'a' and 'b' print together as 'ab'."}

{"answer": "yes", "explanation": "In PHP, print is a language construct that always returns the integer 1 and, unlike echo, can be used inside expressions."}

{"answer": "no", "explanation": "The ?: (elvis) operator returns the left operand when it is truthy, not when it is falsy; it returns the right operand only when the left operand is falsy."}

{"answer": "yes", "explanation": "In PHP, the arithmetic operators (+ and -) have higher precedence than the concatenation operator (.), so concatenation indeed has lower precedence than addition and subtraction."}

{"answer": "no", "explanation": "The ** operator in PHP is right-associative, so 2 ** 3 ** 2 evaluates as 2 ** (3 ** 2) = 2 ** 9 = 512, not (2 ** 3) ** 2 = 64."}

{"answer": "3", "explanation": "The concatenation operator `.` has higher precedence than `+`, so it evaluates as `('sum: ' . 2) + 3` = `'sum: 2' + 3`, and since `'sum: 2'` is a non-numeric string it converts to 0, giving `0 + 3 = 3`."}

{"answer": "no", "explanation": "With ===, arrays are equal only if they have the same key/value pairs in the same order and of the same types, so element order matters."}

{"answer": "no", "explanation": "The statement is false because 0 == false actually returns true with loose comparison, and == is a loose (not strict) comparison operator."}

{"answer": "yes", "explanation": "In PHP, loose comparison converts the non-numeric string \"abc\" to 0, so \"abc\" == 0 evaluates to 0 == 0, which is true."}

{"answer": "yes", "explanation": "In PHP loose comparison, null loosely equals 0, the empty string, and false simultaneously because all of these compare as equal under the == operator."}

{"answer": 42, "explanation": "In PHP, casting a string with the int type cast converts the leading numeric portion of the string, so '42abc' becomes 42."}

{"answer": "10", "explanation": "The + operator forces numeric coercion, converting the string '5' to the integer 5, so 5 + 5 equals 10."}

{"answer": "no", "explanation": "When false is cast to string in PHP, it becomes an empty string \"\", not \"0\"; the integer 0 is the string representation of the number, but the boolean false itself becomes an empty string."}

{"answer": "yes", "explanation": "Due to floating-point precision, 0.1 + 0.2 evaluates to 0.30000000000000004, which is not strictly equal to 0.3."}

{"answer": "false", "explanation": "strrev() reverses the string byte-by-byte rather than character-by-character, which corrupts multibyte UTF-8 characters instead of reversing them correctly."}

{"answer": "yes", "explanation": "str_contains() checks if a string contains a substring and returns true when 'world' is found in 'Hello world'."}

{"answer": "false", "explanation": "str_pad() can pad a string on the left, right, or both sides using STR_PAD_LEFT, STR_PAD_RIGHT, or STR_PAD_BOTH, not the right side only."}

{"answer": "no", "explanation": "trim() by default also strips tabs, newlines, carriage returns, NUL-bytes, and vertical tabs, not just spaces."}

{"answer": "6", "explanation": "strlen counts bytes, and while the string has 5 characters, the é character is encoded as 2 bytes in UTF-8, giving a total of 6 bytes."}

{"answer": "def", "explanation": "With a negative offset, PHP's substr starts counting from the end of the string, so -3 begins at 'd' and returns the remaining characters 'def'."}

{"answer": "false", "explanation": "ucfirst() returns a new string with the first letter capitalized but does not modify the original string in place, since PHP strings are immutable."}

{"answer": "yes", "explanation": "Heredoc syntax supports variable interpolation while nowdoc (introduced in PHP 7) works like a single-quoted string and does not interpolate variables."}

{"answer": "no", "explanation": "The sort() function sorts the array's values in ascending order but reassigns numeric keys, so it does not preserve the key-to-value association (asort() would be used for that)."}

{"answer": "yes", "explanation": "In PHP, when an array key is a numeric string that looks like an integer (like '5'), it is automatically converted to an integer key, while non-numeric strings remain as keys."}

{"answer": "no", "explanation": "in_array() uses loose (non-strict) comparison by default; strict comparison only applies when the third $strict parameter is explicitly set to true."}

{"answer": "yes", "explanation": "Without a callback, array_filter() uses the default behavior of keeping only elements that pass a truthiness test, thereby removing all falsy/empty values like false, 0, \"0\", null, and empty strings."}

```json ⏎ {"answer": "yes", "explanation": "array_slice() preserves the original keys by default; you must pass 'true' as the $preserve_keys parameter to reindex them."} ⏎ ```

```json ⏎ {"answer": "[20, 30]", "explanation": "array_slice starts at offset 1 (element 20) and returns the next 2 elements: 20 and 30."} ⏎ ```

{"answer": "2", "explanation": "In PHP, the + operator for arrays keeps the left array's values for matching keys and appends new keys from the right array, so the result is ['a' => 1, 'b' => 2] which has 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 introduced support for the spread operator with string keys in array literals, whereas previously it only worked with integer-indexed arrays."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "In PHP, named arguments cannot be mixed with argument unpacking using the ... operator in a single function call, as this combination triggers a fatal error." ⏎ } ⏎ ```

{"answer": "no", "explanation": "In PHP, an anonymous function does not automatically inherit outer-scope variables; they must be explicitly imported via the use keyword."}

{"answer": "3", "explanation": "func_num_args() returns the total number of arguments passed to the function, and f(1, 2, 3) passes three arguments."}

{"answer": "false", "explanation": "PHP arrow functions use the fn keyword and can only contain a single expression; they do not support curly-brace blocks or multiple statements (that requires a regular closure)."}

{"answer": "no", "explanation": "In PHP, arrow functions automatically capture outer variables by value, not by reference, unlike regular anonymous functions which require an explicit use clause to capture by reference."}

{"answer": "yes", "explanation": "In PHP, a closure declared as static does not capture $this, while a non-static closure defined inside a class method automatically captures the current $this instance."}

{"answer": "5", "explanation": "In PHP, closures capture variables by value when using use() unless the variable is passed by reference (&$x), so the closure takes a snapshot of $x's value (5) at creation time, and changing $x to 7 afterward does not affect it."}

{"answer": "yes", "explanation": "In weak typing mode, PHP coerces numeric strings like \"5\" to the corresponding int value when passed to an int parameter."}

{"answer": "yes", "explanation": "Constructor property promotion was introduced in PHP 8.0, allowing properties to be declared directly in the constructor parameter list."}

{"answer": "final", "explanation": "The `final` keyword prevents a method (or class) from being overridden in subclasses in PHP."}

{"answer": "yes", "explanation": "In PHP, marking a method as final prevents any subclass from overriding it."}

{"answer": "no", "explanation": "Private members in PHP are only accessible within the class that declares them, so a subclass cannot directly access a parent's private properties."}

{"answer": "@anonymous", "explanation": "get_class(new class {}) returns the anonymous class's fully-qualified name formatted as @anonymous\\0<file_path>, so the part before the NUL byte is @anonymous."}

{"answer": "yes", "explanation": "Private methods are not inherited in PHP and are not part of the inheritance contract, so a child class may freely declare a same-named method with any visibility without conflict."}

{"answer": "no", "explanation": "__get() is triggered for both non-existent AND inaccessible (private/protected) properties, not only non-existent ones."}

{"answer": "Error", "explanation": "In PHP 8.1+, attempting to reassign a readonly property outside its declaring scope throws an Error instance (a 'Cannot modify readonly property' error), not a generic Exception."}

{"answer": "yes", "explanation": "Since PHP 7.1, interfaces can declare constants with the const keyword, which are implicitly public and static."}

{"answer": "instanceof", "explanation": "In PHP, the instanceof operator determines whether an object is an instance of a particular class or interface."}

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces are allowed to declare static methods, and calling classes must implement them to satisfy the interface contract."}

{"answer": "false", "explanation": "The instanceof operator in PHP checks if an object is an instance of a class, implements an interface, or is compatible with the given type, so it does not ignore interfaces."}

{"answer": "yes", "explanation": "In PHP 8.0 and later, interface methods can have a default implementation with a method body, similar to trait methods."}

{"answer": "yes", "explanation": "In PHP, abstract methods can declare any visibility modifier (public, protected, or private), so an abstract method in an abstract class may indeed be protected."}

{"answer": "3", "explanation": "The static method Foo::cases() returns an array containing all defined cases of a PHP 8.1 enum, and this enum has exactly 3 cases."}

{"answer": "false", "explanation": "In PHP, traits can declare methods and properties, but they cannot declare constants; attempting to do so produces a fatal error."}

```json ⏎ {"answer": "yes", "explanation": "In PHP 7+, the Throwable interface is the common ancestor implemented by both Exception and Error classes."} ⏎ ```

{"answer": "false", "explanation": "TypeError extends Error, not Exception, so both implement Throwable independently and a catch (Exception $e) block will not catch a TypeError—you need to catch (Throwable $e) instead."}

{"answer": "no", "explanation": "The @ operator only suppresses PHP errors (warnings, notices, etc.), not exceptions, which are thrown and caught by try/catch blocks regardless of the @ operator."}

{"answer": "DivisionByZeroError", "explanation": "In PHP, intdiv() throws a DivisionByZeroError (which extends ArithmeticError) when the divisor is zero."}

{"answer": "false", "explanation": "The finally block always executes regardless of whether an exception was thrown or caught, as it is used for cleanup code that must run in all cases."}

```json ⏎ {"answer": "no", "explanation": "An exception thrown in the finally block propagates out and overrides any return value or exception from the try block, so it does affect the result."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, casting any object (including an Exception) to bool always yields true, since objects are never considered falsy during a bool cast (only empty() can return false for objects)."}

```json ⏎ {"answer": "yes", "explanation": "Functions registered with register_shutdown_function() are guaranteed to run even when exit() or die() is called, including on fatal errors."} ⏎ ```

{"answer": "no", "explanation": "The use statement only creates a namespace alias; the actual class file is loaded by the autoloader when the class is first referenced, not by the use statement itself."}

```json ⏎ {"answer": "no", "explanation": "Functions (and classes) are imported using the `import` keyword; neither `function` nor `const` is used in the import statement."} ⏎ ```

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the App\\ namespace prefix to the src/ directory, so the remaining namespace segments (Controller\\Api\\User) become the file path Controller/Api/UserController.php under src/."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php loads composer/autoload_real.php, which registers the classmap, files, and PSR-4 autoloaders via spl_autoload_register()."}

{"answer": "yes", "explanation": "__NAMESPACE__ is a magic constant in PHP that returns the name of the current namespace."}

{"answer": "no", "explanation": "In PHP, an unqualified class name in a new statement is resolved relative to the current namespace, not the global root."}

{"answer": "yes", "explanation": "Under PSR-4, the 'App\\' namespace prefix maps to the 'src/' directory, so 'App\\Model\\User' corresponds to the file 'src/Model/User.php'."}

{"answer": "yes", "explanation": "In PHP, a use statement for namespace imports can be placed inside a function body, and the import then applies only within that function's block scope."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, arrays are value types that use copy-on-write semantics, so assigning an array to a new variable creates a copy rather than a reference."} ⏎ ```

{"answer": "2", "explanation": "Arrays in PHP are value types and are copied on assignment (copy-on-write), so modifying $b does not affect $a, which still has 2 elements."}

{"answer": "yes", "explanation": "In PHP, global variables have function-local scope by default and must be explicitly made accessible inside a function using the 'global' keyword, the '$GLOBALS' array, or by being passed as parameters."}

{"answer": "no", "explanation": "unset($GLOBALS['x']) removes the global variable entirely (via the $GLOBALS reference array) so it is destroyed globally, not just for that function."}

{"answer": "6", "explanation": "The parameter is passed by reference (&$x), so $x++ increments the original $n to 6."}

{"answer": "no", "explanation": "foreach iterating by value works on a copy (snapshot) of the array, so modifications made to the array inside the loop are not visible in the same pass."}

{"answer": "no", "explanation": "Static properties belong to the class itself and are shared across all instances, so changes are visible in every object, not isolated per instance."}

{"answer": "no", "explanation": "In PHP, boolean array keys are not stored as booleans; they are coerced to strings, where true becomes \"1\" and false becomes an empty string.\""}

{"answer": "yes", "explanation": "In PHP, using `return $value;` inside a generator stores the value, which can be retrieved via `$gen->getReturn()` after the generator is exhausted (available since PHP 7.1)."}

{"answer": "no", "explanation": "Generators are single-use iterators; once fully consumed, rewind() throws a RuntimeException and the generator cannot be traversed again."}

{"answer": "yes", "explanation": "The `yield from` construct delegates traversal to another generator or iterable, forwarding sent values, thrown exceptions, and returned values, as defined in PEP 380."}

```json ⏎ {"answer": "Generator", "explanation": "A function containing the yield keyword becomes a generator function, so calling g() returns a Generator object whose class name is Generator."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "The generator yields 1, 2, and 3 via iterator_from, and iterator_to_array collects all three (with auto-incremented keys 0,1,2) into a 3-element array that count() returns."} ⏎ ```

{"answer": "no", "explanation": "The SplStack class implements a LIFO (Last In First Out) stack, not a FIFO queue."}

{"answer": "yes", "explanation": "ArrayIterator is an SPL class that wraps an array and implements the Iterator interface to traverse its contents."}

{"answer": "no", "explanation": "ArrayObject implements the Traversable interface, so instances can indeed be traversed with foreach."}

{"answer": "yes", "explanation": "password_hash() automatically generates a cryptographically secure random salt internally and embeds it in the output, so passing a separate salt is unnecessary and not supported via the API."}

{"answer": "false", "explanation": "PASSWORD_DEFAULT in PHP 8 uses bcrypt (PASSWORD_BCRYPT), not md5, though it does automatically generate a salt."}

{"answer": "yes", "explanation": "password_verify returns true when the plaintext 'secret' matches the hash generated by password_hash of the same 'secret' value."}

```json ⏎ {"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags from a string, which helps mitigate XSS attacks but offers no protection against SQL injection; preventing SQL injection requires parameterized queries or proper input escaping."} ⏎ ```

{"answer": "yes", "explanation": "session_regenerate_id() generates a new session ID upon login, invalidating any previously attacker-fixed session ID and thus preventing session fixation attacks."}

{"answer": "php_sapi_name()", "explanation": "The php_sapi_name() function returns the name of the SAPI (Server Application Programming Interface) being used, such as \"cli\", \"apache2handler\", or \"fpm-fcgi\"."}

{"answer": "yes", "explanation": "session_destroy() only destroys the session data on the server; it does not delete the session cookie stored in the user's browser."}

{"answer": "no", "explanation": "The $_SESSION array is only populated after session_start() is called, which initializes the session and loads the stored session data."}

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3 as part of the new array search functions."}

{"answer": "yes", "explanation": "Property hooks were introduced in PHP 8.4, allowing get/set (and other) logic to be defined directly within the property declaration."}

{"answer": "yes", "explanation": "Asymmetric visibility, which allows declarations like `public private(set) string $name`, was indeed introduced in PHP 8.4."}

{"answer": "8.2", "explanation": "The #[\\NoDiscard] attribute was introduced in PHP 8.2 to allow warning when the return value of a function is discarded."}

{"answer": "8.3", "explanation": "The ergonomic pipe operator (|>) was introduced in PHP 8.3, which was released in November 2024."}

{"answer": "8.4", "explanation": "The clone-with syntax clone($obj, ['x' => 1]) was introduced as an experimental feature in PHP 8.4."}

{"answer": "7.3", "explanation": "array_first() and array_last() were introduced in PHP 7.3."}

{"answer": "8.3", "explanation": "The RFC Partial Function Application v2 was adopted as a feature for PHP 8.3."}

{"answer": "8.4", "explanation": "The clamp() function was implemented in PHP 8.4 via the clamp_v2 RFC."}

{"answer": "yes", "explanation": "The Context Managers RFC (v2) was successfully voted on and adopted into PHP, adding the `with` statement syntax for resource-scoped cleanup."}

```json ⏎ {"answer": "false", "explanation": "There is no real RFC or proposal called \"Bound-Erased Generic Types\" declined in 2026; this is a fabricated concept, so the statement is false."} ⏎ ```

{"answer": "false", "explanation": "As of the stated date, no accepted RFC has made Zend Thread Safety (ZTS) the default build; PHP's standard default remains non-thread-safe (NTS)."}

```json ⏎ {"answer": "yes", "explanation": "PHP has never implemented true generics (parameterized types) in its core language, and no such feature has been added as of PHP 8.4/8.5, though static analyzers support them via docblock templates."} ⏎ ```

{"answer": "yes", "explanation": "PHP releases major feature versions annually in November, so with 8.5 released in late 2025, the not-yet-released 8.6 GA in November 2026 makes 8.5 the latest stable version on that date."}

{"answer": "yes", "explanation": "PHP 6 (originally the Unicode-focused branch) was abandoned and never released, so PHP 5.6 was directly followed by PHP 7.0 in December 2015."}

{"answer": "yes", "explanation": "The Deprecated attribute RFC was adopted and the #[\\Deprecated] attribute was implemented in PHP 8.2 core."}

{"answer": "yes", "explanation": "In clean and onion architecture, the dependency rule requires that source code dependencies point inward toward the core, so inner layers never depend on or know about outer layers."}

```json ⏎ {"answer": "yes", "explanation": "Domain entities in domain-driven/clean architecture should be pure language code with no dependency on frameworks like Symfony or persistence tools like Doctrine, keeping the domain layer isolated and testable."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation layer, not the business-logic layer, since they are concerned with I/O and user interaction rather than application rules."} ⏎ ```

{"answer": "Domain entities (business rules and domain objects)", "explanation": "In onion architecture, the innermost layer contains the core domain entities and business rules, which are independent of any external concerns."}

{"answer": "yes", "explanation": "Deptrac is a static layer-dependency analyzer that fails the build when it detects forbidden cross-layer calls."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "Use cases must remain decoupled from framework concerns like HTTP requests or the EntityManager, accepting only plain input data and returning plain output so they stay testable and transport/persistence-agnostic." ⏎ } ⏎ ```

```json ⏎ {"answer": "Repository", "explanation": "A repository is a component that provides a collection of aggregates/entities while hiding the underlying storage mechanism behind an interface, centralizing persistence logic."} ⏎ ```

{"answer": "yes", "explanation": "Because clean architecture uses dependency inversion with the database behind a repository abstraction in the outer infrastructure layer, swapping databases only requires changing that implementation while the domain and application (use case) layers remain untouched."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of entities and value objects treated as a unit for changes, with an aggregate root serving as the consistency boundary; it is a conceptual domain concept, not a database table."}

{"answer": "yes", "explanation": "Value Objects are defined by their attribute values rather than identity, so they should be immutable and compared by the values of their fields."}

{"answer": "Aggregate root", "explanation": "In Domain-Driven Design, an aggregate root is the single external entry point through which all changes to the aggregate and its members must occur, ensuring consistency and invariant enforcement."}

{"answer": "yes", "explanation": "In DDD, repositories are created only for aggregate roots, and the entities within an aggregate are accessed and managed through the root, not via separate repositories."}

{"answer": "yes", "explanation": "Ubiquitous language is a core Domain-Driven Design concept where developers and domain experts share a common, precise vocabulary describing the domain and its model."}

```json ⏎ {"answer": "Boundary of meaning", "explanation": "In model theory, the boundary within which a model and its language are consistent is the 'boundary of meaning,' beyond which the same words/symbols are reinterpreted to denote other models."} ⏎ ```

{"answer": "no", "explanation": "DDD purists, including Eric Evans, recommend rich domain models where objects encapsulate both state and behavior, viewing anemic models as a common anti-pattern rather than a recommended style."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a bounded context defines a boundary within which a specific model applies, so the same concept (e.g., 'Customer') is modeled as a distinct class in each context."}

```json ⏎ {"answer": "yes", "explanation": "Symfony's DI container instantiates services on demand when they are first requested or injected, rather than eagerly creating all services upfront."} ⏎ ```

{"answer": "debug:router", "explanation": "The `debug:router` console command displays a list of all registered routes in a Symfony application."}

{"answer": "false", "explanation": "Symfony autowiring automatically infers and injects constructor dependencies based on type hints, so services do not need to be manually declared in services.yaml (it is even enabled by default in modern Symfony versions)."}

{"answer": "yes", "explanation": "Twig compiles templates into optimized PHP classes and caches them in a directory between requests for performance."}

```json ⏎ {"answer": "no", "explanation": "In the Symfony dev environment the DI container is regenerated on every request, whereas the rebuilt-only-when-tracked-files-change behavior (the classmap cache optimization) applies to the production environment."} ⏎ ```

{"answer": "APP_ENV", "explanation": "The APP_ENV environment variable controls which Symfony runtime environment (dev, prod, test) is active, replacing the older SYMFY_ENV variable in modern versions."}

```json ⏎ {"answer": "yes", "explanation": "Symfony resolves controllers using PHP reflection, which can invoke any method regardless of visibility, so a controller method can technically be private as long as the route references it."} ⏎ ```

{"answer": "no", "explanation": "Event subscribers do not automatically receive events before listeners; ordering is determined by the explicit priority value each registers with, not by whether it is a subscriber or listener."}

{"answer": "yes", "explanation": "The old Guard authentication system was deprecated in Symfony 5.6 and removed in Symfony 6.0, replaced by the new AuthenticatorInterface-based system."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute checks whether the authenticated user holds a specific role or permission, throwing an AccessDeniedException (HTTP 403) if not granted."}

{"answer": "yes", "explanation": "Voters are indeed Symfony's mechanism for evaluating access control, and passing an object (like $post) as the second argument to isGranted() triggers voter evaluation against that specific object."}

{"answer": "yes", "explanation": "Symfony 7 dropped the doctrine/annotations package and all annotation mapping drivers, so validation constraints must now be declared using PHP attributes like #[Assert\NotBlank]."}

{"answer": "yes", "explanation": "Symfony enables CSRF protection by default for forms, automatically including a hidden _token field and validating it during form submission unless explicitly disabled."}

{"answer": "yes", "explanation": "Symfony always executes server-side form validation when the form is processed, regardless of whether client-side HTML5 checks pass, since HTML5 validation can be bypassed and is not a reliable security measure."}

{"answer": "make:form", "explanation": "The `make:form` command from Symfony MakerBundle scaffolds a form class (FormType)."}

{"answer": "no", "explanation": "Symfony stores the authenticated user's identity (the user object without the password) in the session, not the password itself, and passwords should never be stored in plain text."}

{"answer": "yes", "explanation": "In Symfony, bundle configuration is conventionally stored in config/packages as one YAML file per bundle or topic, such as doctrine.yaml or framework.yaml."}

```json ⏎ {"answer": "yes", "explanation": "This matches the standard convention (e.g., Symfony): .env holds committed dev defaults, while .env.local holds local secrets and is git-ignored."} ⏎ ```

{"answer": "debug:container", "explanation": "The `debug:container` command lists all services registered in the Symfony container along with their aliases."}

{"answer": "no", "explanation": "Once the Symfony container is compiled and frozen, calling setParameter() throws a FrozenException, so parameters cannot be changed at runtime from a controller."}

{"answer": "false", "explanation": "By default, Symfony services are private (public: false); they can only be fetched directly from the container if explicitly made public."}

{"answer": "false", "explanation": "Bundles can work with default settings and only require configuration files when customization is needed, so configuration is not mandatory for every bundle."}

{"answer": "yes", "explanation": "In Symfony, environment variables are referenced in config files like services.yaml using the %env(VAR_NAME)% placeholder syntax, which is resolved at runtime."}

{"answer": "APP_DEBUG", "explanation": "In Symfony, the APP_DEBUG environment variable controls debug mode, which enables the profiler and Twig template debugging features."}

{"answer": "no", "explanation": "In Symfony Messenger, a single message can be handled by multiple handlers registered for that message type."}

{"answer": "no", "explanation": "The sync transport handles the message immediately in the same request, while only the async transport queues the message for a worker to consume later."}

{"answer": "messenger:consume", "explanation": "The `messenger:consume` console command starts the worker that pulls new messages from the transport queue and dispatches them to their message handlers."}

{"answer": "yes", "explanation": "In Symfony's Messenger component, the retry_strategy configuration (max_retries, delay, multiplier, etc.) is defined within each individual transport's settings."}

{"answer": "yes", "explanation": "By default, Symfony Messenger uses the JsonSerializer to serialize messages when sending them through a transport."}

{"answer": "no", "explanation": "The Symfony Scheduler component schedules closures/tasks directly on a timeline and runs them in the process; it does not dispatch messages through the Messenger component."}

```json ⏎ {"answer": "database", "explanation": "The Doctrine database transport stores Messenger messages in database tables using Doctrine ORM/ODM."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony Messenger, middleware services are tagged with messenger.middleware and can specify before/after attributes to control their position relative to the built-in middleware."}

{"answer": "yes", "explanation": "Symfony follows a predictable release cadence with major versions every two years and minor versions every six months in May and November."}

```json ⏎ {"answer": "8.3", "explanation": "Symfony 8, scheduled for release in late 2025, requires PHP 8.3 or higher based on Symfony's versioning roadmap."} ⏎ ```

{"answer": "false", "explanation": "Symfony 7.0 removed all annotation reader support, requiring attributes exclusively for validation and route mapping."}

{"answer": "yes", "explanation": "Symfony's AssetMapper manages frontend assets directly through an importmap.php file, eliminating the need for Node.js, webpack, or other build tooling."}

{"answer": "no", "explanation": "Symfony 6.4 is actually a Long-Term Support (LTS) release, so the claim that it lacks LTS support is false."}

{"answer": "no", "explanation": "In Symfony, deprecations are intentionally removed in the next major release, so deprecations from the previous branch do not keep working after upgrading."}

{"answer": "yes", "explanation": "Symfony conventionally ships an UPGRADE-X.Y.md file with each major release documenting breaking changes and migration steps."}

{"answer": "symfony/importmap", "explanation": "The Symfony ImportMap component manages JavaScript and CSS assets using native ES modules and import maps, eliminating the need for node or webpack."}

{"answer": "yes", "explanation": "Symfony follows a fixed release calendar where LTS versions ship in November of even years, so Symfony 8.2 (LTS) would have been released in early November 2026, before November 7."}

{"answer": "no", "explanation": "Symfony 7.0 was released in May 2025, so following the biannual cadence, Symfony 8.0 would arrive in November 2027 and 8.2 in November 2028—by November 2026 the latest release would be 7.3, not 8.2."}

{"answer": "8.2", "explanation": "Symfony uses major.minor versioning, so the version following 8.1 is 8.2."}

{"answer": "no", "explanation": "Symfony 8.2 is a minor release within the Symfony 8 major line, so it is backward compatible and does not require applications to be rewritten; only major releases (e.g., 8.0) contain breaking changes."}

```json ⏎ {"answer": "yes", "explanation": "PHP uses a versioning scheme where the minor version (8.1 → 8.2) introduces new features while maintaining backward compatibility, so no code changes should be required."} ⏎ ```

{"answer": "8.4", "explanation": "In the Symfony 8.x branch, minor versions are numbered sequentially (8.0, 8.1, 8.2, 8.3, 8.4), with 8.4 being the last minor release before the transition to Symfony 9.0."}

{"answer": "no", "explanation": "Symfony 8's minimum PHP version is PHP 8.3, not PHP 8.5, so the specific claim is false."}

```json ⏎ {"answer": "yes", "explanation": "Symfony's deprecation policy guarantees that any deprecation introduced in the 8.x minor release will remain available (deprecated but functional) until the next major version, 9.0, where it will finally be removed."} ⏎ ```

{"answer": "no", "explanation": "In Twig, {{ }} only evaluates and outputs expressions; arbitrary PHP code execution is done via {% %} blocks using Twig's own statement syntax, not raw PHP."}

```json ⏎ {"answer": "yes", "explanation": "Twig has auto-escaping enabled by default, which escapes variables for HTML output using the 'html' escaper unless overridden."} ⏎ ```

{"answer": "yes", "explanation": "The Twig |e filter escapes a string using the html escaping strategy by default, making it safe for output in an HTML context."}

{"answer": "number_format", "explanation": "The `number_format` filter from Twig's intl-extra extension formats a number according to a locale using PHP's NumberFormatter."}

{"answer": "yes", "explanation": "In Twig, the |raw filter marks a value as safe output, disabling auto-escaping so the value is rendered exactly as-is."}

```json ⏎ {"answer": "yes", "explanation": "In Twig, {{ }} are output tags that render an expression's value while {% %} are control tags that execute logic such as if, for, and set statements."} ⏎ ```

{"answer": "false", "explanation": "Twig allows declaring variables inside a template using the set tag, e.g., {% set x = 42 %}, so values don't only come from the controller."}

{"answer": "dump", "explanation": "The `dump()` function in Twig is used to dump information about a variable, including its debug structure for arrays and objects."}

{"answer": "yes", "explanation": "Bootstrap is indeed a CSS/JavaScript library providing ready-made, responsive UI components rather than a single-page application framework like React, Vue, or Angular."}

{"answer": ".container", "explanation": "The `.container` class in Bootstrap provides a responsive fixed-width container whose max-width changes at each breakpoint."}

{"answer": "no", "explanation": "The Bootstrap grid uses a 12-column layout (not 16), and modern Bootstrap versions (4 and 5) are built on flexbox rather than CSS floats."}

{"answer": "yes", "explanation": "Bootstrap 5 defines exactly five named breakpoints: sm, md, lg, xl, and xxl, which are used as infixes in responsive utility class names."}

```json ⏎ {"answer": "yes", "explanation": "In Bootstrap, spacing utilities reference keys in the $spaces map whose values are derived as multiples (or fractions) of the $spacer variable."} ⏎ ```

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the `data-bs-toggle` attribute (e.g., `data-bs-toggle=\"dropdown\"`) enables interactive components like dropdowns on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 removed the jQuery dependency entirely and rewrote all JavaScript components in vanilla JavaScript."}

```json ⏎ {"answer": "no", "explanation": "Bootstrap 5.3+ enables dark mode via the data-bs-theme=\"dark\" attribute on the root element, not a .dark class."} ⏎ ```

{"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; you must run migrations or use the schema tool to create the database structure from entity mappings."}

{"answer": "persist()", "explanation": "The persist() method marks a new entity as managed and defers the SQL INSERT until flush() is invoked."}

```json ⏎ {"answer": "no", "explanation": "The EntityManager::merge() method was deprecated in Doctrine ORM 2.x and completely removed in Doctrine ORM 3.0, so it no longer exists."} ⏎ ```

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is an object-oriented query language that works with entity names and their mapped properties rather than database tables and columns."}

{"answer": "null", "explanation": "In Doctrine ORM, Repository::find() returns null when no entity exists with the given identifier."}

{"answer": "no", "explanation": "By default Doctrine uses the Unit of Work pattern without auto-flushing; automatic request-end flushing (via uow_end_of_request_commit) is an opt-in feature that is disabled by default."}

{"answer": "yes", "explanation": "In Doctrine ORM, managed entities are tracked by the Unit of Work, so flush() automatically detects and persists property changes without needing an explicit persist() call (which is only required for new entities)."}

{"answer": "no", "explanation": "In Doctrine ORM, remove() only schedules the entity for deletion; the actual SQL DELETE is executed only when flush() is called."}

{"answer": "no", "explanation": "PostgreSQL's MVCC design specifically enables readers and writers to proceed concurrently without blocking each other, which is the primary advantage of multi-version concurrency control."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command displays a query's execution plan without actually running the query against the database."}

{"answer": "no", "explanation": "SERIAL is syntactic sugar that creates an integer column with a default from a sequence (nextval), while GENERATED ... AS IDENTITY uses the SQL-standard identity column mechanism with distinct metadata and behaviors."}

{"answer": "no", "explanation": "In PostgreSQL, NULL values are treated as distinct, so a UNIQUE constraint allows multiple rows with NULL in the same column."}

{"answer": "STRING_AGG", "explanation": "STRING_AGG is the PostgreSQL aggregate function that concatenates values from multiple rows into a single string, separated by a specified separator."}

{"answer": "no", "explanation": "Plain VACUUM only marks the space occupied by dead tuples as reusable for future inserts within the table; it does not return the space to the operating system, which only VACUUM FULL does."}

{"answer": "PARTITION BY", "explanation": "The PARTITION BY keyword in a SQL window function's OVER clause divides the result set into groups (partitions) that the window function is computed over."}

{"answer": "no", "explanation": "READ COMMITTED only protects against dirty reads; non-repeatable reads are prevented by the REPEATABLE READ isolation level."}

{"answer": "yes", "explanation": "In PostgreSQL's default autocommit mode, each individual SQL statement is automatically wrapped in its own implicit transaction that is committed when the statement completes."}

{"answer": "COMMIT", "explanation": "The COMMIT command finalizes a transaction by permanently saving all changes made during it."}

{ ⏎  "answer": "yes", ⏎  "explanation": "Indexes speed up UPDATE and DELETE operations because the WHERE clause can use the index to quickly locate matching rows instead of performing a full table scan." ⏎ }

{"answer": "yes", "explanation": "SAVEPOINT lets you create a marker within a transaction so you can roll back only the statements executed after that point without discarding the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and reports real execution times, whereas plain EXPLAIN shows the plan without executing it."}

{"answer": "pgvector", "explanation": "The pgvector extension adds vector data types and indexing (IVF, HNSW) support to PostgreSQL for similarity search over embeddings."}

{"answer": "yes", "explanation": "A partial index is created with a WHERE clause and only indexes the rows that satisfy that predicate condition."}

{"answer": "no", "explanation": "PostgreSQL's SERIALIZABLE isolation level uses Serializable Snapshot Isolation (SSI), which detects serialization anomalies and aborts transactions via errors rather than locking the rows it reads."}

{"answer": "yes", "explanation": "HTTP 201 Created indicates that the request has been fulfilled and resulted in the creation of a new resource."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates the server successfully processed the request and is not returning any content, which is the standard for DELETE operations."}

{"answer": "yes", "explanation": "DELETE is defined as an idempotent method in the HTTP specification, so sending the same delete request multiple times produces the same server state as sending it once."}

{"answer": "no", "explanation": "The Access-Control-Allow-Origin header is sent by the server in its response, not by the client, to indicate which origins are permitted to access the resource."}

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests is defined to indicate that a user has sent too many requests within a permitted time frame, i.e., a rate limit has been exceeded."}

{"answer": "false", "explanation": "The statement is reversed: 4xx codes indicate client errors, while 5xx codes indicate server-side errors."}

{"answer": "Content-Type", "explanation": "The Content-Type HTTP header specifies the MIME type of the body of a request or response."}

```json ⏎ {"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not required to be idempotent, whereas PUT must be idempotent."} ⏎ ```

{"answer": "no", "explanation": "Using == (loose comparison) on hashes is unsafe because PHP may treat hash strings that look like scientific notation (e.g., '0e...') as floats, allowing a comparison bypass; === (strict comparison) should be used instead."}

{"answer": "yes", "explanation": "A CSRF token is generated by the server, stored in the session, embedded in forms, and validated server-side on state-changing (unsafe) requests, which correctly describes standard CSRF protection."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header allows site administrators to control resources the user agent is allowed to load, thereby enabling the CSP policy."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol; an access token grants access to resources but does not by itself authenticate or identify the user's identity."}

{"answer": "no", "explanation": "XSS is prevented by output encoding/escaping data at the point of rendering, not by sanitizing input before storage, since the same stored data may be output in multiple contexts (HTML, JS, CSS, URL) requiring different encoding."}

{"answer": "code", "explanation": "In the OAuth 2.0 authorization code flow, the authorization code (the 'code' parameter) is returned to the redirect_uri and then exchanged for an access token at the token endpoint."}

{"answer": "yes", "explanation": "Refresh tokens are designed to outlive short-lived access tokens and are specifically used to obtain new access tokens without requiring re-authentication."}

{"answer": "no", "explanation": "Salts are designed to be stored in plaintext alongside the hash; security relies on the hash function, not secrecy of the salt."}

{"answer": "no", "explanation": "PHPUnit's test runner only discovers and executes test methods in classes that extend PHPUnit\\Framework\\TestCase, as the TestCase infrastructure is required to run tests."}

{"answer": "false", "explanation": "In PHPUnit, setUp() runs before EACH individual test method, not once before all tests; the method that runs once before all tests is setUpBeforeClass()."}

{"answer": "no", "explanation": "A data provider allows a test to run with multiple sets of arguments, not exactly one."}

{"answer": "expectException()", "explanation": "The expectException() method in PHPUnit declares an expectation that a given exception class will be thrown during the test."}

```json ⏎ {"answer": "no", "explanation": "The statement is reversed: a stub only returns pre-programmed data, while a mock verifies which methods were called on it."} ⏎ ```

{"answer": "yes", "explanation": "In PHPUnit 10, the @dataProvider annotation was deprecated in favor of using the #[DataProvider] attribute for passing data to test methods."}

{"answer": "no", "explanation": "PHPUnit allows test dependencies through the @depends annotation, which lets one test depend on the result of another."}

{"answer": "--randomize-order", "explanation": "PHPUnit uses the --randomize-order option (introduced in PHPUnit 10.2) to execute test cases in a random sequence rather than the default deterministic order."}

{"answer": "3-3", "explanation": "intdiv(7,2) returns 3 and intdiv(-7,2) returns -3 because PHP truncates toward zero, so concatenating them yields the string '3-3'."}

{"answer": "-9", "explanation": "In PHP the exponentiation operator `**` has higher precedence than the unary minus, so `-3 ** 2` is parsed as `-(3 ** 2)` which equals `-9`."}

{"answer": "true", "explanation": "Both '1e1' and '10' are numeric strings, so PHP compares them as numbers (10 == 10), yielding true."}

{"answer": "other", "explanation": "The switch uses loose comparison where the non-numeric string 'a' does not loosely equal integer 0, so it falls through to the default case which echoes 'other'."}

{"answer": "2c", "explanation": "When strtr receives an associative array it performs longest-match-first replacement, so at position 0 it matches the longer key 'ab' → '2' and leaves 'c' unchanged."}

{"answer": "[hello]", "explanation": "substr('hello', -10) starts 10 characters from the end, which clamps to the beginning of the 5-character string, returning the entire 'hello', so the output is '[hello]'."}

{"answer": "k,n,m", "explanation": "The + operator combines arrays with the left array's keys taking precedence, so $a + $b = ['k'=>1,'n'=>2,'m'=>3], and array_keys gives k,n,m which implode joins with commas."}

{"answer": "yxz", "explanation": "usort sorts the rows ascending by their third element (2, 1, 2), reordering to [[2,'y',1],[1,'x',2],[3,'z',2]], and array_column + implode extracts the second column giving 'yxz'."}

{"answer": "4", "explanation": "Named arguments unpack the array so $a=5 and $b=1, making the function return 5-1=4."}

{"answer": "3", "explanation": "The `$p->g(...)` first-class callable syntax creates a bound closure that retains a strong reference to the object, so even after `$p = null` the object stays alive and `$f()` invokes `g()`, returning the private property value 3."}

```json ⏎ {"answer": "B", "explanation": "The `static::class` expression uses late static binding, which resolves to the runtime class (B) where the method was actually invoked, not the class where it's defined (A)."} ⏎ ```

{"answer": "10", "explanation": "The `set` hook receives `$value = 5` and writes `$this->x = $value * 2 = 10` directly to the backing field (without re-triggering the hook), so reading `$c->x` outputs 10."}

{"answer": "BA", "explanation": "The trait aliasing resolves the conflict so f() comes from TB (returning 'B') and g() is an alias for TA::f (returning 'A'), concatenating to 'BA'."}

{"answer": "0", "explanation": "In PHP, a static property defined in a trait is copied into each class that uses the trait, so CX::$n and CY::$n are independent; setting CX::$n = 1 does not affect CY::$n, which remains 0."}

{"answer": "2", "explanation": "In PHP, when a finally block contains a return statement, its value overrides the return from the try block, so f() returns 2."}

{"answer": "second", "explanation": "The inner finally block throws a LogicException which overrides the RuntimeException, and this propagates to the outer catch which outputs its message 'second'."}

{"answer": "App\\Foo|Baz", "explanation": "Within namespace N, `Baz` is aliased to `App\\Foo`, so `Baz::class` resolves to `App\\Foo`, while the leading backslash in `\\Baz::class` refers to the global-namespace class `Baz`, which yields the string `Baz`."}

{"answer": "yesno", "explanation": "The first class_exists($c) resolves the unqualified 'Foo' to Ns\\Foo (which exists → 'yes'), while the second class_exists('Ns\\Foo') treats the qualified name (no leading backslash) as relative to the current namespace, resolving to Ns\\Ns\\Foo (which doesn't exist → 'no')."}

{"answer": "1,2,99", "explanation": "The `&$v` makes `$v` reference the last array element after the foreach loop, so `$v = 99` modifies `$a[2]` to 99."}

{"answer": "3", "explanation": "The static variable $n is shared across all instances and inherited methods since it belongs to the scope of method inc() defined in class A, so the three calls increment it to 1, 2, and finally 3 which is echoed."}

```json ⏎ {"answer": "1,2,ok", "explanation": "The outer generator yields 1 and 2 via `yield from inner()`, then assigns inner()'s return value 'ok' to $r and yields it, producing the sequence [1, 2, 'ok']."} ⏎ ```

{"answer": "noyes", "explanation": "The hash is created with cost 4, so password_needs_rehash returns false for cost 4 (no) but true for cost 5 (yes)."}

{"answer": "strict-in", "explanation": "In PHP 8.4+, E_ALL equals 0x5FFF (with E_DEPRECATED removed), which still includes the E_STRICT flag (2048), so E_ALL & 2048 evaluates to 2048, which is not === 0."}

```json ⏎ {"answer": "mapped", "explanation": "Symfony converts the HTTP_X_TOKEN server parameter into the X-Token request header, so headers->get('X-Token') returns 'abc', making the ternary evaluate to 'mapped'."} ⏎ ```

{"answer": "BCA", "explanation": "Symfony EventDispatcher runs listeners in priority order, so 'B' (priority 10) runs first, then 'C' (priority 5), then 'A' (priority 0)."}

{"answer": "same", "explanation": "The EntityManager's first-level identity cache returns the same managed entity instance for repeated finds of the same identifier within a single unit of work."}

```json ⏎ {"answer": "0", "explanation": "persist() schedules the brand-new entity for insertion, but remove() then cancels that pending insert since the entity has no ID yet, so flush() inserts nothing and the table stays empty."} ⏎ ```

{"answer": "1", "explanation": "count(x) only counts non-NULL values of x, and since one row has NULL, only the single value 1 is counted."}

```json ⏎ {"answer": "10,30,60", "explanation": "The inner query computes running sums (10, 30, 60) ordered by id, and the outer string_agg concatenates them in id order separated by commas."} ⏎ ```

{"answer": "M2M1", "explanation": "The MessageBus pushes middleware in array order (M1 then M2) using a LIFO stack, so M2 becomes the outermost middleware and executes first, echoing 'M2' then invoking M1 which echoes 'M1'."}

{"answer": "1", "explanation": "The first INSERT adds the value 1, and the second INSERT hits the unique index conflict and does nothing, leaving one row."}

{"answer": "2", "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, the uniqueness check is postponed until COMMIT, so both INSERTs succeed and the SELECT returns 2 before any transaction boundary."}

{"answer": "6", "explanation": "The `--filter test_sum` pattern matches both `test_sum` and `test_sum_abs` (substring match), so all 6 data-provider combinations (3 for each method) run, while `test_other` is excluded."}

{"answer": "2, 1", "explanation": "The data provider yields two cases (1 and -1), so two tests run, and the assertion $x > 0 fails only for -1, giving one failure."}

{"answer": "POST", "explanation": "The `-d`/`--data` flag makes curl send an HTTP POST request with the data in the request body."}

{"answer": "GET", "explanation": "The -G option tells curl to append the data specified by -d to the URL as a query string and switch the request method to GET instead of the default POST."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 §5.2, when the client authentication fails (e.g., a non-existent client_id), the token endpoint returns the error value 'invalid_client'."}

{"answer": "fragment (after the # in the URL)", "explanation": "In the OAuth 2.0 implicit grant flow (response_type=token), the access_token is returned in the URL fragment/hash portion after the '#' character, so it is not transmitted to the server and avoided in logs."}

{"answer": "6", "explanation": "The `false` value is empty so `default(2)` yields 2, and regardless of operator precedence (whether parsed as `(false|default(2))*3` or `false|default(2*3)`), the result evaluates to 6."}

{"answer": "1", "explanation": "The NotBlank constraint is traversable, so it is applied to the array's single empty-string element (producing one violation), while the array itself is not empty so it adds no violation of its own."}

```json ⏎ {"answer": "Symfony\\Component\\Form\\Exception\\RuntimeException", "explanation": "Calling isValid() on a form that has not been submitted throws a RuntimeException because the form is not complete yet, which is caught and prints the exception class name."} ⏎ ```

{"answer": "same", "explanation": "Services are shared by default in Symfony's DI container, so the compiled container instantiates and caches the object, returning the same instance for both calls."}

```json ⏎ {"answer": "hi Bob!", "explanation": "The container recursively resolves parameters: '%name%' becomes 'Bob', so 'greeting' is 'hi Bob', and '%greeting'!' becomes 'hi Bob!'."} ⏎ ```

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container reaches its 'lg' breakpoint at min-width: 992px, which sets the max-width to 960px."}

```json ⏎ {"answer": "text-danger", "explanation": "In Bootstrap 5.3's compiled CSS, text color utilities are ordered alphabetically, so `.text-danger` appears after `.text-primary` and wins by higher source order (equal specificity)."} ⏎ ```

```json ⏎ {"answer": "2", "explanation": "OrderService is in the Domain layer, which may only depend on Domain, but it imports App\\Application\\PlaceOrder and App\\Infrastructure\\Db, creating two separate dependency violations."} ⏎ ```

{"answer": "3", "explanation": "BillingService is in the Domain layer, and the rule allows Domain to depend only on Domain, so it violates the rules by depending on App\\Application\\PlaceOrder, App\\Infrastructure\\Db, and App\\Infrastructure\\Logger (three forbidden dependencies)."}

```json ⏎ {"answer": "10,15", "explanation": "The add() method returns a new Money with amount 15 (10+5), and $a's amount stays 10 since Money is immutable."} ⏎ ```

{"answer": "1", "explanation": "The remove() method throws a DomainException because count()===1, and since the exception occurs before unset(), the item 'a' is never removed, so count() still returns 1."}

```json ⏎ {"answer": "hi", "explanation": "The code creates a new instance of class C, calls hi() which returns the string 'hi', and echo outputs it."} ⏎ ```

```json ⏎ {"answer": "yreno", "explanation": "The lazy ghost is uninitialized so the first check prints 'yes'; accessing $o->v triggers the initialization callback that sets v=21, so the second check prints 'no', giving 'yreno' with no newlines."} ⏎ ```

```json ⏎ {"answer": "no", "explanation": "The Guard authentication system, including AbstractGuardAuthenticator, was removed in Symfony 7.0, so it does not exist in Symfony 8.1."} ⏎ ```

```json ⏎ {"answer": "noyes", "explanation": "AnnotationClassLoader was removed in Symfony 6.0 (so it doesn't exist in 6.4 or 8.1, printing 'no'), while AttributeClassLoader still exists and prints 'yes'."} ⏎ ```