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

{"answer": "no", "explanation": "Double-quoted strings process variable interpolation and escape sequences while single-quoted strings treat content literally, so they are not processed identically."}

{"answer": "yes", "explanation": "The null coalescing operator (??) follows isset() semantics and does not emit a warning when the left-hand operand is undefined."}

{"answer": "ab", "explanation": "echo accepts multiple comma-separated arguments and outputs them concatenated in sequence."}

{"answer": "yes", "explanation": "In PHP, print always returns the integer 1 and, unlike echo, can be used inside an expression."}

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

{"answer": "yes", "explanation": "In PHP's precedence table, addition and subtraction (+/-) have higher precedence than the concatenation operator (.), so the statement is true."}

{"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": "sum: 5", "explanation": "In PHP, the addition operator `+` has higher precedence than concatenation `.`, so `2 + 3` is evaluated first to `5`, then concatenated with `'sum: '`."}

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

```json ⏎ {"answer": "no", "explanation": "The statement is false because `0 == false` actually returns `true` (since 0 is loosely coerced to false), and `==` is a loose comparison, not a strict one (which is `===`)."} ⏎ ```

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

{"answer": "yes", "explanation": "In PHP's loose comparison (==), null is coerced to the same empty value as 0, an empty string, and false, so it equals all three simultaneously."}

```json ⏎ {"answer": 42, "explanation": "PHP casts a string to an integer by parsing its leading numeric portion, so '42abc' becomes 42."} ⏎ ```

```json ⏎ {"answer": "10", "explanation": "In PHP, when a string is used in arithmetic with a number, it is coerced to a numeric value, so '5' becomes 5 and 5 + 5 equals 10."} ⏎ ```

{"answer": "no", "explanation": "When cast to a string, PHP's `false` becomes an empty string (\"\"), not \"0\"; it's only when compared with loose comparison that `false == 0` evaluates as true."}

{"answer": "yes", "explanation": "In PHP, 0.1 + 0.2 evaluates to 0.30000000000000004 due to floating-point precision, so the strict comparison === 0.3 returns false."}

{"answer": "no", "explanation": "strrev() reverses the string byte by byte rather than character by character, which corrupts multi-byte UTF-8 characters."}

{"answer": "yes", "explanation": "str_contains() returns true when the needle 'world' is found within the haystack 'Hello world', as it was introduced in PHP 8.0."}

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

{"answer": "no", "explanation": "By default, PHP's trim() strips all standard whitespace characters including spaces, tabs, newlines, carriage returns, NUL-bytes, and vertical tabs, not just spaces."}

```json ⏎ {"answer": "6", "explanation": "strlen counts bytes, and 'héllo' has 5 characters where 'é' is 2 bytes in UTF-8, giving 6 bytes total."} ⏎ ```

{"answer": "def", "explanation": "A negative offset in substr counts from the end of the string, so -3 starts at 'd' and returns the last three characters."}

{"answer": "false", "explanation": "In PHP, strings are immutable, so ucfirst() returns a new string with the first character capitalized rather than modifying the original in place."}

{"answer": "yes", "explanation": "Heredoc supports variable interpolation like double-quoted strings, while nowdoc (using single-quoted delimiter) does not interpolate variables like single-quoted strings."}

{"answer": "no", "explanation": "The sort() function sorts array values by their values but reindexes the array with new numeric keys, so it does not preserve the original key-to-value association (unlike asort(), which does)."}

{"answer": "yes", "explanation": "In PHP, string keys that represent valid nonnegative integers are automatically coerced to integers, so '5' is stored as integer 5."}

{"answer": "no", "explanation": "in_array() uses loose (non-strict) comparison by default; strict comparison (===) requires passing the optional $strict parameter set to true."}

```json ⏎ {"answer": "yes", "explanation": "Without a callback, array_filter() removes all elements that are falsy, using the same test as the empty() function on each value."} ⏎ ```

{"answer": "no", "explanation": "By default array_slice() reindexes numeric keys; you must pass TRUE as the preserve_keys parameter to keep the original keys."}

{"answer": "[20, 30]", "explanation": "array_slice extracts 2 elements starting from offset 1, preserving original keys (1 and 2)."}

```json ⏎ {"answer": "1", "explanation": "In PHP, the `+` operator unions arrays keeping the left array's values as precedence, so `['a' => 1] + ['a' => 9, 'b' => 2]` results in just `['a' => 1]`, which has one element."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "PHP 8.1 extended the spread operator to support arrays with string keys, allowing associative arrays to be properly merged in array literals."} ⏎ ```

```json ⏎ {"answer": "false", "explanation": "Since PHP 8.1, named arguments can indeed be combined with positional argument unpacking using the ... operator in a single call."} ⏎ ```

{"answer": "no", "explanation": "In PHP, closures do not automatically inherit outer-scope variables; you must explicitly use the 'use' keyword to import them."}

{"answer": "3", "explanation": "func_num_args() returns the total number of arguments passed to the function, which is 3 when called as f(1, 2, 3), regardless of how many parameters the function declares."}

{"answer": "false", "explanation": "Arrow functions in PHP use concise syntax with only a single expression (no curly braces or multiple statements); multi-statement bodies require regular functions."}

{"answer": "no", "explanation": "Arrow functions automatically capture outer variables by value, not by reference, so modifying the outer variable afterward does not affect the arrow function."}

{"answer": "yes", "explanation": "Declaring a closure as static unbinds it, so it no longer captures $this or the bound method context."}

```json ⏎ {"answer": "5", "explanation": "The closure captures $x by value at the time it is created (when $x was 5), so later reassigning $x to 7 does not affect the returned value."} ⏎ ```

{"answer": "yes", "explanation": "In weak typing mode without strict_types, PHP coerces numeric strings like '5' to integers when passed to an int parameter, so this is allowed."}

```json ⏎ {"answer": "yes", "explanation": "Constructor property promotion was introduced in PHP 8.0, allowing properties to be declared directly in the constructor parameters with visibility modifiers."} ⏎ ```

{"answer": "final", "explanation": "The 'final' keyword prevents a method or class from being overridden or extended by subclasses."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, declaring a method with the final keyword prevents any subclass from overriding it, resulting in a fatal error if attempted."} ⏎ ```

{"answer": "no", "explanation": "Private properties are only accessible within the class that defines them, so a subclass cannot access private properties inherited from its parent."}

```json ⏎ {"answer": "class@anonymous\\", "explanation": "In PHP, an anonymous class is given an auto-generated name in the format `class@anonymous\\0<path>:<line>$<id>`, where the `\\0` is a NUL byte that separates the fixed prefix from the file path, line, and instance ID; get_class() returns this name, and the part before the NUL byte is `class@anonymous\\`."} ⏎ ```

{"answer": "yes", "explanation": "Private methods are class-scoped and not inherited, so they do not participate in the inheritance contract, allowing a child class to declare a method with the same name under any visibility without conflict."}

```json ⏎ {"answer": "no", "explanation": "__get() is invoked when reading from both non-existent AND inaccessible (non-accessible) properties, not only for non-existent ones."} ⏎ ```

{"answer": "Error", "explanation": "In PHP 8.1+, reassigning a readonly property that has already been initialized throws an Error (specifically a \"Cannot modify readonly property\" error), not a regular Exception."}

```json ⏎ {"answer": "yes", "explanation": "Since PHP 7.1, interfaces can declare constants, and these constants are implicitly public and must be constant expressions."} ⏎ ```

{"answer": "instanceof", "explanation": "The instanceof operator in PHP checks whether an object is an instance of a class or interface."}

{"answer": "yes", "explanation": "Since PHP 8.0, interfaces can declare static methods, so in modern PHP the statement is true."}

{"answer": "no", "explanation": "The instanceof operator in PHP checks class inheritance, interfaces, and implements relationships, so it does not ignore interfaces."}

{"answer": "yes", "explanation": "Since PHP 8.0, interface methods can declare a default implementation, allowing classes to inherit it like trait methods do."}

{"answer": "yes", "explanation": "In PHP, abstract methods can be declared with public, protected, or private visibility, so an abstract method in an abstract class may indeed have protected visibility."}

{"answer": "3", "explanation": "Enum::cases() returns an array of all the enum's case constants, and Foo has three cases (A, B, C), so it returns 3 elements."}

{"answer": "yes", "explanation": "PHP traits can declare constants, properties, and methods that get composed into the using class."}

{"answer": "yes", "explanation": "In PHP 7+, the Throwable interface is indeed the common ancestor of both the Exception class and the Error class, allowing them to be caught together."}

{"answer": "no", "explanation": "TypeError extends Error, not Exception, so a catch (Exception $e) block will not catch it; you must catch (Error $e) or (Throwable $e)."}

{"answer": "no", "explanation": "The @ operator only suppresses errors (like warnings and notices), not exceptions, which continue to propagate and must be caught with try/catch blocks."}

```json ⏎ { ⏎   "answer": "ValueError", ⏎   "explanation": "In PHP, intdiv(5, 0) throws a ValueError exception because dividing an integer by zero with intdiv is an illegal operation." ⏎ } ⏎ ```

{"answer": "no", "explanation": "The finally block always executes regardless of whether an exception was thrown or caught, because it runs after the try/catch blocks unconditionally."}

{"answer": "no", "explanation": "An exception thrown inside a finally block overrides and replaces the original exception from the try block, thus affecting the result."}

{"answer": "true", "explanation": "In PHP any non-empty object cast to boolean evaluates to true, and an Exception object has populated properties so it is not empty."}

```json ⏎ {"answer": "yes", "explanation": "register_shutdown_function() registers callbacks that execute when the script terminates, including when exit() or die() is called."} ⏎ ```

{"answer": "no", "explanation": "The `use` statement only creates a namespace alias and does not load the class file; the file is loaded later when the class is actually referenced via autoloading."}

{"answer": "const", "explanation": "In JavaScript/TypeScript, function bindings imported via default imports behave like const (reassignment is forbidden), whereas the keyword 'function' is never used in import statements."}

```json ⏎ {"answer": "Controller/Api/UserController.php", "explanation": "Under PSR-4, the namespace 'App\\' maps to 'src/', so 'App\\Controller\\Api\\UserController' resolves to the file src/Controller/Api/UserController.php."} ⏎ ```

{"answer": "yes", "explanation": "Composer's vendor/autoload.php includes autoload_real.php which registers multiple autoloader callbacks (for classmap, PSR-4, files, etc.) via spl_autoload_register()."}

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

{"answer": "no", "explanation": "An unqualified class name in new is resolved relative to the current namespace first, with only a backward-compatibility fallback to the global scope—so it is not resolved from the global root."}

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

```json ⏎ {"answer": "yes", "explanation": "Since PHP 7.0, use statements can be declared inside function or method bodies, where the import applies only to that local scope."} ⏎ ```

{"answer": "yes", "explanation": "In PHP 7 and later, arrays are value types that are copied on assignment using copy-on-write semantics rather than being passed by reference."}

{"answer": "2", "explanation": "Arrays in PHP use copy-on-write semantics, so `$b = $a` creates an independent copy and modifying `$b` does not affect `$a`."}

{"answer": "yes", "explanation": "In PHP, user-defined variables declared outside a function exist only in the global scope and cannot be accessed inside a function's local scope unless accessed via the global keyword, the $GLOBALS superglobal array, or passed as a parameter."}

{"answer": "no", "explanation": "Because $GLOBALS['x'] holds a reference to the actual global variable, unset() removes the global variable entirely, not just within the function's local scope."}

```json ⏎ {"answer": "6", "explanation": "The parameter $x is passed by reference, so the increment applies to $n, making it 6."} ⏎ ```

{"answer": "no", "explanation": "foreach by value operates on an internal copy of the array, so modifications to the array inside the loop are not reflected during the same pass."}

{"answer": "no", "explanation": "Static properties belong to the class itself and are shared across all instances, so changes made through one object are visible in all others."}

{"answer": "no", "explanation": "In PHP, boolean array keys are cast to integers (true becomes 1, false becomes 0), so they are not stored as bool."}

{"answer": "yes", "explanation": "Generators in PHP support returning a value via the return statement, and this value can be retrieved using $generator->getReturn() after the generator has completed execution."}

```json ⏎ {"answer": "yes", "explanation": "By default, PHP generators are rewinding iterators, so calling rewind() on a fully consumed generator resets it and allows it to be traversed again."} ⏎ ```

{"answer": "yes", "explanation": "yield from correctly delegates traversal to an inner generator or any iterable, forwarding values in both directions."}

{"answer": "Generator", "explanation": "A function containing `yield` becomes a generator function, so calling it returns a Generator object whose class name is \"Generator\"."}

{"answer": "3", "explanation": "The generator yields the three values 1, 2, and 3 via `yield from`, so `iterator_to_array` produces a 3-element array and `count()` returns 3."}

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In First Out) stack, while FIFO queue behavior is provided by SplDoublyLinkedList set to SplDoublyLinkedList::IT_MODE_LIFO with FIFO mode, or by the SplQueue class."}

{"answer": "yes", "explanation": "ArrayIterator is an SPL class that wraps an array and implements the Iterator interface, allowing traversal using foreach, rewind(), current(), key(), next(), etc."}

{"answer": "false", "explanation": "ArrayObject implements IteratorAggregate, making it Traversable and therefore fully usable with foreach."}

{"answer": "yes", "explanation": "password_hash() automatically generates a random salt and embeds it in the resulting hash, so providing a separate salt is unnecessary and the salt parameter was even removed in PHP 8.0."}

{"answer": "no", "explanation": "PASSWORD_DEFAULT uses bcrypt (currently) rather than md5, and md5 is considered insecure and should not be used for password hashing."}

{"answer": "true", "explanation": "password_hash generates a hash of 'secret' and password_verify compares the plaintext 'secret' against it, returning true because they match."}

{"answer": "false", "explanation": "strip_tags() only removes HTML and PHP tags to mitigate XSS attacks; it provides no protection against SQL injection, which requires parameterized queries or prepared statements."}

{"answer": "yes", "explanation": "session_regenerate_id() changes the session ID after login, invalidating any previously fixed session ID an attacker may have planted, thereby preventing session fixation attacks."}

{"answer": "php_sapi_name()", "explanation": "The php_sapi_name() function returns the description of the current Server API Interface (SAPI) name, such as 'cli', 'fpm', or 'apache2handler".}

{"answer": "yes", "explanation": "session_destroy() only destroys the server-side session data, but it does not remove the session cookie stored in the user's browser, which must be deleted separately using setcookie()."}

```json ⏎ {"answer": "no", "explanation": "The $_SESSION array is only populated with session data after session_start() is called to initialize the session."} ⏎ ```

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3 as part of the new array functions like array_key_first, array_key_last, and array_slice with preserve_keys."}

{"answer": "yes", "explanation": "Property hooks (get/set) were officially introduced in PHP 8.4, allowing direct declaration of getter and setter logic within a property."}

{"answer": "no", "explanation": "Asymmetric visibility (e.g., `public private(set) string $name`) was introduced in PHP 8.2, not PHP 8.4."}

{"answer": "8.2", "explanation": "The #[\NoDiscard] attribute was introduced in PHP 8.2 to allow marking functions whose return values should not be discarded."}

{"answer": "8.0", "explanation": "The pipe operator |> (threading operator) was introduced in PHP 8.0 in late 2020."}

```json ⏎ {"answer": "8.4", "explanation": "The clone-with syntax, which allows passing arguments during cloning like clone($obj, ['x' => 1]), was introduced in PHP 8.4."} ⏎ ```

```json ⏎ {"answer": "7.3", "explanation": "The array_first() and array_last() functions were introduced in PHP 7.3."} ⏎ ```

{"answer": "8.4", "explanation": "The RFC Partial Function Application v2 was adopted for PHP 8.4, introducing the ability to partially apply arguments to arrow functions and closures."}

{"answer": "8.2", "explanation": "The clamp() function was implemented via the clamp_v2 RFC and added to PHP in version 8.2."}

{"answer": "no", "explanation": "The Context Managers RFC (v1) was debated in PHP discussions but did not result in adoption, so the v2 proposal was not adopted as of that date."}

{"answer": "no", "explanation": "There is no recognized PHP RFC titled 'Bound-Erased Generic Types' that was declined in 2026; this appears to be a fabricated proposal."}

{"answer": "no", "explanation": "The RFC to enable ZTS (thread safety) by default in PHP was proposed but not accepted; PHP maintainers have kept ZTS as an opt-in build option rather than making it the default."}

{"answer": "yes", "explanation": "Generics/parameterized types have not been implemented in PHP as of PHP 8.x, and the feature remains absent."}

{"answer": "yes", "explanation": "PHP 8.5 released ~November 2025, and PHP 8.6 is scheduled for ~November 2026 (GA 2026-11-19), so on 2026-11-07 the latest stable version is indeed 8.5."}

{"answer": "yes", "explanation": "PHP 6 was planned as a Unicode-based release but was ultimately abandoned, and PHP 7.0 was released directly after PHP 5.6 without PHP 6 ever shipping."}

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

{"answer": "yes", "explanation": "In clean/onion architecture, the dependency rule requires that inner layers know nothing about outer layers, with dependencies always pointing inward toward the center."}

{"answer": "yes", "explanation": "In a well-layered domain model (DDD/Clean Architecture), domain entities are plain PHP classes depending only on the language and SPL, with persistence concerns like Doctrine mapping kept in a separate infrastructure layer."}

```json ⏎ {"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation layer, not the business-logic layer; they call use cases but do not contain the actual business logic, which lives in the application/domain layers."} ⏎ ```

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

{"answer": "yes", "explanation": "Deptrac performs static analysis of inter-layer dependencies and fails with a non-zero exit code when it detects a forbidden call crossing a layer boundary."}

{"answer": "no", "explanation": "A use case should accept only simple plain domain/value objects, never framework-dependent artifacts like an HTTP request or a Doctrine EntityManager, since that would couple the service layer to infrastructure and defeat the purpose of a clean, testable architecture."}

{"answer": "Repository", "explanation": "The Repository pattern provides a collection-like interface for accessing aggregates/entities while abstracting away the underlying storage mechanism."}

```json ⏎ {"answer": "yes", "explanation": "In clean architecture the database is part of the outer infrastructure layer, so switching databases only requires replacing the data-access adapter behind a port, leaving the domain and application (use case) layers untouched."} ⏎ ```

{"answer": "false", "explanation": "In DDD, an aggregate is a cluster of entities and value objects treated as a unit for consistency, which is a domain concept that does not map one-to-one with a database table."}

{"answer": "yes", "explanation": "Value objects are immutable and define equality based on the values of their fields rather than reference identity, which is a core characteristic of the value object pattern."}

{"answer": "aggregate root", "explanation": "In Domain-Driven Design, the aggregate root is the single entry point through which all modifications to the aggregate's state must pass, ensuring consistency and invariants are maintained."}

{"answer": "yes", "explanation": "In DDD, repositories are created for aggregate roots, and entities within an aggregate are accessed and managed through their root rather than having their own repositories."}

{"answer": "yes", "explanation": "Ubiquitous language is a core Domain-Driven Design concept describing the shared, consistent vocabulary developed collaboratively by developers and domain experts and reflected in the domain model."}

{"answer": "The boundary of a language", "explanation": "In model theory, this refers to the boundary within which a model fixes the interpretation of its language (keeping model and language consistent), while the same terms can denote different models outside it."}

{"answer": "no", "explanation": "DDD actually recommends a rich domain model where objects encapsulate both state and behavior, and an anemic model (logic in services) is widely criticized as an anti-pattern."}

```json ⏎ {"answer": "yes", "explanation": "In Domain-Driven Design, a bounded context defines the boundary within which a model applies, so the same concept can indeed be modeled as different classes in different contexts."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Symfony's DI container instantiates a service only when it is first fetched from the container (on first use), rather than eagerly at compile or boot time."} ⏎ ```

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

{"answer": "no", "explanation": "Symfony's autowiring and autoconfiguration allow services to be automatically wired based on type-hinted constructor arguments without manually declaring every service in services.yaml."}

{"answer": "yes", "explanation": "Twig compiles templates into plain PHP classes and caches the compiled output between requests to avoid recompiling on each request."}

{"answer": "yes", "explanation": "In Symfony's dev environment the compiled DI container is dumped to disk (var/cache/dev) and only regenerated when tracked files change, rather than on every request."}

{"answer": "APP_ENV", "explanation": "Symfony uses the APP_ENV environment variable (with a default via .env file) to select between dev, prod, and test environments."}

{"answer": "no", "explanation": "Controller methods must be public or protected; private methods cannot be called by Symfony's controller resolver because they are only accessible within the class itself."}

```json ⏎ {"answer": "no", "explanation": "Event order is determined by the priority value assigned to each listener or subscriber, not by whether the handler is a listener or an event subscriber—so a high-priority listener can run before a low-priority subscriber."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony 6.0, the old Guard-based authentication system was removed, and authentication is now built on the newer AuthenticatorInterface-based authenticator system."}

{"answer": "IsGranted", "explanation": "The #[IsGranted] attribute checks a role or permission on a controller method and throws an AccessDeniedException (403) if the user lacks the required right."}

{"answer": "yes", "explanation": "Symfony voters are indeed used to check access to a specific object by passing an attribute (like 'EDIT') and a subject object (like $post) to isGranted()."}

{"answer": "yes", "explanation": "Since Symfony 7, Doctrine annotations were removed and validation constraints are declared exclusively via PHP attributes."}

{"answer": "yes", "explanation": "In Symfony, forms have CSRF protection enabled by default via the csrf_protection option (default true), which validates a token on submission."}

{"answer": "yes", "explanation": "Symfony performs server-side validation on every submission regardless of client-side HTML5 checks, which are only for user convenience and can be bypassed."}

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

{"answer": "no", "explanation": "Symfony never stores passwords in the session; it stores only the authenticated user's identity, and passwords are always stored as cryptographic hashes rather than plaintext."}

{"answer": "yes", "explanation": "In Symfony, bundle and topic configurations are organized in the config/packages directory, typically with one file (like framework.yaml, doctrine.yaml, or security.yaml) per bundle or configuration topic."}

{"answer": "yes", "explanation": "The .env file holds committed dev defaults while .env.local is gitignored and used for real, environment-specific secrets."}

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

{"answer": "no", "explanation": "Once the Symfony container is compiled and booted it becomes frozen, so calling $container->setParameter() after that point (e.g., from a controller) throws a LogicException and cannot change runtime parameters."}

{"answer": "no", "explanation": "In Symfony, services are private (public: false) by default and cannot be fetched directly from the container; they must be injected via constructor arguments."}

```json ⏎ {"answer": "no", "explanation": "Bundles in Symfony do not require a config file in config/packages; configuration is optional and bundles use their built-in defaults when no config is provided."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony, environment variables are injected into services.yaml using the %env(VAR)% syntax, which allows services to reference environment variables defined in .env files."}

```json ⏎ {"answer": "APP_DEBUG", "explanation": "In Symfony, the APP_DEBUG environment variable controls whether debug mode is enabled, which activates the profiler and Twig debugging features."} ⏎ ```

{"answer": "no", "explanation": "In Symfony Messenger, a single message can be handled by multiple handlers, as you can register several handlers for the same message type."}

{"answer": "no", "explanation": "The sync transport processes the message immediately in the current request rather than queuing it for a worker to handle asynchronously."}

{"answer": "artisan messenger:work", "explanation": "In Laravel, the messenger component uses the `artisan messenger:work` command to start the worker that consumes and processes queued messenger messages."}

{"answer": "yes", "explanation": "In Symfony Messenger, the retry_strategy (including max_retries, retry_multiplier, and delay) is configured individually for each transport in the messenger configuration."}

{"answer": "yes", "explanation": "By default, Laravel Messenger serializes queued messages to JSON using the JSON serializer."}

{"answer": "no", "explanation": "The Symfony Scheduler component runs periodic tasks by invoking configured closures/actions on a schedule, rather than producing and dispatching messages through the Messenger component."}

{"answer": "Doctrine", "explanation": "The Doctrine transport in Symfony's Messenger component persists messages to database tables managed through Doctrine ORM/ODM."}

```json ⏎ {"answer": "yes", "explanation": "Symfony's Messenger pipeline is a middleware stack where custom middleware can be registered via services and ordered relative to the built-in ones."} ⏎ ```

{"answer": "no", "explanation": "Symfony major releases do come every two years (November), but minor releases happen roughly quarterly (around March, May, August, and October), not just every six months."}

{"answer": "8.3", "explanation": "Symfony 8.0 requires PHP 8.3 or higher as its minimum version."}

{"answer": "no", "explanation": "Symfony 7.0 removed support for DocBlock annotations in favor of PHP attributes, which have been the recommended approach since Symfony 5."}

{"answer": "yes", "explanation": "AssetMapper is a Symfony component that manages frontend CSS/JS dependencies without requiring Node.js or Webpack by using an importmap.php file to declare and track dependencies."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long Term Support) release, released in October 2023 with 5 years of community maintenance and 3 more years of enterprise support."}

{"answer": "yes", "explanation": "Symfony intentionally keeps deprecations from the previous major version working after a major upgrade so developers have time to fix them; they are only removed in the following LTS release, not in the major release itself."}

{"answer": "yes", "explanation": "Symfony documents breaking changes for each major release in UPGRADE files, which are part of the official upgrade documentation."}

{"answer": "symfony/importmap", "explanation": "The symfony/importmap component manages JS/CSS assets through the browser importmap API, eliminating the need for node or webpack."}

{"answer": "no", "explanation": "Symfony follows a schedule where 8.1 is released in May 2026 and the 8.2 LTS version is released around mid-November 2026 (after Nov 7), so as of 2026-11-07, version 8.2 has not yet been released."}

{"answer": "no", "explanation": "Following Symfony's six-month release cadence, November 2026 would bring Symfony 7.3, not 8.2 (8.2 would arrive around 2028), so the specific version claim is false."}

```json ⏎ {"answer": "8.2", "explanation": "Symfony releases minor versions in sequence, so the version immediately following 8.1 is 8.2."} ⏎ ```

{"answer": "no", "explanation": "Symfony 8.2 is a point release within the 8.x major version line, not a separate major release; the major release that introduced new APIs was Symfony 8.0."}

```json ⏎ {"answer": "yes", "explanation": "PHP's backward compatibility policy ensures that code written for 8.1 continues to run under 8.2 within the same 8.x major branch, so updates generally require no code changes."} ⏎ ```

{"answer": "8.2", "explanation": "In Symfony's annual release cycle, each major branch (like 8.x) releases minor versions 0, 1, and 2, so the last 8.x minor before 9.0 is 8.2."}

```json ⏎ {"answer": "false", "explanation": "Symfony's minimum PHP requirement for the 8.x series is expected to be PHP 8.3/8.4, not PHP 8.5, so the claim about requiring PHP 8.5 in Symfony 8.2 is inaccurate."} ⏎ ```

{"answer": "yes", "explanation": "In Symfony's deprecation policy, deprecations added in a minor release (8.x) are scheduled for removal in the next major release (9.0), so they will not be removed before 9.0."}

{"answer": "no", "explanation": "In Twig, {{ }} is used only for outputting the result of an expression, while {% %} is used for executing control statements like if, for, or arbitrary code."}

{"answer": "yes", "explanation": "Twig enables autoescaping by default for most file types such as .html, .php, .twig, .css, and .js, so printed variables are escaped automatically."}

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

{"answer": "number_format", "explanation": "The `number_format` filter in Twig's intl-extra extension formats a number according to the current locale settings."}

{"answer": "yes", "explanation": "The |raw filter in Twig marks a value as raw and disables auto-escaping for it."}

```json ⏎ {"answer": "yes", "explanation": "In Twig, {{ }} is the output marker that prints an evaluated expression's value, while {% %} is the action marker that executes tags such as if, for, and set statements."} ⏎ ```

```json ⏎ {"answer": "false", "explanation": "In Twig you can declare variables inside a template using the {% set %} tag, so values do not only come from the controller."} ⏎ ```

```json ⏎ {"answer": "dump", "explanation": "The Twig dump() function outputs the debug structure (like var_dump) of a variable such as an array or object, but only when Twig is in debug mode."} ⏎ ```

{"answer": "yes", "explanation": "Bootstrap is a CSS/JavaScript component library providing pre-built UI elements like buttons, navbars, and modals, but it does not handle routing or state management, so it is not an SPA framework."}

{"answer": "container", "explanation": "The `.container` class in Bootstrap provides a responsive box with a fixed maximum width that changes at each breakpoint, whereas `.container-fluid` spans 100% width at all breakpoints."}

{"answer": "false", "explanation": "Bootstrap's grid system uses a 12-column layout (not 16), and while Bootstrap 3 used CSS floats, later versions use Flexbox."}

{"answer": "yes", "explanation": "Bootstrap 5 defines five named breakpoints with infixes sm, md, lg, xl, and xxl, corresponding to minimum viewport widths of 576, 768, 992, 1200, and 1400px respectively."}

{"answer": "yes", "explanation": "Bootstrap's spacing utilities reference the $spacers map, whose default values are multiples of the base $spacer variable."}

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, the 'data-bs-toggle' data attribute (prefixed with 'bs-') enables interactive components like dropdowns when added to an element."}

{"answer": "yes", "explanation": "Bootstrap 5 removed its jQuery dependency and all components are implemented in vanilla JavaScript."}

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

```json ⏎ {"answer": "no", "explanation": "Doctrine ORM does not create tables automatically at runtime; you must explicitly run a command like `doctrine:schema:create` to generate the database schema."} ⏎ ```

{"answer": "persist()", "explanation": "The persist() method marks a new object as managed and schedules the INSERT operation to be executed during flush() rather than executing SQL immediately."}

{"answer": "no", "explanation": "In Doctrine ORM 3, the EntityManager::merge() method was removed; it was deprecated in ORM 2.2 and completely removed in ORM 3."}

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

{"answer": "null", "explanation": "In Doctrine ORM, $repository->find() returns the entity if found, or null when no matching record exists."}

{"answer": "no", "explanation": "DoctrineBundle requires you to explicitly call $entityManager->flush() to persist changes; it does not automatically flush at the end of every request."}

{"answer": "yes", "explanation": "For a managed (persistent) entity already tracked by the Unit of Work, modifying a property is enough because flush() runs change detection on all managed entities, so no explicit persist() is needed."}

{"answer": "no", "explanation": "In Doctrine ORM, remove() only schedules the entity for deletion by marking it for removal in the Unit of Work; the actual SQL DELETE is not executed until flush() is called."}

{"answer": "no", "explanation": "PostgreSQL's MVCC specifically allows readers and writers to proceed concurrently without blocking each other by giving each transaction a snapshot of the data."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command displays a query's execution plan without actually executing the query, unlike EXPLAIN ANALYZE which both plans and runs the query."}

{"answer": "no", "explanation": "SERIAL is a legacy PostgreSQL mechanism that implicitly creates a sequence and sets a default via nextval(), while GENERATED ... AS IDENTITY is the SQL-standard approach that also uses sequences but offers more control and different behavior, so they are not the same."}

{"answer": "no", "explanation": "In PostgreSQL, a UNIQUE constraint allows multiple rows with NULL values because NULLs are not considered equal to each other in SQL semantics."}

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

{"answer": "no", "explanation": "Plain VACUUM reclaims dead-tuple space for reuse within the table but does not return it to the operating system; only VACUUM FULL (or trailing-page removal) releases space back to the OS."}

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

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

{"answer": "yes", "explanation": "PostgreSQL runs in autocommit mode by default, so each standalone SQL statement is automatically wrapped in and committed as its own implicit transaction."}

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

{"answer": "yes", "explanation": "Indexes speed up SELECT queries by avoiding full table scans, and they also benefit UPDATE and DELETE operations because the database can use the index to quickly locate the rows matching the WHERE clause on the indexed column rather than scanning the entire table."}

{"answer": "yes", "explanation": "SAVEPOINT in PostgreSQL lets you set a mark within a transaction so you can roll back only the statements executed after that point using ROLLBACK TO SAVEPOINT."}

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

{"answer": "pgvector", "explanation": "pgvector is the PostgreSQL extension that adds vector data types and index types (such as IVF, HNSW) for similarity search and embedding-based retrieval."}

{"answer": "yes", "explanation": "A partial index created with CREATE INDEX ... WHERE ... only indexes the rows that satisfy the WHERE predicate condition."}

{"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which detects serialization failures via read/write/write-write dependency conflicts rather than locking the rows read."}

{"answer": "yes", "explanation": "HTTP 201 Created status code indicates that the request was successfully processed and resulted in the creation of a new resource."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates the request succeeded but there is no content to return, which is the standard response for a successful DELETE operation."}

{"answer": "yes", "explanation": "DELETE is idempotent per the HTTP specification, meaning making multiple identical DELETE requests results in the same outcome (the resource is removed and further deletes yield a 404 without additional state change)."}

{"answer": "false", "explanation": "The Access-Control-Allow-Origin header is sent by the server (not the client) to indicate that a response can be shared with the specified origin."}

```json ⏎ {"answer": "yes", "explanation": "HTTP 429 Too Many Requests is specifically defined to indicate that a user has sent too many requests in a given amount of time, triggering a rate limit."} ⏎ ```

{"answer": "no", "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 resource being sent in the request or response body."}

{"answer": "yes", "explanation": "RFC 5789 explicitly states that PATCH is not required to be idempotent, whereas PUT is required to be idempotent per RFC 7231."}

{"answer": "no", "explanation": "Using plain == is unsafe because of PHP's type juggling, where hashes starting with '0e' followed by digits (like some md5 hashes) are loosely compared as equal to 0, enabling authentication bypass; strict === or hash_equals() should be used instead."}

```json ⏎ {"answer": "yes", "explanation": "A CSRF token is generated by the server and stored in the session, then included in forms and validated server-side on unsafe requests to prevent cross-site request forgery."} ⏎ ```

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header is the standard mechanism browsers use to enforce CSP restrictions on resources."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework that grants access to resources, not an authentication protocol, and an access token by itself does not tell you who the user is—OpenID Connect provides authentication."}

{"answer": "no", "explanation": "XSS is prevented by encoding/escaping output when rendering data in the browser, not by sanitizing input before storing it in the database, since data must be stored in its raw form and encoded contextually on output."}

```json ⏎ {"answer": "code (authorization code)", "explanation": "In the OAuth 2.0 authorization code flow, the authorization server redirects the client with a temporary \"code\" parameter, which the client then exchanges for an access token at the token endpoint."} ⏎ ```

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

{"answer": "no", "explanation": "Salts are not meant to be secret; they are stored alongside the hash and their security comes from uniqueness and randomness, not from secrecy."}

{"answer": "yes", "explanation": "PHPUnit discovers and runs test methods via reflection based on the 'test' prefix or @test annotation convention, so a class does not strictly need to extend TestCase, though it then lacks the usual assertion helpers and lifecycle features."}

{"answer": "no", "explanation": "In PHPUnit, setUp() runs before EACH test method, not once before all tests of the class."}

{"answer": "no", "explanation": "A data provider allows a test to run multiple times, once for each set of arguments it provides, rather than just one."}

{"answer": "expectException()", "explanation": "PHPUnit's expectException() method declares that an exception of the specified class is expected to be thrown during the test."}

{"answer": "no", "explanation": "The statement is reversed: a mock verifies which methods were called on it, while a stub only provides return values without verifying calls."}

```json ⏎ {"answer": "yes", "explanation": "In PHPUnit 10, the @dataProvider docblock annotation was deprecated in favor of the #[DataProvider] attribute, which is now the recommended way to specify data providers."} ⏎ ```

{"answer": "no", "explanation": "PHPUnit allows test dependencies through the @depends annotation, enabling one test to depend on and receive the return value of another test's result."}

{"answer": "--randomize-order", "explanation": "The --randomize-order option (previously --order-by=random) shuffles the execution order of tests in PHPUnit."}

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

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

```json ⏎ {"answer": "true", "explanation": "Both '1e1' and '10' are numeric strings, so PHP compares them as numbers where '1e1' equals 10, making the condition true."} ⏎ ```

```json ⏎ {"answer": "zero", "explanation": "The switch uses loose comparison, so 'a' == 0 evaluates to true because the non-numeric string 'a' is converted to 0."} ⏎ ```

```json ⏎ {"answer": "2c", "explanation": "With the array form, strtr replaces the longest matching key first, so 'ab' is matched and replaced with '2', leaving '2c'."} ⏎ ```

{"answer": "[]", "explanation": "substr('hello', -10) returns an empty string because -10 is 10 characters before the end of a 5-character string, which is before the start, so the output is just the brackets."}

```json ⏎ {"answer": "k,n,m", "explanation": "The array union operator + keeps the left array's keys with their values, then adds only the right array's elements whose keys are absent, giving keys k, n, m in order."} ⏎ ```

{"answer": "yxz", "explanation": "usort sorts the rows by their third element (2,1,2) ascending into [[2,'y',1],[1,'x',2],[3,'z',2]], then array_column extracts index 1 ('y','x','z') which implode joins into \"yxz\"."}

```json ⏎ {"answer": "4", "explanation": "Argument unpacking maps by key name, so $a=5 and $b=1, giving 5-1=4."} ⏎ ```

{"answer": "3", "explanation": "The `...` inside `$p->g(...)` uses PHP 8.1 first-class callable syntax, creating a bound Closure (equivalent to `fn() => $this->g()`) that retains a reference to the object even after `$p = null`, so `$f()` returns the private `$v` value of 3."}

{"answer": "B", "explanation": "The method uses `static::class`, which relies on late static binding and resolves to the runtime class `B` when called on an instance of `B`."}

{"answer": "Fatal error (infinite recursion), no output", "explanation": "The `set` hook assigns to `$this->x`, which is the same hooked property, so it re-invokes the set hook with the transformed value repeatedly until PHP's recursion depth limit is hit, producing a fatal error before `echo` ever runs."}

```json ⏎ {"answer": "BA", "explanation": "The conflict for f() is resolved so TC::f() comes from TB (returning 'B'), while TA::f() is aliased as g() (returning 'A'), producing the concatenation 'BA'."} ⏎ ```

{"answer": "0", "explanation": "Each class that uses a trait gets its own separate copy of the trait's static property, so setting CX::$n = 1 does not affect CY::$n, which stays 0."}

{"answer": "2", "explanation": "In PHP, a return statement in a finally block overrides the return value from the try block."}

{"answer": "second", "explanation": "The inner try throws RuntimeException which is overridden by the exception thrown in the finally block (LogicException 'second'), which then propagates to the outer catch that echoes its message."}

{"answer": "App\\Foo|Baz", "explanation": "Within namespace N, Baz is imported as an alias for App\\Foo so Baz::class resolves to App\\Foo, while the fully-qualified \\Baz refers to a non-existent global Baz class and simply resolves to its literal name 'Baz'."}

{"answer": "yesyes", "explanation": "In namespace Ns, class_exists('Foo') resolves to Ns\\Foo (current namespace prepended since no leading backslash) which exists, and class_exists('Ns\\\\Foo') is the fully-qualified name which also exists, so both return true."}

{"answer": "1,2,99", "explanation": "The foreach with &$v leaves $v referencing the last element $a[2], so $v = 99 reassigns $a[2], producing 1,2,99."}

```json ⏎ {"answer": "3", "explanation": "The static variable $n is scoped to the function inc() and is shared across all instances of A and its subclass B, so inc() is called three times with ++$n incrementing the same shared $n to 3."} ⏎ ```

{"answer": "11", "explanation": "send(10) starts the generator, sets $x to 10 via the yield, causes the function to return 11, and getReturn() retrieves that returned value which is then echoed."}

{"answer": "1,2,ok", "explanation": "yield from delegates inner()'s yields (1, 2) to outer, and the return value 'ok' is captured in $r and then also yielded, so the generator produces 1, 2, 'ok'."}

{"answer": "noyes", "explanation": "The hash is created with cost 4, so it doesn't need rehashing when asking for cost 4 (outputs 'no'), but it does need rehashing when asking for cost 5 (outputs 'yes')."}

{"answer": "strict-out", "explanation": "In PHP 8.4+ the E_STRICT error level (value 2048) was removed from the E_ALL bitmask, so E_ALL & 2048 now equals 0, making the ternary evaluate to 'strict-out'."}

{"answer": "mapped", "explanation": "The server var HTTP_X_TOKEN is converted by Symfony into the X-Token header (with underscores replaced by dashes), so headers->get('X-Token') returns 'abc', satisfying the strict comparison."}

```json ⏎ {"answer": "BCA", "explanation": "Listeners with higher priority execute first, so priority 10 (B) runs before priority 5 (C) runs before default priority 0 (A)."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Doctrine's identity map (Unit of Work) caches entities by primary key, so both find() calls return the same instance registered after the first load."} ⏎ ```

{"answer": "0", "explanation": "Because the newly persisted entity is removed before flush, Doctrine's UnitOfWork discards it entirely, so no INSERT is issued and the table stays empty."}

{"answer": "1", "explanation": "count(x) counts only non-NULL values of x, so the NULL is excluded and only the value 1 is counted."}

{"answer": "10,30,60", "explanation": "The inner window function computes running sums of x (10, 30, 60), and string_agg concatenates these text values ordered by id with a comma delimiter."}

```json ⏎ {"answer": "M1M2", "explanation": "The MessageBus runs middleware in registration order, so M1's handle() echoes 'M1' before delegating to M2, whose handle() echoes 'M2' before invoking the final handler, producing the concatenated output 'M1M2'."} ⏎ ```

```json ⏎ {"answer": "0", "explanation": "The aliases 'h1' and 'h2' do not match the message type 'Ping', so HandleMessageMiddleware's resolve() method (which requires 0 === strpos($messageType, $alias.'@')) yields no handlers and neither closure is invoked."} ⏎ ```

{"answer": "1", "explanation": "The unique index causes the second insert to be ignored via ON CONFLICT DO NOTHING, so only one row remains in the table."}

{"answer": "2", "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, its validity is checked only at COMMIT, not after each INSERT, so both duplicate inserts succeed and the table holds 2 rows when queried."}

```json ⏎ {"answer": "6", "explanation": "The --filter uses a regex, so test_sum matches both test_sum (3 data-provider tests) and test_sum_abs (3 data-provider tests), totaling 6, while test_other doesn't match."} ⏎ ```

{"answer": "2, 1", "explanation": "The data provider supplies two cases ([1] and [-1]), so 2 tests run; test_x(1) passes while test_x(-1) fails the assertTrue check."}

```json ⏎ {"answer": "POST", "explanation": "The `-d` flag sends data via the HTTP POST method by default in curl."} ⏎ ```

{"answer": "GET", "explanation": "The -d flag normally sends POST data in the body, but combining it with -G moves the data into the URL query string, which forces curl to use the GET method."}

{"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, an unknown client_id causes client authentication to fail, resulting in the 'invalid_client' error response."}

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access_token is returned in the URI fragment (the part after the #), which the browser does not send to the server."}

```json ⏎ {"answer": "6", "explanation": "The default filter returns 2 because false is considered empty, then 2 * 3 evaluates to 6."} ⏎ ```

{"answer": "Twig\\Error\\RuntimeError", "explanation": "Since '+' and '~' share the same precedence and are left-associative, the expression evaluates as ('a' ~ 1) + 2 = 'a1' + 2, and Twig throws a Twig\\Error\\RuntimeError because it cannot add an integer to the string 'a1'."}

{"answer": "0", "explanation": "The NotBlank constraint is applied to the entire array `['']` (arrays passed to validate() are validated as a whole, not iterated), and since an array is neither null nor an empty string, no violation is triggered, so count() returns 0."}

```json ⏎ {"answer": "invalid", "explanation": "isValid() returns false for a form that has not been submitted (it does not throw), so the ternary outputs 'invalid'."} ⏎ ```

{"answer": "same", "explanation": "By default Symfony DI services are shared (singleton), so after compile() the container caches the instantiated stdClass and $c->get('a') returns the identical instance both times, making the spl_object_id comparisons equal."}

```json ⏎ {"answer": "hi Bob!", "explanation": "The ContainerBuilder recursively resolves parameter placeholders, so '%greeting%!' becomes 'hi %name%!' and '%name%' becomes 'Bob', yielding 'hi Bob!'."} ⏎ ```

```json ⏎ {"answer": "960px", "explanation": "In Bootstrap 5.3, the .container reaches its 'lg' breakpoint max-width of 960px at the min-width: 992px breakpoint."} ⏎ ```

{"answer": "text-primary", "explanation": "Both text-danger and text-primary set the color property, so the class that appears later in the source order (text-primary) wins due to equal specificity and cascade order."}

```json ⏎ {"answer": "2", "explanation": "The OrderService class is in the Domain layer (App\\Domain), which may only depend on Domain itself, so its dependencies on Application\\PlaceOrder and Infrastructure\\Db each constitute a violation."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "BillingService is in the Domain layer, which may only depend on Domain, so each of its 3 external dependencies (Application\\PlaceOrder, Infrastructure\\Db, Infrastructure\\Logger) counts as a separate violation."} ⏎ ```

{"answer": "10,15", "explanation": "The add() method returns a new Money object with amount 15 (10+5), while the original $a retains amount 10."}

{"answer": "1", "explanation": "The add() sets items to ['a'=>true]; remove() throws DomainException because count===1 before the unset runs, so the catch swallows it and items still has 1 element, making count() return 1."}

{"answer": "hi", "explanation": "The code instantiates class C, immediately calls hi() which returns the string 'hi', and echoes it."}

{"answer": "yesno", "explanation": "newLazyGhost creates an uninitialized ghost object, so isUninitializedLazyObject returns 'yes'; accessing $o->v triggers the initializer (setting v=21) and marks the object initialized, so the second call returns 'no'."}

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

{"answer": "noyes", "explanation": "In Symfony 8.x, the deprecated AnnotationClassLoader was removed (returning 'no'), while the AttributeClassLoader remains available (returning 'yes')."}