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

{"answer": "no", "explanation": "Double-quoted strings undergo variable interpolation and escape sequence processing, while single-quoted strings are treated almost literally, so they are not processed identically (speed is not the difference)."}

{"answer": "yes", "explanation": "The ?? (null coalescing) operator indeed follows isset() semantics and does not raise warnings for undefined variables."}

{"answer": "ab", "explanation": "The echo statement accepts multiple comma-separated arguments and outputs them sequentially without any separator."}

{"answer": "yes", "explanation": "In PHP, print always returns the value 1 and can be used inside expressions since it is a language construct."}

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

```json ⏎ {"answer": "false", "explanation": "In PHP, the concatenation operator (.) has the same precedence level as addition (+) and subtraction (-), not a lower precedence."} ⏎ ```

{"answer": "no", "explanation": "In PHP, the ** operator 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 addition (+), so it evaluates as ('sum: ' . 2) + 3, which coerces to 2 + 3 and prints just 3."}

{"answer": "no", "explanation": "With strict comparison (===), arrays are NOT equal regardless of element order; they must have the same key/value pairs in the same order to be considered equal."}

```json ⏎ {"answer": "no", "explanation": "The comparison `0 == false` returns true (not false) because `==` is a loose comparison, not a strict one, and PHP evaluates 0 as equal to false in loose comparison."} ⏎ ```

{"answer": "yes", "explanation": "In PHP, non-numeric strings are loosely compared as 0 when compared to an integer, and since 0 == 0 is true, 'abc' == 0 evaluates to true."}

```json ⏎ {"answer": "yes", "explanation": "In PHP loose comparison, null, 0, \"\", and false are all considered equal to each other via ==."} ⏎ ```

```json ⏎ {"answer": 42, "explanation": "In PHP, casting a string like '42abc' to int extracts the leading numeric portion (42) and ignores the trailing non-numeric characters."} ⏎ ```

```json ⏎ {"answer": "10", "explanation": "In PHP, the expression '5' + 5 returns 10 because the + operator forces both operands to be treated as integers (numeric coercion)."} ⏎ ```

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

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

{"answer": "no", "explanation": "strrev() operates byte-by-byte on multibyte UTF-8 strings, which corrupts characters that consist of multiple bytes."}

{"answer": "yes", "explanation": "str_contains() returns true when the haystack 'Hello world' contains the needle 'world'."}

{"answer": "no", "explanation": "str_pad() can pad a string on the left, right, or both sides depending on the pad_type parameter."}

{"answer": "false", "explanation": "By default trim() strips all whitespace characters including spaces, tabs, newlines, carriage returns, null bytes, and vertical tabs, not just spaces."}

{"answer": "6", "explanation": "strlen() counts bytes, and 'héllo' has 6 bytes because the é is encoded as 2 bytes in UTF-8."}

{"answer": "cdef", "explanation": "substr() with a negative start offset counts from the end of the string, so -3 means start at the third-to-last character, returning 'cdef'."}

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

{"answer": "yes", "explanation": "Heredoc syntax parses variables and escapes like double-quoted strings, while nowdoc syntax behaves like single-quoted strings and does not perform variable interpolation."}

{"answer": "no", "explanation": "The sort() function sorts the array by values but reassigns sequential integer keys, losing the original key-to-value association; use asort() if you want to preserve keys."}

{"answer": "yes", "explanation": "In PHP, string keys that consist solely of valid integer digits are automatically converted to integers when used as array keys."}

{"answer": "no", "explanation": "The in_array() function uses loose comparison (==) by default, and strict comparison (===) is only applied when the third parameter is explicitly set to true."}

{"answer": "yes", "explanation": "Without a callback, array_filter() removes all falsy elements (false, 0, \"0\", null, array(), \"\", etc.) from the array."}

{"answer": "no", "explanation": "array_slice() reindexes numeric keys by default, resetting them sequentially starting from 0, unless the preserve_keys parameter is set to true."}

```json ⏎ {"answer": "[20, 30]", "explanation": "array_slice extracts a slice starting at offset 1 (value 20) with a length of 2 elements, returning [20, 30]."} ⏎ ```

{"answer": 2, "explanation": "The array union operator (+) combines both arrays keeping keys from the left-hand array for duplicates, resulting in keys 'a' and 'b', so count() returns 2."}

{"answer": "true", "explanation": "Since PHP 8.1, the spread operator in array syntax correctly merges arrays with string keys, with later values overriding earlier ones for duplicate keys."}

{"answer": "false", "explanation": "Named arguments can be combined with argument unpacking (...$args) in a single call in PHP 8.1 and later, though they must not overlap."}

{"answer": "false", "explanation": "Anonymous functions in PHP do not automatically inherit variables from the outer scope; you must explicitly pass them using the `use` keyword, though they still have access to `this` in object contexts."}

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

```json ⏎ {"answer": "no", "explanation": "The body of an arrow function may only consist of a single expression if no curly braces are used, but with curly braces it must contain statements rather than multiple expressions, so the statement is false."} ⏎ ```

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

{"answer": "no", "explanation": "Static closures do not capture $this, but the statement incorrectly claims they do (actually, static closures explicitly do not bind $this)."}

{"answer": "5", "explanation": "Closures capture variables by value at the time of definition, so $x is bound to 5 even though it is later reassigned to 7."}

{"answer": "yes", "explanation": "In weak typing mode, PHP performs coercive type juggling, so a numeric string like \"5\" passed to an int parameter is automatically converted without error."}

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

{"answer": "final", "explanation": "The 'final' keyword prevents a method from being overridden by any subclass."}

{"answer": "yes", "explanation": "A method declared final cannot be overridden in a subclass."}

{"answer": "no", "explanation": "Private members in a parent class are not accessible from a subclass, as they are limited to the class in which they are declared."}

```json ⏎ {"answer": "class@anonymous", "explanation": "Anonymous classes in PHP get the name \"class@anonymous\" followed by a NUL byte and file path information, and get_class strips everything after the NUL byte."} ⏎ ```

{"answer": "yes", "explanation": "Private methods are not part of the inheritance contract, so a child class can declare a method with the same name as a private parent method with any visibility (public, protected, or private) without causing errors."}

{"answer": "false", "explanation": "__get() is also called when accessing inaccessible (protected/private) properties, not only non-existent ones."}

{"answer": "Error", "explanation": "Reassigning a readonly property in PHP throws a 'Fatal error: Cannot modify a readonly property' which is an Error instance (specifically Error), not a generic Exception."}

{"answer": "yes", "explanation": "Interfaces can declare constants, which are implicitly public, static, and final, and must be initialized with a constant expression."}

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

```json ⏎ { ⏎  "answer": "false", ⏎  "explanation": "Interfaces in PHP prior to version 7 cannot declare static methods, and while PHP 7+ does allow static method declarations in interfaces, the traditional answer and the base behavior is that interfaces only define instance method contracts that implementing classes must provide, meaning the classic statement that 'an interface can declare static methods' is considered false." ⏎ } ⏎ ```

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

{"answer": "false", "explanation": "In standard PHP (before 8.1), interface methods cannot have a body, though PHP 8.1 introduced 'default interface methods' which is a newer feature not available in traditional interface definitions."}

{"answer": "yes", "explanation": "In PHP, an abstract method declared as public can be overridden with reduced visibility (e.g., protected) in a child class because the child class only implements the method for internal use, which is allowed."}

```json ⏎ {"answer": "3", "explanation": "The enum Foo has three cases (A, B, C), and enum::cases() returns an array containing all defined cases."} ⏎ ```

{"answer": "yes", "explanation": "Traits in PHP can declare constants, which are then available in any class that uses the trait."}

{"answer": "yes", "explanation": "The Throwable interface is indeed the common ancestor of both Exception and Error in PHP 7+."}

{"answer": "no", "explanation": "TypeError extends from Error (which extends from Throwable), not from Exception, so a catch (Exception $e) block will not catch it in PHP 7+."}

{"answer": "false", "explanation": "The @ operator in PHP suppresses errors (runtime warnings/notices), not exceptions, which are controlled by try/catch blocks and error handling settings."}

{"answer": "DivisionByZeroError", "explanation": "intdiv(5, 0) throws a DivisionByZeroError exception because the divisor is zero."}

{"answer": "no", "explanation": "The finally block always runs regardless of whether an exception was caught, thrown, or not thrown at all."}

{"answer": "false", "explanation": "An exception thrown inside a finally block will replace (suppress) any exception or value from the try or catch blocks, so it does affect the result of the try block."}

{"answer": "yes", "explanation": "In PHP, all objects (including Exception instances) evaluate to true when cast to boolean, so (bool) new Exception('x') returns true."}

{"answer": "yes", "explanation": "Shutdown functions registered via register_shutdown_function() are executed when exit() is called, as exit triggers a script shutdown."}

{"answer": "false", "explanation": "The `use` statement only creates an alias for a class name; it does not load the class file, which is loaded by the autoloader when the class is first referenced."}

{"answer": "function", "explanation": "A function is imported/declared using the keyword `function`, while `const` is used for arrow functions or constant values, so the keyword specifically for importing a function is `function`."}

{"answer": "src/Controller/Api/UserController.php", "explanation": "PSR-4 maps the namespace segment after the vendor prefix to a subdirectory, so App\\Controller\\Api\\ maps to src/Controller/Api/ with the class name appended as UserController.php."}

{"answer": "yes", "explanation": "vendor/autoload.php generated by Composer calls spl_autoload_register() to register the classmap and PSR-4 autoloaders."}

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

{"answer": "false", "explanation": "An unqualified class name in `new` is resolved relative to the current namespace, not the global root, so `new Foo()` inside namespace `Bar` refers to `Bar\\Foo`."}

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

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

{"answer": "true", "explanation": "In PHP, arrays are value types that are copied on assignment, so modifying one array variable does not affect another unless references are explicitly used."}

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

{"answer": "true", "explanation": "In PHP, user-defined global variables declared outside a function cannot be accessed inside the function without using the global keyword, $GLOBALS array, or passing them as parameters since function scope is isolated from global scope."}

{"answer": "no", "explanation": "unset($GLOBALS['x']) inside a function destroys the global variable 'x' permanently, not just for that function, because you are deleting the actual element from the $GLOBALS array rather than a local reference."}

{"answer": "6", "explanation": "The function inc takes $x by reference and increments it, so $n changes from 5 to 6."}

```json ⏎ {"answer": "false", "explanation": "In PHP, foreach over an array by value operates on a copy of the array, so modifications to the array inside the loop do not affect iteration."} ⏎ ```

{"answer": "no", "explanation": "Static properties belong to the class itself rather than individual instances, so changes are shared across all objects."}

{"answer": "no", "explanation": "In PHP, boolean array keys are converted to integers, so a key of true becomes 1 and false becomes 0."}

```json ⏎ {"answer": "yes", "explanation": "In PHP 7.0+, a generator can return a value using a return statement, and this value is retrieved via the getReturn() method after the generator is exhausted."} ⏎ ```

{"answer": "yes", "explanation": "PHP generators can be rewound with rewind() and traversed again unless they were created with the Generator::EXCEPT_FROM_GENERATOR flag or use send()/throw() in ways that prevent rewinding."}

{"answer": "yes", "explanation": "The yield from construct allows one generator to delegate traversal to another generator or iterable."}

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

```json ⏎ {"answer": "3", "explanation": "The generator yields the elements 1, 2, and 3 from the array, so iterator_to_array collects exactly 3 elements and count() returns 3."} ⏎ ```

{"answer": "no", "explanation": "SplStack implements a LIFO (Last In First Out) stack, not a FIFO queue; that role is served by SplDoublyLinkedList or queue classes."}

{"answer": "yes", "explanation": "ArrayIterator is a PHP SPL class that allows wrapping an array and traversing it using the Iterator interface, along with additional functionality like offset access and seeking."}

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

{"answer": "yes", "explanation": "password_hash() automatically generates a cryptographically secure random salt when none is provided, so passing a separate salt is unnecessary and not even supported by the API."}

{"answer": "no", "explanation": "In PHP 8, PASSWORD_DEFAULT uses bcrypt by default, not md5."}

{"answer": "true", "explanation": "password_verify returns true when the plaintext password matches the hash generated by password_hash, and since both use 'secret', they match."}

{"answer": "no", "explanation": "strip_tags() only removes HTML and PHP tags from strings and provides no protection against SQL injection, which requires parameterized queries or proper input escaping for SQL contexts."}

{"answer": "yes", "explanation": "session_regenerate_id() with delete_old_session=true refreshes the session ID upon login, preventing attackers from using a pre-set (fixed) session ID."}

{"answer": "php_sapi_name", "explanation": "The php_sapi_name() function returns the name of the Server API Interface (SAPI) in use, such as cli for the command line interface."}

{"answer": "yes", "explanation": "session_destroy() only removes the session data stored on the server, leaving the session cookie in the browser intact unless the cookie is also explicitly cleared."}

{"answer": "no", "explanation": "session_start() must be called first to initialize and populate the $_SESSION array with existing session data."}

{"answer": "5.3", "explanation": "The array_find() function was introduced in PHP 5.3."}

{"answer": "yes", "explanation": "Property hooks (get/set right in the property declaration) landed in PHP 8.4."}

{"answer": "yes", "explanation": "Asymmetric visibility, allowing independent get and set access modifiers like public private(set), was indeed introduced in PHP 8.4."}

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

{"answer": "8.1", "explanation": "The pipe operator (|>) for piping values into function arguments was introduced in PHP 8.1."}

{"answer": "8.3", "explanation": "Clone expressions with the syntax clone($obj, ['property' => value]) were introduced in PHP 8.3."}

{"answer": "7.3", "explanation": "The array_first() and array_last() functions were introduced in PHP 7.3 (released December 2018)."}

{"answer": "8.5", "explanation": "The RFC for Partial Function Application v2 was adopted for PHP 8.5."}

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

{"answer": "no", "explanation": "As of the knowledge available, the Context Managers proposal has not yet been adopted into PHP."}

{"answer": "no", "explanation": "PHP's generics were implemented via the RFC \"Generics: Alias-based Syntax\" which passed in August 2025 and is scheduled for PHP 8.4, not declined in 2026."}

{"answer": "false", "explanation": "There is no RFC that enables ZTS (Zend Thread Safety/multithreading) by default in PHP, as PHP's default SAPI build remains non-ZTS (thread-safe off)."}

{"answer": "yes", "explanation": "As of PHP 8.x, generics (statically-typed parameterized classes/interfaces like Java's List<String>) have not been implemented, though static analysis tools like PHPStan and Psalm provide their own partial generic support."}

{"answer": "yes", "explanation": "PHP 8.5.0 was released on November 7, 2025, making it the latest stable version, with PHP 8.6 not yet released at that date."}

{"answer": "yes", "explanation": "PHP 6 was abandoned (its Unicode branch was cancelled) and PHP 7.0 was released directly after PHP 5.6 in 2015."}

{"answer": "false", "explanation": "The RFC proposing the #[\\Deprecated] attribute was rejected (voted 35-52), not adopted."}

{"answer": "yes", "explanation": "In clean and onion architecture, dependencies must point inward toward the center, meaning inner layers must not depend on outer layers."}

```json ⏎ {"answer": "yes", "explanation": "In a well-designed domain-driven design, entities depend only on PHP core and standard library, importing neither ORM frameworks like Doctrine nor Symfony components, so business rules remain testable and decoupled from infrastructure."} ⏎ ```

{"answer": "no", "explanation": "Controllers belong to the presentation/presentation layer and Twig templates to the view layer, not the business-logic layer; they are entry points that invoke use cases but do not themselves constitute the business-logic domain layer."}

{"answer": "Entities (Domain Models)", "explanation": "In the onion architecture, entities (domain models) sit at the very center, representing the core business rules and that other layers depend inward on them."}

```json ⏎ {"answer": "yes", "explanation": "Deptrac analyzes dependency graphs statically and fails the build when a forbidden layer dependency (like a call from a lower layer to a higher one) is detected."} ⏎ ```

{"answer": "false", "explanation": "Use cases should be transport- and infrastructure-agnostic, accepting plain data transfer objects rather than framework-specific objects like HTTP requests or an EntityManager, which violates the Dependency Rule and makes them harder to test and reuse."}

{"answer": "Repository", "explanation": "The Repository component provides a collection of aggregates/entities behind an interface while abstracting away the underlying storage implementation."}

{"answer": "yes", "explanation": "In clean architecture, the database is part of the outer infrastructure layer behind interfaces, so switching databases only requires reimplementing those interfaces without touching the domain or use cases."}

{"answer": "no", "explanation": "In DDD, an aggregate is a cluster of domain objects treated as a single unit of consistency and invariants, not a database table, which is a persistence-layer concept unrelated to domain modeling."}

{"answer": "yes", "explanation": "This is correct because a Value Object's primary characteristics are immutability and value-based equality rather than identity-based comparison."}

{"answer": "Gateway", "explanation": "In Domain-Driven Design, the Gateway is the single external entry point of an aggregate through which all changes must pass to maintain its integrity and invariants."}

```json ⏎ {"answer": "yes", "explanation": "In DDD, repositories are only created for aggregate roots because they manage the consistency and lifecycle boundaries of an entire aggregate, not for individual entities within it."} ⏎ ```

{"answer": "yes", "explanation": "Ubiquitous language in Domain-Driven Design refers to the shared, precise language developed collaboratively by developers and domain experts that is used consistently throughout the model and communication."}

{"answer": "standard system of arithmetic", "explanation": "This concept refers to what Tarski and others describe as the boundary within which a formal language and its model remain consistent (as in the reference to 'Aramshamian and the standard system of arithmetic')."}

{"answer": "false", "explanation": "The anemic domain model is actually the style thatDomain-Driven Design purists, particularly Eric Evans and Martin Fowler, explicitly criticize; DDD recommends a rich domain model where objects encapsulate both state and behavior/logic."}

{"answer": "yes", "explanation": "A bounded context defines explicit boundaries within which a domain model is valid, so the same concept (e.g., 'Customer' or 'Product') is represented by different classes in different bounded contexts."}

{"answer": "no", "explanation": "This is false because Symfony's container creates services eagerly at container build time when using the cached (prod) container, though it does use lazy loading for lazy service definitions specifically marked as such."}

```json ⏎ { ⏎ 	"answer": "debug:router", ⏎ 	"explanation": "The `debug:router` command displays a list of all the routes registered in a Symfony application, including their paths, methods, and other details." ⏎ } ⏎ ```

{"answer": "false", "explanation": "Symfony supports autoconfiguration and autowiring by default, where services can be auto-registered and wired based on type-hints without manually declaring every service in services.yaml."}

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

{"answer": "true", "explanation": "In the Symfony dev environment, the DI container is optimized to be rebuilt only when tracked source files change, not on every request, which significantly improves performance."}

{"answer": "APP_ENV", "explanation": "In modern Symfony applications the active environment is selected via the APP_ENV environment variable (in legacy versions it was the SYMFY_ENV or Symfony Environment variable)."}

{"answer": "no", "explanation": "The statement is false because Symfony routing only works with public methods, and methods are referenced via the 'Class::method' format rather than the class alone."}

{"answer": "no", "explanation": "Event subscribers do not inherently receive events before listeners; the event dispatcher manages subscription ordering and there is no automatic priority guarantee that subscribers are always processed before listeners."}

```json ⏎ {"answer": "no", "explanation": "While modern Symfony (5.8+ / 6.0+) does introduce the new authenticator system built on AuthenticatorInterface and deprecates the old Guard system, the old Guard authentication system was not fully removed in Symfony 6.0."} ⏎ ```

```json ⏎ {"answer": "IsGranted", "explanation": "The IsGranted attribute (from Symfony Security Core) checks a role or permission on a controller method and triggers a 403 exception when the check fails."} ⏎ ```

{"answer": "false", "explanation": "Voters are Symfony's mechanism for checking access, but the example is wrong because isGranted() is a method on the Authorizer/TokenVerifier (or the trait), not a Voter itself, and the correct usage example should show a Voter's vote() method rather than isGranted()."}

```json ⏎ {"answer": "yes", "explanation": "Modern Symfony versions recommend PHP attributes for validation constraints, and while annotations are deprecated and no longer actively supported, attributes remain the preferred approach."} ⏎ ```

{"answer": "yes", "explanation": "Symfony forms have CSRF protection enabled by default via the _token field using CsrfProtection, which validates the token on submission unless explicitly disabled."}

{"answer": "yes", "explanation": "Symfony's form validation always runs server-side regardless of any client-side HTML5 validation, which should only be treated as a usability enhancement, not a security measure."}

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

{"answer": "false", "explanation": "Symfony does not store passwords in the session; it stores user objects (as serialized user objects or in the session) and validates passwords by re-hashing submitted passwords against the stored hash."}

{"answer": "yes", "explanation": "In Symfony, bundle and topic configurations are conventionally stored in config/packages, with one file per bundle or configuration topic."}

```json ⏎ { ⏎   "answer": "yes", ⏎   "explanation": "This is the standard Laravel convention where .env.example contains committed defaults and .env.local holds the untracked real secrets." ⏎ } ⏎ ```

{"answer": "php bin/console debug:container", "explanation": "The debug:container command displays all registered services and their aliases in the Symfony dependency injection container."}

{"answer": "false", "explanation": "The parameter bag is read-only after the container is booted, so calling setParameter() from a controller after booting throws a RuntimeException."}

{"answer": "no", "explanation": "By default, Symfony services are private (public: false), and you must explicitly mark them as public to fetch them directly from the container."}

{"answer": "no", "explanation": "Bundles work without configuration files because Symfony bundles define default option values, so configuration is optional and only needed when you want to override those defaults."}

{"answer": "yes", "explanation": "In Symfony, environment variables are injected into configuration files using the %env(VAR_NAME)% syntax, which is automatically resolved at runtime."}

{"answer": "APP_DEBUG", "explanation": "The APP_DEBUG environment variable controls debug mode in Symfony, enabling the profiler and Twig debugging when set to \"1\"."}

{"answer": "false", "explanation": "A single message in Symfony Messenger can have multiple handlers, as the framework supports dispatching one message to several registered handlers."}

```json ⏎ { ⏎     "answer": "no", ⏎     "explanation": "The sync transport processes the message immediately in the current request rather than queuing it for a worker like the async transport does." ⏎ } ⏎ ```

{"answer": "php artisan queue:work", "explanation": "In Laravel, the queue:work command starts a worker that processes queued jobs, and Messenger message processing is handled through this worker."}

{"answer": "true", "explanation": "In Symfony Messenger, retry strategies are configured per transport in the retry_strategy section of the transport configuration."}

{"answer": "yes", "explanation": "Messenger serializes messages to JSON by default when passing them through the messenger bus, transport, or consuming them from a queue, using the JSON encoder unless another encoder is configured."}

```json ⏎ {"answer": "yes", "explanation": "The Symfony Scheduler component lets you define schedule entries that produce messages, which can then be dispatched through the Messenger component."} ⏎ ```

{"answer": "DoctrineMessengerTransport", "explanation": "The DoctrineMessengerTransport (Doctrine transport) is the built-in Symfony Messenger transport that stores messages in database tables via Doctrine ORM."}

{"answer": "yes", "explanation": "In Laravel, the Illuminate\\Messages\\MessagePipeline (used by the `notify` mechanism) supports `map()` to inject middleware before/after the pipeline's default middleware, so the statement is true."}

{"answer": "yes", "explanation": "Symfony's release schedule indeed follows this pattern, with major releases every two years and minor releases in May and November of each year."}

{"answer": "PHP 8.4", "explanation": "Symfony 8.0 requires a minimum of PHP 8.4 as officially documented in its system requirements."}

```json ⏎ {"answer": "no", "explanation": "Symfony 6.4 deprecated docblock annotations and Symfony 7.0 removed support for them in favor of attributes."} ⏎ ```

{"answer": "no", "explanation": "AssetMapper manages CSS/JS without node or webpack via its own asset system (with importmap.php used specifically for vendor/CDN libraries, while the statement conflates the two mechanisms incorrectly)."}

{"answer": "no", "explanation": "Symfony 6.4 is an LTS (Long-Term Support) release, which means it is a regular release but WITH long-term support (5 years total: 4 years of support plus 1 year of bug fixes)."}

{"answer": "false", "explanation": "Major releases typically remove deprecations introduced two major versions earlier, as part of Symfony's deprecation lifecycle where deprecations are removed in a subsequent major release."}

{"answer": "yes", "explanation": "Every Symfony major release includes a UPGRADE.md file in the repository and documents the changes in the Symfony docs, listing deprecations and backward-compatibility breaks."}

```json ⏎ { ⏎ 	"answer": "Symfony Webpack Encore", ⏎ 	"explanation": "Actually, this question contains a contradiction since Webpack Encore typically requires webpack/node, while the component that manages assets without node/webpack is AssetMapper." ⏎ } ⏎ ``` ⏎  ⏎ Wait, let me correct this: ⏎  ⏎ ```json ⏎ { ⏎ 	"answer": "AssetMapper", ⏎ 	"explanation": "The Symfony AssetMapper component manages frontend assets and importmaps without requiring node or webpack." ⏎ } ⏎ ```

{"answer": "false", "explanation": "Symfony 8.2 has not been released by 2026-11-07, as Symfony follows a quarterly release schedule with major versions (8.0, 8.1, 8.2) releasing in November, February, and May respectively, meaning 8.2 would not appear until May 2027."}

```json ⏎ { ⏎ "answer": "false", ⏎ "explanation": "Symfony's release cycle follows versioning where major versions like 8.2 are actually scheduled for May 2026, with the .2 release following the usual six-month cycle from the initial 8.0 release in November 2025." ⏎ } ⏎ ```

{"answer": "8.2", "explanation": "Symfony 8.1 was released in November 2025, and the next minor version in the release cycle is 8.2."}

```json ⏎ {"answer": "no", "explanation": "Symfony 8.2 does not exist yet as Symfony releases major versions roughly annually (7.x is current in 2024) and minor version numbers like .2 indicate minor/patch releases, not major ones."} ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "PHP's backward compatibility policy guarantees that updating within a major branch (e.g., 8.1 to 8.2) should not break existing code."} ⏎ ```

{"answer": "8.4", "explanation": "Following Symfony's LTS versioning scheme, the last minor version of the 8.x branch before Symfony 9.0 is 8.4, which is an LTS release scheduled until November 2027."}

{"answer": "no", "explanation": "Symfony 8.0 requires PHP 8.4+ (minimum), and there is no Symfony 8.2 that would require PHP 8.5."}

{"answer": "yes", "explanation": "Symfony's deprecation policy states that deprecations introduced in the 8.x branch will not be removed until Symfony 9.0, ensuring backwards compatibility for the duration of the branch's lifecycle."}

{"answer": "no", "explanation": "In Twig, braces {} denote expressions and must be valid Twig syntax, not arbitrary PHP code; raw PHP is only accessible through tags like {% %} and is not directly callable inside {{ }}."}

{"answer": "yes", "explanation": "Twig automatically escapes output by default, using HTML escaping for .twig templates and the specified autoescape strategy for other file types."}

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

{"answer": "number_format", "explanation": "The number_format filter from twig/intl-extra formats a number according to a specified locale using the IntlNumberFormatter."}

{"answer": "yes", "explanation": "The |raw filter in Twig marks a value as safe and prevents auto-escaping from being applied to it in templates."}

{"answer": "yes", "explanation": "In Twig, {{ }} is used for outputting expression values while {% %} is used for executing tags like conditions, loops, and set statements."}

{"answer": "false", "explanation": "Twig provides the set tag, which allows you to declare and assign variables inside a template."}

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

{"answer": "yes", "explanation": "Bootstrap is indeed a front-end CSS and JavaScript framework providing pre-built UI components like navbars, cards, and modals, but it is not a single-page application (SPA) framework like React, Angular, or Vue."}

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

{"answer": "no", "explanation": "Bootstrap's modern grid (v4 and v5) is built on CSS Flexbox, not floats, and uses a 12-column layout, not 16."}

{"answer": "false", "explanation": "Bootstrap 5 defines six named breakpoints: sm, md, lg, xl, xxl, and the newer xxxl (introduced in Bootstrap 5.3)."}

```json ⏎ {"answer": "yes", "explanation": "Bootstrap's spacing utilities (.mt-3, .px-2, etc.) are generated from the $spacer value using the $spaces map as multiples."} ⏎ ```

{"answer": "data-bs-toggle", "explanation": "In Bootstrap 5, all data attributes are prefixed with \"bs-\", so data-bs-toggle=\"dropdown\" enables the dropdown component on an element."}

{"answer": "yes", "explanation": "Bootstrap 5 dropped jQuery as a dependency, so all its components (dropdowns, modals, tooltips, etc.) are implemented in vanilla JavaScript and work without jQuery."}

```json ⏎ { ⏎ 	"answer": "false", ⏎ 	"explanation": "In Bootstrap 5.3+, dark mode is enabled using the data-bs-theme=\"dark\" attribute on the :root element, not a .dark class." ⏎ } ⏎ ```

```json ⏎ {"answer": "no", "explanation": "Doctrine ORM does not automatically create tables at runtime; tables are explicitly created via the `orm:schema-tool:create` command based on entity mappings."} ⏎ ```

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

{"answer": "no", "explanation": "In Doctrine ORM 3, the EntityManager::merge() method was removed because it was deprecated and considered a bad practice; you should instead use EntityManager::persist() and rely on cascade operations or manual property copying."}

{"answer": "yes", "explanation": "DQL (Doctrine Query Language) is designed to work with entities and their mapped fields rather than database tables and columns."}

```json ⏎ {"answer": "null", "explanation": "In Doctrine ORM, when a repository's find() method cannot locate a record matching the given identifier, it returns null instead of throwing an exception or returning an empty result."} ⏎ ```

{"answer": "false", "explanation": "DoctrineBundle does not automatically call flush(); developers must explicitly call $entityManager->flush() to persist changes to the database."}

{"answer": "yes", "explanation": "For a managed entity, simply modifying a tracked property is enough because Doctrine's Unit of Work performs change detection during flush() and automatically commits the change without needing an explicit persist()."}

{"answer": "false", "explanation": "In Doctrine ORM, remove() marks the entity as scheduled for deletion by adding it to the removal list, but the actual SQL DELETE is only executed when flush() is called."}

{"answer": "false", "explanation": "PostgreSQL's MVCC allows readers and writers to proceed concurrently without blocking each other, since readers see a snapshot of the data while writers create new versions."}

{"answer": "EXPLAIN", "explanation": "The EXPLAIN command (also known as EXPLAIN ANALYZE or EXPLAIN QUERY PLAN depending on the database) displays a query's execution plan without actually executing it."}

{"answer": "false", "explanation": "SERIAL and GENERATED ... AS IDENTITY are different mechanisms: SERIAL creates an implicit sequence plus a default nextval() call with a NOT NULL constraint, whereas GENERATED ... AS IDENTITY uses modern SQL standard identity columns with an owned sequence and different behaviors around defaults, ALTER COLUMN TYPE, and sequence cycling."}

{"answer": "no", "explanation": "In PostgreSQL, a UNIQUE constraint allows multiple rows containing NULL values because NULLs are considered distinct from each other, unlike the standard SQL behavior of allowing only one NULL."}

{"answer": "string_agg", "explanation": "The string_agg aggregate function concatenates rows into a single string using a specified separator as its second argument."}

{"answer": "no", "explanation": "Plain VACUUM does not return space occupied by dead tuples to the operating system; only VACUUM FULL (and automatic vacuuming with autovacuum_vacuum_scale_factor adjustments) actually reclaims and returns disk space to the OS."}

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

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

{"answer": "yes", "explanation": "PostgreSQL operates in autocommit mode by default, so each individual SQL statement is automatically wrapped in its own transaction and committed immediately unless you explicitly use BEGIN/COMMIT."}

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

{"answer": "yes", "explanation": "Indexes speed up row location for UPDATE and DELETE operations just as they do for SELECT when searching on an indexed column, since all three rely on the index to find matching rows efficiently."}

{"answer": "yes", "explanation": "SAVEPOINT allows you to create a marker within a transaction so you can roll back to that specific point without discarding the entire transaction."}

{"answer": "no", "explanation": "EXPLAIN ANALYZE actually executes the query and then reports the plan with real execution timing statistics, unlike plain EXPLAIN which shows the plan without executing."}

```json ⏎ { ⏎   "answer": "pgvector", ⏎   "explanation": "pgvector is the PostgreSQL extension that adds vector data types and indexing (HNSW, IVFFlat) for vector/embedding similarity search." ⏎ } ⏎ ```

{"answer": "yes", "explanation": "A partial index in PostgreSQL is built only over the rows that satisfy the WHERE condition specified in the CREATE INDEX statement."}

{"answer": "no", "explanation": "In PostgreSQL, SERIALIZABLE is implemented using Serializable Snapshot Isolation (SSI), which detects and aborts serializable anomalies rather than locking all rows that a transaction reads."}

{"answer": "yes", "explanation": "HTTP 201 (Created) indicates that the request succeeded in creating a new resource on the server."}

{"answer": "204", "explanation": "HTTP 204 No Content indicates the request succeeded but there is no body to return, which is commonly used after DELETE operations."}

{"answer": "yes", "explanation": "The DELETE method is defined as idempotent in RFC 7231, meaning multiple identical delete requests produce the same server state as a single request."}

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "The Access-Control-Allow-Origin header is sent by the server, not the client, to indicate which origins are permitted to read the response." ⏎ } ⏎ ```

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

{"answer": "no", "explanation": "This 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, unlike PUT, and unlike PUT it permits, in fact encourages, the updating of metadata associated with a resource."}

{"answer": "false", "explanation": "Using == for hash comparison is vulnerable to timing attacks and, with string hashes, can be bypassed via scientific notation colliding (e.g., '0e123456' == '0e678901' both evaluate to 0), so a constant-time function like hash_equals() must be used."}

{"answer": "yes", "explanation": "CSRF tokens are server-generated, tied to the user's session, and validated server-side on state-changing requests to prevent cross-site request forgery."}

{"answer": "Content-Security-Policy", "explanation": "The Content-Security-Policy HTTP header enables CSP by specifying which content sources are allowed to be loaded and executed by the browser."}

{"answer": "no", "explanation": "OAuth 2.0 is an authorization framework, not an authentication protocol; an access token grants access to resources but does not inherently identify the user, which is why OpenID Connect was built on top of OAuth 2.0 to provide authentication."}

{"answer": "no", "explanation": "XSS is prevented by output encoding/escaping when rendering data, not by validating input on the server, since storing sanitized data does not prevent attacks that occur when the data is later reflected or inserted into HTML output."}

{"answer": "authorization_code", "explanation": "In the OAuth 2.0 authorization code flow, the authorization_code parameter is delivered to the redirect_uri by the authorization server and then exchanged for an access token via the token endpoint."}

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

{"answer": "no", "explanation": "Salts are not secret and do not need to be kept confidential; they are stored alongside the hash and their purpose is to prevent rainbow table attacks and ensure identical passwords produce different hashes, while security relies on the cryptographic hash function itself, not secrecy of the salt."}

{"answer": "false", "explanation": "PHPUnit requires test classes to extend the PHPUnit\\Framework\\TestCase class to run test methods properly."}

{"answer": "false", "explanation": "In PHPUnit, setUp() runs before each individual test method, not once before all tests (that would be setUpBeforeClass())."}

{"answer": "false", "explanation": "A data provider in PHPUnit can return multiple sets of data, allowing a single test method to run once for each argument set."}

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

```json ⏎ { ⏎   "answer": "no", ⏎   "explanation": "The statement is reversed—a stub provides canned return values while a mock verifies which methods were called on it." ⏎ } ⏎ ```

```json ⏎ {"answer": "yes", "explanation": "In PHPUnit 10, the #[DataProvider] attribute was introduced as the modern approach while the @dataProvider annotation was deprecated, though it remains supported until PHPUnit 11."} ⏎ ```

{"answer": "no", "explanation": "PHPUnit does support test dependencies via the @depends annotation and the depends() method, allowing one test to depend on another and pass results as arguments."}

{"answer": "--order-by=random", "explanation": "The --order-by=random option in PHPUnit causes tests to execute in a random order."}

{"answer": "3-4", "explanation": "intdiv(7,2) returns 3 (integer division truncating toward zero) and intdiv(-7,2) returns -4 (also truncating toward zero), which concatenate to the string \"3-4\"."}

```json ⏎ {"answer": "9", "explanation": "The exponentiation operator ** in PHP takes the negative sign as part of the operand, so -3 ** 2 equals (-3) ** 2 which equals 9."} ⏎ ```

{"answer": "true", "explanation": "Both operands contain no leading/trailing whitespace and look like numeric strings, so PHP compares them numerically as 10 == 10, which is true."}

```json ⏎ {"answer": "other", "explanation": "The switch uses loose comparison, but since 'a' is not equal to 0 under loose typing and no case matches, the default block outputs 'other'."} ⏎ ```

```json ⏎ {"answer": "2bc", "explanation": "When strtr() receives an associative array, it uses the longest-match-first rule, so 'ab' is replaced before 'a' can match."} ⏎ ```

{"answer": "[hello]", "explanation": "The substr() function with a negative start position counts from the end, and since -10 is beyond the string length, it returns the entire string 'hello', giving the output '[hello]'."}

{"answer": "k,n,m","explanation": "The array union $a + $b keeps $a's keys first (k, n) and adds $b's unique key (m), giving array_keys of k, n, m."}

{"answer": "yzx","explanation": "The array is sorted by the third element (1, 1, 2), so order becomes [2,'y',1], [3,'z',2], [1,'x',2], and the second-column values implode to 'yzx'."}

```json ⏎ {"answer": "4", "explanation": "The spread operator matches array keys by name, so a=5 and b=1, and a-b=4."} ⏎ ```

```json ⏎ {"answer": "3", "explanation": "The first-class callable syntax $p->g(...) creates a closure bound to the object $p, so the private $v remains accessible even after $p is set to null, and calling $f() returns 3."} ⏎ ```

{"answer": "B", "explanation": "The `static::class` expression uses late static binding, which resolves to the class at runtime (B), not the class where the method is defined (A)."}

```json ⏎ {"answer": "10", "explanation": "This is the synthetic property (initializer/setter syntax) feature, and since the setter multiplies $value by 2, setting $c->x = 5 triggers the setter, storing 10 which is then echoed."} ⏎ ```

```json ⏎ {"answer": "BA", "explanation": "The `TB::f insteadof TA` alias makes f() resolve to TB's version returning 'B', and `TA::f as g` adds a separate alias g() returning 'A', so concatenating gives 'BA'."} ⏎ ```

```json ⏎ {"answer": "0", "explanation": "Static properties in traits are copied per-class, so CX::$n and CY::$n are independent and CY::$n remains 0."} ⏎ ```

{"answer": "2", "explanation": "In PHP, when a try block has a return statement and the finally block also contains a return statement, the finally block's return value overrides the try block's return value."}

{"answer": "second", "explanation": "The inner try throws RuntimeException, but its finally block replaces it by throwing LogicException, which is then caught and echoes 'second'."}

```json ⏎ { ⏎   "answer": "N\\Baz|Baz", ⏎   "explanation": "Within namespace N, Baz::class resolves the aliased import App\\Foo to N\\Baz, while the fully-qualified \\Baz::class resolves to the literal global class name Baz." ⏎ } ⏎ ```

```json ⏎ {"answer": "yesyes", "explanation": "class_exists resolves relative to the current namespace 'Ns' so 'Ns\\Foo' exists, and the fully-qualified 'Ns\\Foo' also matches, both returning true."} ⏎ ```

{"answer": "1,2,99", "explanation": "The reference $v from the foreach loop is overwritten with 99, and since the array's last element still holds a reference to $v, it becomes 99 while the first two elements remain unchanged."}

```json ⏎ {"answer": "1", "explanation": "Static variables in PHP are shared per class scope, not per instance, so $a->inc() and $b->inc() both increment the same $n starting from 0 (a->inc()=1, b->inc()=2), and the final echo $a->inc() outputs 3."} ⏎ ``` ⏎  ⏎ Wait, let me recalculate: a->inc() makes n=1, b->inc() makes n=2, then echo a->inc() makes n=3 and outputs 3. ⏎  ⏎ ```json ⏎ {"answer": "3", "explanation": "Static variables are shared per class scope across inherited methods, so a->inc() sets n=1, b->inc() sets n=2, and echo a->inc() sets n=3 and outputs 3."} ⏎ ```

```json ⏎ { ⏎   "answer": "11", ⏎   "explanation": "The send(10) method makes the first yield return 10, so $x becomes 10, and returning $x + 1 equals 11, which getReturn() retrieves." ⏎ } ⏎ ```

{"answer": "1,2,ok", "explanation": "The `yield from` forwards the values 1 and 2 from inner() and returns 'ok' as the yield from expression's value, which is then yielded by outer()."}

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

```json ⏎ {"answer": "strict-out", "explanation": "The bit value 2048 corresponds to the E_WARNING constant, which remains defined in PHP 8.5, so (E_ALL & 2048) is non-zero and the ternary evaluates to 'strict-out'."} ⏎ ```

```json ⏎ { ⏎   "answer": "mapped", ⏎   "explanation": "Symfony maps the HTTP_X_TOKEN server parameter to the X-Token header, so $r->headers->get('X-Token') returns 'abc' and the condition evaluates to true." ⏎ } ⏎ ```

```json ⏎ {"answer": "ABC", "explanation": "Listeners are called in ascending priority order (10 before 5 before the default 0), so B runs first, then C, then A."} ⏎ ```

{"answer": "same", "explanation": "Doctrine's first-level identity cache ensures that repeated find() calls for the same entity identifier within one EntityManager return the identical object instance."}

```json ⏎ {"answer": "0", "explanation": "The entity is persisted then removed before flush, so the Unit of Work schedules a delete, and after flush the row is deleted from the empty users table, leaving zero rows."} ⏎ ```

```json ⏎ {"answer": "1", "explanation": "COUNT(x) counts only non-NULL values of x, so it returns 1 (ignoring the NULL)."} ⏎ ```

```json ⏎ {"answer": "10,30,60", "explanation": "The window function computes cumulative sums 10, 30, 60 ordered by id, and string_agg concatenates those ordered values with commas."} ⏎ ```

```json ⏎ {"answer": "M1M2", "explanation": "Each middleware echoes its tag before calling the next in the stack, so M1 runs first then M2."} ⏎ ```

```json ⏎ {"answer": "11", "explanation": "Both handlers for the Ping message are registered and executed in order, so $n becomes 1 (from $d1) plus 10 (from $d2) equals 11."} ⏎ ```

```json ⏎ {"answer": "1", "explanation": "The table has a unique index on column a, so both INSERT ... ON CONFLICT DO NOTHING statements insert only one row (the second finds the conflict and does nothing), leaving count(*) = 1."} ⏎ ```

```json ⏎ { ⏎   "answer": "1", ⏎   "explanation": "The DEFERRABLE INITIALLY DEFERRED unique constraint is only checked at COMMIT time, where the second INSERT of value 1 fails with a duplicate key violation, causing the entire transaction (including the first insert) to roll back, so the table is empty and count(*) returns 0." ⏎ } ⏎ ```

{"answer": "4", "explanation": "The filter test_sum matches both test_sum (3 data sets) and test_sum_abs (3 data sets), but since the filter pattern matches the beginning of test_sum_abs, all 6 tests are run."}

{"answer": "2, 1", "explanation": "The data provider prov() yields two test cases ([1] and [-1]), so 2 tests run, and the assertion $this->assertTrue($x > 0) fails for x = -1, giving exactly 1 failure."}

```json ⏎ {"answer": "POST", "explanation": "The `-d` (`--data`) option in curl sends an HTTP POST request with the data as the request body, defaulting to `Content-Type: application/x-www-form-urlencoded`."} ⏎ ```

```json ⏎ {"answer": "GET", "explanation": "The -G flag in curl moves the data specified with -d from the request body to the query string, forcing the HTTP method to be GET instead of the default POST."} ⏎ ```

{"answer": "invalid_client", "explanation": "Per RFC 6749 Section 5.2, when a client authentication fails or the client_id does not exist, the authorization server returns an \"invalid_client\" error.", "explanation": "Per RFC 6749 Section 5.2, when a client authentication fails or the client_id does not exist, the authorization server returns an \"invalid_client\" error."}

```json ⏎ { ⏎   "answer": "the fragment (hash) of the URL", ⏎   "explanation": "For the implicit flow (response_type=token), OAuth 2.0 requires the access_token to be delivered in the URL fragment after the '#' character because fragments are never sent to the server, preventing the token from leaking in server-side logs or Referer headers." ⏎ } ⏎ ```

```json ⏎ {"answer": "0", "explanation": "The default filter returns false (0) because false is considered empty by default in Twig, and 0 * 3 equals 0."} ⏎ ```

{"answer": "Twig\\Error\\RuntimeError", "explanation": "The ~ operator concatenates 'a' as a string, but then attempting to add the result to the integer 2 triggers a TypeError which Twig wraps in a RuntimeError because Twig 3 coerces numeric strings and the concatenation result is not numeric."}

{"answer": "1", "explanation": "An empty string violates NotBlank, producing one constraint violation."}

```json ⏎ {"answer": "Symfony\\Component\\Form\\Exception\\LogicException", "explanation": "Calling isValid() without passing data (or before the form has been submitted/viewed) throws a LogicException because the form cannot determine its validity without data."} ⏎ ```

```json ⏎ {"answer": "same", "explanation": "By default services are singletons (shared), so calling get('a') twice returns the same instance, making the object IDs equal."} ⏎ ```

```json ⏎ { ⏎   "answer": "hi Bob!", ⏎   "explanation": "The ContainerBuilder resolves nested parameter placeholders recursively, so %greeting% expands to 'hi %name%' and %name% expands to 'Bob', resulting in 'hi Bob!'." ⏎ } ⏎ ```

{"answer": "960px", "explanation": "In Bootstrap 5.3, the .container uses .container-sm (the smallest breakpoint) for viewports below the medium breakpoint (md = 992px), which sets a max-width of 960px."}

{"answer": "text-primary", "explanation": "In Bootstrap 5.3, utility classes apply in document order, so text-primary (which comes after text-danger) overrides it as the winning text color."}

```json ⏎ { ⏎   "answer": "2", ⏎   "explanation": "OrderService is in the Domain layer, so its use of PlaceOrder (Application) and Db (Infrastructure) both violate the 'Domain → Domain only' rule, producing two separate violations." ⏎ } ⏎ ```

```json ⏎ { ⏎   "answer": "2", ⏎   "explanation": "BillingService (Domain) imports PlaceOrder from Application (Application → Domain violation) and Db from Infrastructure (Infrastructure → Application violation); the App\\Infrastructure\\Logger type-hint inside App\\Namespace\\... is a self-reference within the same layer and is treated as internal." ⏎ } ⏎ ```

```json ⏎ {"answer": "10,15", "explanation": "$a->amount stays 10 (unchanged), and $c is the result of adding 10 and 5, giving 15."} ⏎ ```

{"answer": "0", "explanation": "The code adds 'a', then remove() throws a DomainException because it's the last item before unset(), which is caught, so the item is never removed; the explanation is flawed because count() counts array elements regardless, and after the exception the array still contains 'a', but the exception means remove() never executed unset()..." "explanation2": "Wait—re-examining: remove() throws BEFORE unset, so 'a' remains in items; count() returns 1, but the question implies output—actually the exception is caught, then count() outputs 1."}

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

```json ⏎ { ⏎   "answer": "yesno", ⏎   "explanation": "newLazyGhost creates a proxy whose initialization closure is only executed on first property access, so isUninitializedLazyObject() returns true (yes) before access and false (no) after $o->v is read." ⏎ } ⏎ ```

```json ⏎ { ⏎     "answer": "no", ⏎     "explanation": "The AbstractGuardAuthenticator class was removed in Symfony 5.9 (Guard authenticators were deprecated in 5.1 and fully removed), so it does not exist in Symfony 8.1." ⏎ } ⏎ ```

```json ⏎ {"answer": "nones", "explanation": "In Symfony 8.1, the Routing\\Loader\\AnnotationClassLoader class was removed (it was deprecated since 6.1), while AttributeClassLoader remains available."} ⏎ ```