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

{"answer": "false", "explanation": "Double-quoted strings undergo variable interpolation and escape sequence processing (like \\n, \\t, $var), while single-quoted strings are treated nearly literally, so they are not processed identically and speed is not the difference."}

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

{"answer": "ab", "explanation": "PHP's echo statement accepts multiple comma-separated arguments and outputs them concatenated together."}

```json ⏎ {"answer": "yes", "explanation": "print is a language construct that always returns the value 1, and because it returns a value, it can be used inside an expression like echo cannot."} ⏎ ```

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

{"answer": "yes", "explanation": "In PHP 8.0, the concatenation operator (.) was explicitly given lower precedence than the addition (+) and subtraction (-) operators, so `+`/`-` are evaluated first."}

```json ⏎ {"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": "Concatenation (.) has higher precedence than (+), so 'sum: ' . 2 evaluates to 'sum: 2' first, then 'sum: 2' + 3 converts the non-numeric string to 0 and adds 3, yielding 3."}

{"answer": "no", "explanation": "In PHP, the strict comparison (===) for arrays requires identical key/value pairs in the same order and of the same types, so element order does matter."}

{"answer": "no", "explanation": "The statement is false because `0 == false` uses the loose equality operator (==), which returns true (0 is loosely equal to false), and it is not a strict comparison—that would be `===`, which does return false."}

{"answer": "yes", "explanation": "In a loose (==) comparison, the non-numeric string \"abc\" is converted to the integer 0, so the comparison becomes 0 == 0, which is true."}

{"answer": "yes", "explanation": "In PHP loose comparison, null, 0, empty string, and false all compare equal to each other, so null == 0 == '' == false all evaluate to true."}

{"answer": "42", "explanation": "In PHP, casting a string to int parses the leading numeric portion and ignores trailing non-numeric characters."}

{"answer": "10", "explanation": "In PHP, the arithmetic + operator converts both operands to numbers, so the numeric string '5' becomes 5 and 5 + 5 equals 10."}

{"answer": "no", "explanation": "When cast to string, false becomes an empty string (\"\"), not \"0\"."}

{"answer": "yes", "explanation": "Due to floating-point precision issues, 0.1 + 0.2 equals 0.30000000000000004, not exactly 0.3, so the strict === comparison returns false."}

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

{"answer": "yes", "explanation": "str_contains() returns true when the haystack string contains the specified substring, and 'Hello world' does contain 'world'."}

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

{"answer": "no", "explanation": "By default trim() strips not only spaces but also tabs, newlines, carriage returns, and other whitespace characters."}

```json ⏎ {"answer": "6", "explanation": "strlen counts bytes, and the 'é' character is 2 bytes in UTF-8, so 'héllo' (h+é+l+l+o) equals 1+2+1+1+1 = 6 bytes."} ⏎ ```

{"answer": "def", "explanation": "A negative offset in PHP's substr() counts from the end of the string, so -3 starts at the third character from the end ('d') and returns to the end of the string, yielding 'def'."}

{"answer": "no", "explanation": "ucfirst() returns a new string with the first character capitalized and does not modify the original string, since PHP strings are immutable."}

{"answer": "yes", "explanation": "Heredoc syntax parses and interpolates variables while nowdoc syntax treats content literally without interpolation, similar to single-quoted strings."}

{"answer": "no", "explanation": "sort() reindexes the array with numeric keys starting from zero, so it does not preserve the key-to-value association; asort() is the function that preserves keys."}

{"answer": "yes", "explanation": "In PHP, any string key that looks like a valid integer (such as '5') is automatically converted to an integer key when stored in a regular (non-associative) array."}

{"answer": "no", "explanation": "in_array() uses loose comparison by default; strict comparison requires passing true as the third argument."}

{"answer": "yes", "explanation": "Without a callback, array_filter() keeps only elements that are truthy, effectively removing all falsy (empty) values from the array."}

{"answer": "no", "explanation": "By default array_slice() re-indexes numeric keys starting from 0; you must pass TRUE as the third parameter (preserve_keys) to keep the original keys."}

{"answer": "[20, 30]", "explanation": "array_slice extracts a portion of an array starting at offset 1 and taking 2 elements, giving [20, 30]."}

{"answer": "2", "explanation": "The array + operator unions arrays with left-hand keys taking precedence, so 'a' => 1 stays, and 'b' => 2 is added while the right 'a' => 9 is ignored, resulting in 2 elements."}

{"answer": "yes", "explanation": "PHP 8.1 added support for merging arrays with string keys using the spread operator, whereas previously the string keys would be dropped when spreading."}

{"answer": "no", "explanation": "In PHP 8.1, named arguments CAN be combined with argument unpacking in a single call, provided the unpacked array uses integer (positional) keys."}

{"answer": "no", "explanation": "In PHP, anonymous functions (closures) do not automatically inherit variables from the outer scope; you must explicitly import them using the use keyword."}

{"answer": 3, "explanation": "func_num_args() returns the actual number of arguments passed to the function when it was called, which is 3, regardless of the number of declared parameters."}

{"answer": "false", "explanation": "Arrow functions (fn) in PHP contain exactly one expression that is implicitly returned and cannot use curly braces with multiple statements, unlike regular closures."}

{"answer": "no", "explanation": "PHP arrow functions automatically capture outer variables by value at definition time, not by reference or lazily at use time."}

{"answer": "yes", "explanation": "A static closure uses the 'static' keyword, which prevents it from binding or capturing $this, just like static methods in a class cannot access $this."}

```json ⏎ {"answer": "5", "explanation": "The closure captures $x by value at the time of creation (5), so changing $x to 7 afterward does not affect the already-bound value."} ⏎ ```

{"answer": "yes", "explanation": "In weak typing mode without strict_types, PHP performs coercive type juggling, so the string \"5\" is automatically coerced to the int 5 when passed to an int parameter."}

{"answer": "yes", "explanation": "Constructor property promotion was introduced in PHP 8.0 and allows declaring and initializing properties directly in the constructor parameters."}

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

{"answer": "yes", "explanation": "In PHP, the final keyword prevents a method from being overridden by any subclass."}

{"answer": "no", "explanation": "Private properties in PHP are only accessible within the class that declares them and are not accessible from subclasses or inherited classes."}

{"answer": "Class@anonymous", "explanation": "An anonymous class is given an internal name of the form 'Class@anonymous\\0<file>:<line>', and get_class returns everything before the NUL byte as 'Class@anonymous'."}

```json ⏎ {"answer": "yes", "explanation": "Private methods are not inherited, so they are not part of the child's interface, allowing the child to declare a method with the same name and any visibility (public, protected, or private) without triggering a visibility-compatibility error."} ⏎ ```

{"answer": "no", "explanation": "__get() is invoked not only for non-existent properties but also when accessing inaccessible (private or protected) properties, so the statement is false."}

```json ⏎ {"answer": "Error", "explanation": "In PHP 8.1+, attempting to reassign a readonly property after it has been initialized throws a built-in Error, not an Exception."} ⏎ ```

{"answer": "yes", "explanation": "Since PHP 7.1, interfaces can declare constants using the const keyword."}

{"answer": "instanceof", "explanation": "The instanceof operator in PHP checks 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, in addition to constant and instance method declarations."}

{"answer": "false", "explanation": "The instanceof operator in PHP checks both class inheritance and interface implementation, so it does not ignore interfaces."}

{"answer": "yes", "explanation": "Since PHP 7.1, interface methods can provide default implementations, similar to trait methods."}

{"answer": "yes", "explanation": "In PHP, abstract methods in an abstract class can be declared with any visibility modifier, including protected, private, or public."}

{"answer": "3", "explanation": "Enum::cases() returns an array containing all of the enum's defined cases, so an enum with three cases (A, B, C) will return an array of 3 elements."}

{"answer": "yes", "explanation": "In PHP, traits can declare constants, properties, and methods, which become part of the using class."}

```json ⏎ {"answer": "yes", "explanation": "In PHP 7 and later, the Throwable interface is the common ancestor of both the Exception class and the Error class, both of which implement it."} ⏎ ```

{"answer": "no", "explanation": "TypeError extends from Error, not Exception, so a catch (Exception $e) block will not catch a TypeError since they do not share that inheritance relationship."}

{"answer": "no", "explanation": "The @ operator suppresses errors (warnings/notices/fatal errors) but does not suppress exceptions, which are handled via try/catch blocks."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError (which extends ArithmeticError and Exception) because it performs integer division by zero."}

{"answer": "false", "explanation": "The finally block always runs regardless of whether an exception was thrown, caught, or not caught—it executes after the try/catch block in all circumstances."}

{"answer": "no", "explanation": "An exception thrown inside a finally block overrides and replaces the original exception from the try block, so it does have an effect on the result."}

```json ⏎ {"answer": "false", "explanation": "In PHP, casting an object to boolean returns false only if the object has no accessible properties, and Exception stores its data (message, code, file) internally rather than as member variables, so it is considered empty."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "Shutdown functions registered via register_shutdown_function() are executed when the script terminates, which includes when exit() or die() is called."} ⏎ ```

{"answer": "no", "explanation": "The `use` statement only creates a namespace alias; it does not load the file. Autoloading (via Composer/PSR-4) loads the class file, and only when the class is actually used."}

{"answer": "const", "explanation": "In ES6/JavaScript, a named import of a function creates a const binding, whereas default imports and class-like imports also use const bindings, but the keyword const is what precedes the imported identifier in destructuring/const-style imports rather than the word 'function'."}

{"answer": "Controller/Api/UserController.php", "explanation": "PSR-4 maps the namespace segment after the prefix to directory paths, so App\\Controller\\Api\\UserController maps from the src/ root to src/Controller/Api/UserController.php."}

{"answer": "yes", "explanation": "Composer's vendor/autoload.php calls spl_autoload_register() to register autoloaders for PSR-4, classmap, and files."}

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

{"answer": "no", "explanation": "Inside a namespace, an unqualified class name in a new statement is resolved relative to the current namespace (e.g., `Bar` becomes `CurrentNamespace\\Bar`), not from the global root; you must use a leading backslash (`\\Bar`) to reference the global class."}

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

{"answer": "yes", "explanation": "In PHP, a use statement can be placed inside a function or method body, and its import applies only within that function's local scope."}

{"answer": "yes", "explanation": "In PHP, arrays follow value semantics, so assigning an array to a variable or passing it to a function creates an independent copy rather than a reference to the original."}

{"answer": 2, "explanation": "Arrays in PHP use copy-on-write semantics, so `$a` remains unchanged at [1, 2] after `$b` is modified."}

```json ⏎ {"answer": "yes", "explanation": "In PHP, variables defined in the global scope are not automatically accessible inside functions due to function-local scope rules, requiring the global keyword, $GLOBALS superglobal, or explicit parameter passing to access them."} ⏎ ```

{"answer": "no", "explanation": "Because $GLOBALS holds references to global variables, unset($GLOBALS['x']) actually destroys the global variable entirely, not just within that function's scope."}

{"answer": "6", "explanation": "The parameter $x is passed by reference (&$x), so the increment inside inc() modifies the original variable $n, making it 6."}

{"answer": "no", "explanation": "foreach by value operates on a copy of the array, so modifying the original array inside the loop does not affect the current iteration."}

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

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

{"answer": "yes", "explanation": "A generator can return a value using `return $value;`, and that value is retrieved via the Generator object's `getReturn()` method (available since PHP 7.0)."}

```json ⏎ {"answer": "yes", "explanation": "Generators implement the Iterator interface, so after being fully consumed, calling rewind() resets them to their initial state, allowing them to be traversed again."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, `yield from` delegates traversal to another generator, Traversable object, or array, forwarding all yielded values and return values."}

```json ⏎ {"answer": "Generator", "explanation": "A function containing a yield keyword becomes a generator function that returns a Generator object when called."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "The generator uses yield from to propagate the three values from [1, 2, 3], so iterator_to_array produces an array of 3 elements and count() returns 3."} ⏎ ```

{"answer": "no", "explanation": "SplStack 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 allows traversal through the Iterator interface."}

{"answer": "false", "explanation": "ArrayObject implements IteratorAggregate (and Traversable), so instances can be traversed with foreach."}

{"answer": "yes", "explanation": "password_hash() automatically generates a random salt internally when none is provided, so passing a salt separately is unnecessary and not even supported."}

{"answer": "false", "explanation": "PASSWORD_DEFAULT uses bcrypt (currently), not md5, because md5 is a fast cryptographic hash unsuitable for secure password hashing."}

{"answer": "true", "explanation": "password_verify returns a boolean, and since 'secret' matches the hash of 'secret', it returns true."}

{"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags from a string; it does not prevent SQL injection, which requires parameterized queries or proper input escaping."}

{"answer": "yes", "explanation": "session_regenerate_id() issues a new session ID upon login, which prevents an attacker from using a pre-set (fixed) session ID to hijack the authenticated session."}

{"answer": "php_sapi_name", "explanation": "The php_sapi_name() function returns the server API interface (SAPI) type PHP is running as, such as 'cli' for the command line interface."}

{"answer": "yes", "explanation": "session_destroy() only removes the server-side session data; it does not delete the session cookie stored in the user's browser, which must be cleared separately via setcookie()."}

{"answer": "no", "explanation": "The $_SESSION array remains empty until session_start() is called, which initializes and populates it with the session data."}

{"answer": "7.3", "explanation": "The array_find() function was introduced in PHP 7.3 alongside array_find_key() and other array search functions."}

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

{"answer": "yes", "explanation": "Asymmetric visibility (e.g., `public private(set) string $name`) was indeed introduced in PHP 8.4, allowing a property to be publicly readable but privately writable."}

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

{"answer": "7.4", "explanation": "The fat pipe (pipe) operator |> was first introduced as an experimental feature in PHP 7.4 before becoming fully stable in PHP 8.0."}

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

{"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 via the `...` placeholder."}

{"answer": "8.5", "explanation": "The clamp() function was implemented as part of the clamp_v2 RFC for PHP 8.5, which was released in November 2025."}

{"answer": "no", "explanation": "The Context Managers v2 RFC was rejected (not adopted) after voting, so it has not been incorporated into PHP."}

{"answer": "no", "explanation": "There is no real PHP RFC titled 'Bound-Erased Generic Types,' and a decline could not have occurred in 2026, a future year."}

{"answer": "no", "explanation": "The RFC to make PHP build thread-safe (ZTS) by default failed to reach the required 2/3 majority when voted on, so it was not accepted."}

{"answer": "yes", "explanation": "As of PHP 8.5, generics (parameterized types) have not yet been implemented in PHP core, though RFCs and FIG discussions have been ongoing."}

```json ⏎ {"answer": "yes", "explanation": "PHP 8.5 was released as stable in November 2025, and PHP 8.6 is scheduled for GA on 2026-11-19, so as of 2026-11-07 the latest stable version is indeed 8.5."} ⏎ ```

{"answer": "yes", "explanation": "PHP 6 was originally planned for Unicode support but was abandoned, so PHP 7.0 was released directly after PHP 5.6 in 2015."}

```json ⏎ {"answer": "no", "explanation": "The RFC proposing a #[\\Deprecated] attribute for the PHP core was voted down/rejected and therefore not adopted."} ⏎ ```

{"answer": "yes", "explanation": "In clean and onion architecture the dependency rule requires that inner layers know nothing about outer layers and that all source code dependencies point inward toward the center."}

{"answer": "yes", "explanation": "In clean/ddd architecture, domain entities are pure PHP that should depend only on the language and standard library to remain decoupled from frameworks like Doctrine or Symfony."}

{"answer": "no", "explanation": "Controllers and Twig templates belong to the presentation/framework (outer) layer; they call/use cases but are not part of the business-logic layer."}

{"answer": "Domain entities (business rules/entities)", "explanation": "In the onion architecture, the innermost center contains the domain objects and core business rules, with outer layers (use cases, interfaces, frameworks) wrapping around them."}

{"answer": "yes", "explanation": "Deptrac performs static analysis to detect forbidden layer dependencies and fails the build when a violation is found."}

{"answer": "no", "explanation": "Use cases/interactors must be framework-agnostic and accept only domain-level inputs (values, DTOs, or primitives), not infrastructure concerns like an HTTP request or an EntityManager, which would violate the dependency rule and make them hard to test."}

{"answer": "Repository", "explanation": "The Repository pattern provides a collection of aggregates/entities through an interface while abstracting away the underlying storage/persistence mechanism."}

```json ⏎ {"answer": "yes", "explanation": "In clean architecture the dependency rule points inward, so database concerns live in the outer adapter layer behind ports/interfaces, letting the database be swapped without touching the domain or application use cases."} ⏎ ```

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of domain objects treated as a unit for consistency changes, not a database table, which is an implementation detail of persistence."}

{"answer": "yes", "explanation": "Value objects are defined by their field values rather than identity, and are conventionally immutable to ensure that their equality remains consistent based on those values."}

{"answer": "Aggregate Root", "explanation": "In Domain-Driven Design, an aggregate root is the single external entry point of an aggregate through which all changes must pass to maintain the aggregate's invariants."}

{"answer": "yes", "explanation": "In DDD, repositories are created for aggregate roots because aggregates are the main unit of distributed persistence and identity, while individual entities are only accessible through their root."}

{"answer": "yes", "explanation": "Ubiquitous language in Domain-Driven Design is the shared language developed collaboratively by developers and domain experts to ensure consistent communication and accurate modeling."}

```json ⏎ {"answer": "interpretation", "explanation": "In model theory, an interpretation (or model) provides the boundary within which the symbols of a language are assigned consistent meanings, while outside that interpretation the same symbols can denote different models."} ⏎ ```

{"answer": "no", "explanation": "DDD recommends rich domain models where objects encapsulate both data and behavior, whereas anemic domain models (data with logic in services) are widely considered an anti-pattern by Eric Evans and Fowler."}

{"answer": "yes", "explanation": "In Domain-Driven Design, a bounded context defines the boundaries within which a particular model applies, so the same concept (e.g., 'Customer') can be represented by different classes depending on the context."}

{"answer": "yes", "explanation": "By default, Symfony's DI container only instantiates a service when it is first requested, rather than creating all services at load time."}

{"answer": "debug:router", "explanation": "The `debug:router` command displays a list of all registered routes for a Symfony application, including their paths, methods, and names."}

{"answer": "no", "explanation": "Symfony's autowiring automatically injects dependencies based on type hints, so services do not need to be manually declared in services.yaml."}

```json ⏎ {"answer": "yes", "explanation": "Twig compiles template source into optimized PHP classes and caches the compiled bytecode between requests to avoid recompiling on every request."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "In Symfony's dev environment, the compiled DI container is cached on disk and its freshness is validated by comparing tracked resource files' modification times, so it only recompiles when those files change rather than on every request."} ⏎ ```

{"answer": "APP_ENV", "explanation": "In Symfony, the APP_ENV environment variable (formerly SYMFONY_ENV) selects the active environment such as dev or prod."}

{"answer": "no", "explanation": "In modern Symfony, controller methods must be public because the container resolves and invokes them via reflection/service lookup, and private methods cannot be called that way."}

{"answer": "no", "explanation": "Both listeners and subscribers rely on the same priority system to determine order, so subscribers do not inherently receive events before listeners."}

{"answer": "yes", "explanation": "In Symfony 6.0 the legacy security-guard component was removed and authentication is now built around the authenticator system using AuthenticatorInterface, which was introduced (deprecating the old setup) in Symfony 5.7."}

{"answer": "#\[IsGranted\\]", "explanation": "The #[IsGranted] attribute (and its newer alias #[IsAccessGranted] in Symfony 6.4+) enforces a role or permission on a controller, returning HTTP 403 when the check fails."}

{"answer": "yes", "explanation": "Voters are indeed Symfony's mechanism for authorizing access to specific objects/subjects, and isGranted('EDIT', $post) passes $post as the subject that the voter evaluates."}

{"answer": "yes", "explanation": "Symfony 7 removed Doctrine annotation support entirely, requiring PHP attributes for validation constraints and other metadata."}

{"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default (the csrf_protection option defaults to true), so a token is auto-added and validated on submission."}

```json ⏎ {"answer": "yes", "explanation": "Symfony performs server-side validation independently of any client-side HTML5 checks, which can be bypassed, ensuring data integrity and security."} ⏎ ```

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

{"answer": "false", "explanation": "Symfony stores only the user's authenticated identifier (e.g., username or ID) in the session, not the password, and passwords should never be stored at all."}

```json ⏎ {"answer": "yes", "explanation": "In Symfony, bundle and topic configurations are stored in the config/packages directory, typically as one YAML (or other format) file per bundle or feature such as framework.yaml, doctrine.yaml, and security.yaml."} ⏎ ```

{"answer": "yes", "explanation": "This matches the common framework convention (e.g., Symfony) where .env holds committed dev defaults and .env.local is gitignored to keep real secrets out of the repository."}

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

```json ⏎ {"answer": "no", "explanation": "Once the Symfony container is compiled, it becomes frozen and immutable, so $container->setParameter() throws a RuntimeException at runtime and only works before compilation in the container builder."} ⏎ ```

{"answer": "no", "explanation": "In modern Symfony, services are private (public: false) by default and can only be fetched from the container if explicitly marked public."}

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

{"answer": "yes", "explanation": "Symfony allows referencing environment variables in services.yaml using the %env(VAR)% syntax, which is resolved at container build time."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls whether Symfony runs in debug mode, enabling the profiler and Twig debug functionality."}

{"answer": "false", "explanation": "A single message in Symfony Messenger can be handled by multiple handlers, which can be prioritized using attributes like #[AsMessageHandler(priority: ...)] or by mapping the same message type to several handlers."}

{"answer": "false", "explanation": "The sync transport immediately sends the message to the handler for processing, rather than queuing it for a worker to consume later like the async transport does."}

{"answer": "messenger:consume", "explanation": "In Symfony, the `messenger:consume` command (formerly `messenger:consume-messages`) starts the worker that processes queued Messenger messages."}

{"answer": "yes", "explanation": "In Symfony Messenger, the retry strategy (max_retries, multiplier, delay, etc.) is configured per transport in the messenger routing configuration."}

{"answer": "no", "explanation": "Messenger serializes messages using PHP serialization (PhpSerializer) by default, not JSON, though you can configure a JSON serializer."}

{"answer": "no", "explanation": "Symfony Scheduler executes scheduled jobs by running console commands (via a process runner), not by producing and dispatching messages through the Messenger component."}

{"answer": "doctrine", "explanation": "The Doctrine transport is the built-in Symfony Messenger transport that persists messages in database tables using Doctrine ORM."}

{"answer": "yes", "explanation": "In Symfony Messenger, middleware run through a pipeline and custom ones can be tagged as 'messenger.middleware' with a priority attribute, allowing them to execute before or after the built-in middleware."}

{"answer": "yes", "explanation": "Symfony follows an official release schedule where major releases occur every two years and minor/bugfix releases happen twice a year in May and November."}

{"answer": "PHP 8.3", "explanation": "Symfony 8 does not yet exist as a released version (Symfony 7.x is current), so there is no official minimum PHP version requirement, though it would likely follow the trend of requiring PHP 8.3+ based on Symfony's major version upgrade pattern."}

```json ⏎ {"answer": "false", "explanation": "Symfony 7.0 removed support for docblock annotations, which were deprecated in 6.4 in favor of PHP attributes."} ⏎ ```

{"answer": "yes", "explanation": "Symfony's AssetMapper component manages CSS/JS assets without needing Node.js, npm, or Webpack by using importmap.php to declare and map the packages and files."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long Term Support) release, as even-numbered minor versions released in November are designated for long-term support."}

{"answer": "yes", "explanation": "Symfony keeps deprecations introduced in a previous branch working across major releases, only removing them after they have passed through several major versions rather than at the next major version."}

{"answer": "yes", "explanation": "Symfony provides a UPGRADE guide (e.g., UPGRADE-5.0.md, UPGRADE-6.0.md) for each major version, documenting backward-compatibility changes and how to migrate."}

{"answer": "symfony/asset-maps", "explanation": "The symfony/asset-maps component manages JavaScript/CSS assets via the browser importmap system, eliminating the need for Node.js or Webpack."}

{"answer": "no", "explanation": "Symfony 8.0 is the LTS release scheduled for November 2026, and Symfony 8.2 would not arrive until 2027, so it has not been released as of 2026-11-07."}

{"answer": "no", "explanation": "Symfony 8.0 is scheduled for November 2026, but Symfony 8.2 would follow two six-month cycles later, i.e., November 2027, not November 2026."}

{"answer": "8.2", "explanation": "Symfony follows a release schedule where minor versions like 8.2 follow 8.1, with 8.1 released around November 2025 and 8.2 following in May 2026."}

{"answer": "false", "explanation": "Symfony 8.2 is a minor release within the 8.x series that introduces new features without breaking changes, while major releases requiring API changes occur at version boundaries like 8.0."}

{"answer": "yes", "explanation": "PHP 8.1 and 8.2 share the same major version (8.x), so updating between minor releases stays within the same major branch and PHP's backward compatibility policy preserves existing code."}

{"answer": "8.9", "explanation": "Symfony 8.x branch will have minor releases from 8.0 through 8.9, making 8.9 the last minor release before Symfony 9.0."}

{"answer": "false", "explanation": "Symfony 8.0 (the LTS release arriving November 2025) requires PHP 8.3, not PHP 8.5, so the version numbers do not map one-to-one and no PHP 8.5 upgrade is mandated."}

{"answer": "yes", "explanation": "According to Symfony's deprecation policy, deprecations are kept for 2 major versions before removal, so those added in 8.x are removed in 10.0, meaning they will indeed not be removed before 9.0."}

{"answer": "no", "explanation": "Twig's `{{ }}` syntax only evaluates and outputs expressions, and `{% %}` handles statements, but neither permits executing arbitrary PHP code by default—it requires custom extensions/functions."}

{"answer": "yes", "explanation": "Twig automatically escapes output variables using the HTML escaping strategy by default unless explicitly disabled."}

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

{"answer": "number_format", "explanation": "The number_format filter in the twig/intl-extra package formats a number according to the current locale using PHP's NumberFormatter."}

{"answer": "yes", "explanation": "The |raw filter in Twig marks the value as safe HTML, which disables auto-escaping for that value."}

{"answer": "yes", "explanation": "In Twig, double curly braces {{ }} render the value of an expression, while percent braces {% %} execute control tags such as if, for, and set."}

{"answer": "no", "explanation": "Twig allows you to declare variables inside a template using the set tag, such as {% set foo = 'bar' %}."}

```json ⏎ {"answer": "dump", "explanation": "The Twig dump() function outputs the debug structure of a variable such as an array or object."} ⏎ ```

{"answer": "yes", "explanation": "Bootstrap is a CSS and JavaScript library providing pre-built UI components like navbars, modals, and carousels, but it does not provide the routing, state management, or reactivity that define an SPA framework like React or Vue."}

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

{"answer": "false", "explanation": "Bootstrap's grid uses 12 columns (not 16), and Bootstrap 4/5 are built on Flexbox rather than CSS floats."}

{"answer": "yes", "explanation": "Bootstrap 5 defines exactly five named breakpoints used as class-name infixes: sm, md, lg, xl, and xxl."}

```json ⏎ {"answer": "yes", "explanation": "In Bootstrap, spacing utilities like .mt-3 and .px-2 pull values from the $spacers scale, which is generated as multiples of the base $spacer variable."} ⏎ ```

{"answer": "data-bs-toggle", "explanation": "Bootstrap 5 uses the `data-bs-toggle` attribute (with a value like `dropdown`, `modal`, or `collapse`) to enable interactive components on an element."}

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

{"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 create tables automatically at runtime; you must run schema tools like `doctrine:schema:create` to generate the database schema from entity mappings."}

{"answer": "persist()", "explanation": "The persist() method on the EntityManager marks a new object as managed and schedules it for insertion, deferring the actual SQL INSERT until flush() is called."}

{"answer": "no", "explanation": "In Doctrine ORM 3 the EntityManager::merge() method was removed (it was deprecated in ORM 2 in favor of the Unit of Work's identity map)."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is written in terms of PHP entities and their mapped properties/fields rather than database tables and columns, which is its key difference from SQL."}

{"answer": "null", "explanation": "Doctrine repository's find() method returns null when no entity exists with the given identifier."}

{"answer": "no", "explanation": "Doctrine uses a Unit of Work pattern that requires you to explicitly call $em->flush() to persist changes; it does not automatically flush at the end of a request."}

{"answer": "yes", "explanation": "In Doctrine ORM, once an entity is managed (persisted), its properties are tracked by the Unit of Work through dirty checking, so a simple change is automatically detected and committed by flush() without needing another persist() call."}

```json ⏎ {"answer": "no", "explanation": "In Doctrine ORM, remove() only marks an entity for deletion in the persistence context; the actual DELETE SQL is only executed when flush() is called."} ⏎ ```

{"answer": "no", "explanation": "PostgreSQL's MVCC allows readers and writers to run concurrently without blocking each other, which is precisely the purpose of Multi-Version Concurrency Control."}

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

{"answer": "no", "explanation": "SERIAL is a legacy implementation that creates a sequence plus a default nextval() call, while GENERATED ... AS IDENTITY is the SQL-standard identity column feature with additional options and behaviors, so they are distinct mechanisms."}

{"answer": "false", "explanation": "In PostgreSQL, NULL values are treated as distinct within a UNIQUE constraint, so multiple rows with NULL are allowed, not just one."}

{"answer": "STRING_AGG", "explanation": "STRING_AGG is a PostgreSQL aggregate function that concatenates a set of string values with a specified separator."}

{"answer": "no", "explanation": "Plain VACUUM reclaims space occupied by dead tuples for reuse within the table but does not return it to the operating system; only VACUUM FULL shrinks the table and returns space to the OS."}

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

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

```json ⏎ {"answer": "yes", "explanation": "In PostgreSQL's default autocommit mode, each individual SQL statement is automatically wrapped in and committed as its own implicit transaction unless an explicit BEGIN block is used."} ⏎ ```

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

{"answer": "yes", "explanation": "Indexes speed up UPDATE and DELETE operations too, because both need to quickly locate the rows matching their WHERE clause, avoiding full table scans."}

{"answer": "yes", "explanation": "SAVEPOINT allows you to create a marker within a transaction so you can roll back only part of the statements using ROLLBACK TO SAVEPOINT without discarding the entire transaction."}

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

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

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

```json ⏎ {"answer": "no", "explanation": "PostgreSQL implements SERIALIZABLE using Serializable Snapshot Isolation (SSI), which tracks read/write conflicts and aborts conflicting transactions rather than locking the rows that are read."} ⏎ ```

{"answer": "yes", "explanation": "HTTP 201 Created indicates the request succeeded and a new resource was created as a result."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates a successful request that has no response body, which is the standard response for DELETE operations."}

{"answer": "yes", "explanation": "DELETE is idempotent because repeating the request for the same resource yields the same resource state—after the first deletion, subsequent requests return 404 without further altering the resource."}

{"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 via CORS."}

{"answer": "yes", "explanation": "HTTP status 429 Too Many Requests indicates that the client has exceeded the rate limit for a given resource."}

{"answer": "no", "explanation": "The statement is backwards: 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 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, so this statement is true."}

{"answer": "no", "explanation": "Plain == can produce false positives with strings that look like scientific notation (e.g., '0e123...' == '0e456...' both equal 0), so hash_equals() should be used for constant-time, safe comparison."}

{"answer": "yes", "explanation": "A CSRF token is generated server-side, stored in the user's session, and validated on unsafe requests (POST/PUT/DELETE) to ensure the request originated from a legitimate form served by the same site."}

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

```json ⏎ {"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol—the access token grants access to resources but does not inherently identify who the user is."} ⏎ ```

{"answer": "no", "explanation": "XSS is prevented by output encoding/escaping when rendering data to the browser, not by input validation before database storage, since stored data only becomes dangerous when displayed in an HTML context."}

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

{"answer": "yes", "explanation": "Refresh tokens are designed to have a longer lifetime than access tokens and are used to mint new access tokens without requiring the user to re-authenticate."}

{"answer": "no", "explanation": "Salts do not need to be secret; they are typically stored alongside the hash and are applied during verification so the same input can be reproduced and compared."}

```json ⏎ {"answer": "yes", "explanation": "PHPUnit discovers and runs test methods via reflection based on naming conventions (the 'test' prefix and 'Test' class/file suffix), so a class does not strictly need to extend TestCase to be executed, though TestCase provides the assertion methods and lifecycle hooks."} ⏎ ```

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

{"answer": "no", "explanation": "A data provider in PHPUnit allows a test to run multiple times, each time with a different set of arguments, not just exactly one set."}

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

{"answer": "false", "explanation": "The statement is reversed: a stub only returns canned data, while a mock verifies that specific methods were called on it."}

{"answer": "yes", "explanation": "In PHPUnit 10+, the #[DataProvider] attribute replaced the deprecated @dataProvider annotation as the recommended way to associate data providers with tests."}

{"answer": "no", "explanation": "PHPUnit supports test dependencies through the @depends annotation (or #[Depends] attribute), which allows one test to depend on another test and receive its return value."}

{"answer": "--order-by=random", "explanation": "The `--order-by=random` option tells PHPUnit to shuffle the execution order of tests, with an optional `--random-order-seed` to make the sequence reproducible."}

```json ⏎ {"answer": "3-3", "explanation": "intdiv(7,2) returns 3 and intdiv(-7,2) returns -3 (truncated toward zero), concatenated to form the string '3-3'."} ⏎ ```

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

```json ⏎ {"answer": "true", "explanation": "Both '1e1' (scientific notation for 10) and '10' are treated as numeric strings, so PHP compares them as the numbers 10 and 10, which are equal."} ⏎ ```

```json ⏎ {"answer": "zero", "explanation": "In a loose comparison, the string 'a' is converted to integer 0, which matches case 0, so 'zero' is echoed."} ⏎ ```

{"answer": "2c", "explanation": "When strtr() receives an associative array, it replaces the longest matching substrings first, so 'ab' matches before 'a', producing '2c'."}

{"answer": "[hello]", "explanation": "Since the negative offset -10 exceeds the string length of 5, substr returns the entire string 'hello', which is then wrapped in brackets."}

```json ⏎ {"answer": "k,n,m", "explanation": "The + operator unions arrays with left array's keys taking precedence, keeping k,n from $a and adding m from $b, giving keys k,n,m."} ⏎ ```

{"answer": "yxz", "explanation": "usort sorts the rows by their third element ascending (1, 2, 2), leaving the two equal-value rows in original order, then array_column extracts index 1 giving ['y','x','z'] which joins to 'yxz'."}

{"answer": "4", "explanation": "The spread operator uses associative array keys as named arguments, so `b=>1` binds to `$b` and `a=>5` binds to `$a`, giving `5 - 1 = 4`."}

{"answer": "3", "explanation": "The first-class callable syntax `$p->g(...)` creates a closure that captures and holds a reference to the object `$p`, so even after `$p = null` the underlying object is still alive and `$f()` returns the value of `$this->v`, which is 3."}

{"answer": "B", "explanation": "Static::class uses late static binding, so when who() is called on a B instance, it returns B's class name."}

{ ⏎   "answer": "Fatal error (infinite recursion / stack overflow)", ⏎   "explanation": "The property is a PHP 8.4+ hook property, and its `set` hook assigns to `$this->x`, which re-invokes the same set hook, causing infinite recursion and a stack overflow before the `echo` line is ever reached." ⏎ }

```json ⏎ {"answer": "BA", "explanation": "The `insteadof` operator makes TB::f the winning method for f() (returning 'B'), while `as g` gives TA::f an alias that returns 'A', so the concatenation outputs 'BA'."} ⏎ ```

{"answer": "0", "explanation": "In PHP, when a trait declares a static property, each class that uses the trait receives its own separate copy of that static property, so setting CX::$n does not affect CY::$n."}

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

```json ⏎ {"answer": "second", "explanation": "The inner try throws RuntimeException, but the finally block throws LogicException which overrides it and is caught by the outer catch, echoing 'second'."} ⏎ ```

```json ⏎ {"answer": "App\\Foo|Baz", "explanation": "Within namespace N, Baz::class resolves via the use statement to App\\Foo, while \\Baz::class refers to the global \\Baz class name (yielding just Baz)."} ⏎ ```

{"answer": "yesno", "explanation": "In namespace Ns, class_exists('Foo') prepends the namespace and finds Ns\\Foo (yes), but class_exists('Ns\\Foo') has no leading backslash so it prepends the current namespace again, searching for Ns\\Ns\\Foo which does not exist (no)."}

{"answer": "1,2,99", "explanation": "The foreach with by-reference creates a lingering reference to the last array element, so $v = 99 reassigns the last element of $a, resulting in [1,2,99]."}

{"answer": "3", "explanation": "Class B does not override inc(), so both $a->inc() and $b->inc() execute A's method, sharing the same static variable $n which is incremented across all calls (1, 2, 3), so only the final echo prints 3."}

{"answer": "It throws a RuntimeException (Cannot send() to an unstarted generator); no output is produced", "explanation": "send() can only inject a value into a generator that has already reached a yield point, but here it is called on a freshly created, unstarted generator, which throws before getReturn() is ever reached."}

```json ⏎ {"answer": "1,2,ok", "explanation": "The `yield from inner()` delegates yielding 1 and 2, captures inner's return value 'ok' as $r, then outer yields 'ok', so the iterator yields 1, 2, 'ok'."} ⏎ ```

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

{"answer": "strict-in", "explanation": "E_ALL equals 16383 (bits 0–13), which still includes the 2048 bit (E_STRICT); 16383 & 2048 = 2048, which is non-zero, so the ternary evaluates to 'strict-in'."}

{"answer": "mapped", "explanation": "Symfony converts the 'HTTP_X_TOKEN' server parameter into an 'X-Token' header by stripping the HTTP_ prefix and replacing underscores with hyphens, so the comparison is true and it echoes 'mapped'."}

```json ⏎ {"answer": "BCA", "explanation": "In Symfony's EventDispatcher, listeners with higher priority execute first, so B (10), C (5), then A (0)."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "Both find() calls use the same EntityManager, so the second call returns the cached first-level entity instance rather than a new one."} ⏎ ```

{"answer": "0", "explanation": "Persisting then removing a brand-new, never-flushed entity causes Doctrine's UnitOfWork to discard the pending insert (the remove simply cancels it), so no INSERT or DELETE SQL executes and the empty users table still returns zero rows."}

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

```json ⏎ {"answer": "10,30,60", "explanation": "The window function computes running sums (10, 30, 60), which are concatenated in id order by string_agg."} ⏎ ```

{"answer": "M1M2", "explanation": "The bus wraps the middleware in a stack with a default ThrowOnFailureMiddleware appended, so Trace('M1') runs first echoing 'M1', then Trace('M2') echoing 'M2', then the final middleware passes through."}

```json ⏎ {"answer": "1", "explanation": "The first insert adds the row (1), and the second insert hits the unique index conflict and does nothing, so only one row remains."} ⏎ ```

{"answer": "2", "explanation": "Because the UNIQUE constraint is DEFERRABLE INITIALLY DEFERRED, it is only validated at the end of the transaction, so both duplicate inserts succeed and the SELECT counts both rows as 2."}

{"answer": "6", "explanation": "The `--filter test_sum` regex matches both `test_sum` and `test_sum_abs` (since 'test_sum' is a substring of 'test_sum_abs'), each with 3 data-provider cases, totaling 6 tests."}

{"answer": "2,1", "explanation": "The data provider supplies two data sets ([1] and [-1]), so 2 tests run, and only the -1 case fails the assertTrue, giving 1 failure."}

{"answer": "POST", "explanation": "The -d/--data flag in curl automatically sends an HTTP POST request with the data as the request body."}

```json ⏎ {"answer": "GET", "explanation": "The -G flag makes curl append the data sent with -d to the URL as a query string and sends it using the GET method instead of POST."} ⏎ ```

```json ⏎ {"answer": "invalid_client", "explanation": "Per RFC 6749 §5.2, a non-existent/unknown client identifier causes client authentication to fail, which the server reports using the 'invalid_client' error value."} ⏎ ```

{"answer": "fragment", "explanation": "In the OAuth 2.0 implicit flow (response_type=token), the access_token is returned in the URL fragment (the part after the '#') rather than the query string, because the fragment is not sent to the server."}

{"answer": "6", "explanation": "The `default` filter has higher precedence than `*`, so `false|default(2)` evaluates to `2` (since `false` is considered empty), then `2 * 3` equals `6`."}

{"answer": "2", "explanation": "In Twig the `~` operator has higher precedence than `+`, so `'a' ~ 1 + 2` parses as `('a' ~ 1) + 2` = `'a1' + 2`, and PHP coerces the non-numeric string 'a1' to 0, giving 2 with no exception thrown."}

```json ⏎ {"answer": "1", "explanation": "Passing an array of constraints to validate() wraps them in an All constraint, so NotBlank is applied to each element of [''], and the empty string '' is considered blank, producing exactly one violation."} ⏎ ```

{"answer": "Symfony\\Component\\Form\\Exception\\UnexpectedException", "explanation": "Calling isValid() on a form that has not been submitted (and thus not synchronized) throws an UnexpectedException in the Symfony Form component."}

```json ⏎ {"answer": "same", "explanation": "The service 'a' is a singleton by default, so the compiled container caches and returns the same instance for both get() calls, giving identical spl_object_id values."} ⏎ ```

```json ⏎ {"answer": "hi Bob!", "explanation": "Parameter interpolation recursively resolves %greeting% to 'hi Bob' and %name% to 'Bob', producing 'hi Bob!'."} ⏎ ```

{"answer": "960px", "explanation": "In Bootstrap 5.3, 992px is the 'lg' breakpoint (≥992px), where the .container max-width is 960px."}

{"answer": "text-danger", "explanation": "Both `.text-danger` and `.text-primary` have equal specificity and both use `!important`, so the winner is determined by source order in Bootstrap's compiled CSS, where `.text-danger` (defined after `.text-primary` in the theme-colors map) appears later and thus wins regardless of the class attribute order."}

{"answer": "2", "explanation": "OrderService is in the Domain layer, whose rule allows depending only on Domain, so both the Application (PlaceOrder) and Infrastructure (Db) dependencies are violations."}

```json ⏎ {"answer": "2", "explanation": "BillingService is in the Domain layer, which may only depend on Domain; depending on Application (PlaceOrder) and Infrastructure (Db and Logger) violates the rules, and deptrac aggregates violations per target layer, yielding 2 violations (one for Application, one for Infrastructure)."} ⏎ ```

{"answer": "10,15", "explanation": "The constructor promotes $amount, add() creates a new Money with 10+5=15, so $a->amount is 10 and $c->amount is 15."}

```json ⏎ {"answer": "1", "explanation": "The remove() method throws DomainException before unsetting since count is 1, but the exception is caught, leaving 'a' in items so count() returns 1."} ⏎ ```

{"answer": "hi", "explanation": "The code creates a new instance of class C and immediately calls its hi() method, which returns the string 'hi', which is then echoed out."}

{"answer": "yes\nno", "explanation": "`newLazyGhost` creates an uninitialized lazy ghost object so the first check prints 'yes'; accessing `$o->v` triggers the initialization closure (setting v=21), after which the object is no longer uninitialized so the second check prints 'no'."}

```json ⏎ {"answer": "no", "explanation": "The Guard authentication system including AbstractGuardAuthenticator was deprecated in Symfony 5.3 and removed in Symfony 6.0, so it cannot exist in Symfony 8.1."} ⏎ ```

{"answer": "noyes", "explanation": "In Symfony 6.0+ the deprecated AnnotationClassLoader (introduced with annotations) was removed, while AttributeClassLoader (the active attribute-based loader) still exists, so the first check is 'no' and the second is 'yes'."}