Software Engineering FAQ & Answers

Python has no built-in memory limit for processes. Memory usage is limited only by available system RAM and any ulimit or container constraints applied externally.

The default stack size for spawned threads in Rust is 2 MB on most platforms, configurable via the std::thread::Builder::stack_size method.

MySQL 8.0 has a default max_connections setting of 151 connections, with a theoretical maximum of 100,000 connections depending on system resources.

V8's default heap size is approximately 700 MB on 64-bit systems and 1.4 GB on 64-bit systems with --max-old-space-size defaults to approximately 1/2 of available physical memory up to 4GB.

The default timeout for TCP connections in CLOSE_WAIT state is 60 seconds, configurable via nf_conntrack_tcp_timeout_close_wait.

The default initial value for eventfd is 0, unless a different value is specified as the initval argument to eventfd().

Python's requests library uses HTTPConnectionPool which defaults to a maximum of 10 connections (pool_connections) and a maximum of 10 connections per host (pool_maxsize).

Detached processes (detached: true) continue running independently after the parent process exits. They become orphaned and are adopted by init (PID 1) or the system's init system.

Files created with File.createTempFile() persist until explicitly deleted. If the deleteOnExit() method is called, the file is scheduled for deletion when the JVM terminates normally (but not on crash or kill -9).

Docker networks persist until explicitly removed with docker network rm. Networks are not automatically deleted when containers attached to them are removed.

The Linux kernel defines SEMMNI (maximum number of semaphore sets) defaulting to 128, SEMMSL (maximum semaphores per set) defaulting to 250, and SEMMNS (total semaphores system-wide) defaulting to 32000.

Calling std::thread destructor without join() or detach() invokes std::terminate(), crashing the program. Threads must be explicitly joined or detached before destruction.

The default somaxconn (net.core.somaxconn) is 128 on Linux. This limits the maximum length of the pending connection queue for listening sockets.

The net.ipv4.tcp_max_tw_buckets kernel parameter defaults to 8192, limiting the maximum number of sockets in TIME_WAIT state to prevent resource exhaustion.

The default soft limit for open file descriptors per process on Linux is typically 1024, which can be viewed with ulimit -n and modified up to the hard limit (usually 65536 or higher).

Detached HEAD states persist until branches are created or commits are garbage collected (after 30+ days with default gc config).

Java's ReentrantLock.lock() acquires the lock indefinitely with no timeout. The tryLock() method returns immediately false if the lock is not available, and tryLock(long timeout, TimeUnit unit) waits for the specified time.

The default preparedStatementCacheQueries is 256, meaning up to 256 prepared statements are cached per connection.

The default minimum number of connections in psycopg2's pool is 1, and the default maximum is not defined by the library itself—the pool grows as needed up to any limit set by the PostgreSQL server or system resources.

eventfd file descriptors are automatically closed when all references are closed or the process exits. The internal counter persists in the kernel until the last file descriptor referring to it is closed.

Detached pthreads (pthread_detach) automatically release their resources when they terminate, without requiring pthread_join. Joinable pthreads retain resources (including stack) until pthread_join is called.

Vulkan objects (buffers, images, fences, etc.) persist until explicitly destroyed with vkDestroy* functions (e.g., vkDestroyBuffer, vkDestroyImage). No automatic cleanup occurs.

The default maximum size of a single shared memory segment (/proc/sys/kernel/shmmax) is 4,294,967,295 bytes (4 GB on 32-bit) or larger on 64-bit systems, often set to half of physical memory.

Linux's /proc/sys/kernel/shmmni controls the maximum number of shared memory segments and defaults to 4096 segments system-wide.

The default maximum heap size (-Xmx) is 1/4 of physical memory for client JVM and 1/4 of physical memory for server JVM on systems with 2GB+ RAM, subject to platform-specific constraints.

Apache's default KeepAliveTimeout is 5 seconds. The default MaxKeepAliveRequests is 100 requests per connection.

Linux creates pipes as file descriptors, so the effective limit is the process's RLIMIT_NOFILE (open file descriptor limit), typically 1024 by default.

By default, NamedTemporaryFile deletes the file automatically when it is closed. If delete=False is specified, the file persists and must be manually removed.

When multiple defer statements are used in a Go function, they are executed in LIFO (Last In, First Out) order—the most recently called defer executes first.

Named semaphores created with sem_open persist until explicitly closed with sem_close and sem_unlink. Unnamed semaphores in shared memory persist until the shared memory is detached.

Docker volumes persist until explicitly removed with docker volume rm. Volumes are not automatically deleted when containers using them are removed.

Redis uses the operating system's file descriptor limits. The recommended minimum ulimit for Redis is 32,064 for high-throughput environments, which can handle up to 10,000 concurrent client connections plus internal file usage.

The default pipe buffer size on macOS is 16,384 bytes (16 KB), controlled by the PIPE_BUF kernel constant.

Git reflog entries expire after 90 days by default (gc.reflogExpire), after which they are eligible for garbage collection.

Process objects in .NET persist until the process exits or is explicitly killed with .Kill(). The .Close() method releases OS resources but does not terminate the process.

Python's with statement and context managers (defined by enter and exit methods) ensure that resources are properly cleaned up regardless of whether an exception occurs, commonly used for file I/O, locks, and database connections.

HikariCP's leakDetectionThreshold defaults to 0 (disabled). When set to a value greater than 0, it logs a warning if a connection is held longer than the threshold milliseconds.

Go has no hard limit on the number of goroutines. The scheduler can run millions of goroutines limited only by available memory. Each goroutine starts with a stack size of approximately 2 KB on Go 1.18+.

Python threads are daemon threads by default if not marked explicitly, though they actually default to non-daemon. The Python interpreter waits for all non-daemon threads to exit before terminating.

Unix domain sockets created in the filesystem (socket path) must be explicitly removed with unlink() or rm after close() to clean up the socket file. Bound sockets in the abstract namespace (starting with null byte) are automatically cleaned up when closed.

File handles persist until explicitly closed with CloseHandle(). Handles are not automatically closed when the process crashes (but are closed on normal exit). Unclosed handles leak system resources.

The default maximum pool size for .NET SQL Server connections is 100, and the default minimum pool size is 0.

Timeouts created with setTimeout() execute once and are automatically cleaned up after firing (unless they reference the timer object elsewhere). Unfired timers persist until the process exits or they are cleared with clearTimeout().

HikariCP's default maximumPoolSize is calculated as CPU cores * 2 (with a minimum of 10 if not explicitly set). The default minimumIdle is the same as maximumPoolSize.

Linux's ephemeral port range (net.ipv4.ip_local_port_range) defaults to 32768-60999 (28,232 ports). The number of available ports equals the range size minus the number of ports in TIME_WAIT.

There is no explicit limit on the number of epoll instances a process can create, other than the general file descriptor limit (RLIMIT_NOFILE).

Virtual machine domains persist after libvirtd restarts. Domains must be explicitly destroyed with virDomainDestroy() or virsh destroy.

Memory mappings created with mmap are automatically unmapped when the process terminates. During execution, they persist until explicitly unmapped with munmap() or when the process exits.

Named semaphores (CreateSemaphore) persist until all handles are closed with CloseHandle(). The semaphore is automatically destroyed when the last handle is closed.

PersistentVolumes persist until explicitly deleted, regardless of Pod lifecycle. The reclaim policy (default: Retain) determines behavior after claim deletion.

When a process reaches its file descriptor limit, any attempt to open new files, sockets, or pipes will fail with the error "EMFILE: Too many open files" or "Too many open files in system."

The default ThreadPoolExecutor core pool size equals the number of processors, and the maximum pool size is Integer.MAX_VALUE (2,147,483,647) for cached thread pools.

Intervals created with setInterval() continue firing until explicitly cleared with clearInterval() or the process terminates. They persist even if the referenced callback function goes out of scope.

Windows file locks (LockFile/UnlockFile) are not automatically released when a process terminates abnormally (crash). They are released on normal process exit but may persist after crashes until the system reboots or handles are forcibly closed.

Pid files created in /var/run or /var/run/*.pid must be explicitly removed by the daemon process on exit. Many daemons fail to clean up pid files when killed abruptly.

OpenCL buffers (cl_mem) persist until explicitly released with clReleaseMemObject(). Memory leaks if objects are not released before the program exits.

Cmd.Start() starts a process that runs independently. The process continues until it exits or is explicitly killed with Cmd.Process.Kill(). No automatic cleanup occurs when the parent exits.

The default inotify max_user_watches is 8,192 per user, though this was increased to 524,288 in many modern distributions. Each watched directory entry consumes one watch.

Goroutines cannot be forcefully stopped. They exit only when their function returns or when the program exits. Resources must be explicitly cleaned up via context cancellation, channel signaling, or sync.WaitGroup.

The default timeout is 0, meaning no timeout (sockets wait indefinitely).

Event listeners added with addEventListener remain attached until explicitly removed with removeEventListener or when the event emitter object is garbage collected.

The default net.core.rmem_default is 212,992 bytes (208 KB), and the maximum net.core.rmem_max is 4,194,304 bytes (4 MB) unless modified.

The default inotify max_user_instances is 128, limiting the number of inotify instances (watches) a user can create. Each instance can watch up to max_user_watches (default 8192).

The default keepAliveTime for ThreadPoolExecutor cached pools is 60 seconds, after which idle threads are terminated if there are more than corePoolSize threads.

The default maximum number of open connections in Go's database/sql is 0 (unlimited), and the default maximum idle connections is 2. The default maximum lifetime of a connection is 0 (no expiration).

Processes started with ProcessBuilder persist until they exit or are destroyed with destroy() (sends SIGTERM on Unix). destroyForcibly() sends SIGKILL. No automatic cleanup occurs when the parent exits.

Windows TCP keep-alive defaults to 2 hours (7,200,000 milliseconds) for keepalive time, 1 second (1,000 ms) interval, and 5 retries for keep-alive failures.

POSIX record locks are released on file descriptor close only if that file descriptor was the one that acquired the lock. Locks are not automatically released on fork() in the child process.

The default nf_conntrack_max is calculated based on available RAM (typically 65536 on systems with 1GB+ RAM), limiting the maximum number of concurrent connections the kernel can track.

CUDA memory allocated with cudaMalloc persists until explicitly freed with cudaFree(). Memory is not automatically freed when the host process exits abnormally.

Forked child processes become independent processes. If the parent exits before the child, the child becomes orphaned and is adopted by init (PID 1).

The default terminationGracePeriodSeconds is 30 seconds, allowing the pod time to shut down gracefully before being forcefully killed.

Containers persist after the container process exits until explicitly removed with docker rm. Docker ps -a shows stopped containers awaiting removal.

The net.ipv4.tcp_keepalive_time defaults to 7200 seconds (2 hours), net.ipv4.tcp_keepalive_intvl defaults to 75 seconds, and net.ipv4.tcp_keepalive_probes defaults to 9 probes.

OpenGL contexts persist until explicitly destroyed with wglDeleteContext(), glXDestroyContext(), or equivalent platform-specific function. The context is not automatically destroyed when the window is closed.

Python's threading.Lock.acquire() blocks indefinitely (no timeout) unless a timeout argument is explicitly provided.

Linux's net.ipv4.tcp_fin_timeout defaults to 60 seconds, controlling how long the kernel waits for the remote side to close a connection before forcibly closing it.

timerfd file descriptors are automatically closed on process exit. The timer itself is disarmed and all resources freed when the last file descriptor is closed.

The default stack size for Java threads is 1 MB on 64-bit JVMs (or 512 KB on some 32-bit systems), configurable via the -Xss JVM flag.

The default soft limit for open files on macOS is 256 for standard processes, though this can be increased with ulimit or launchd configuration. The hard limit is typically 10,240 or higher depending on system version.

If no backlog argument is provided to socket.listen(), Python defaults to SOMAXCONN (128 on Linux, 128 on macOS, and 5 on some older Unix systems).

c3p0's default checkoutTimeout is 0, meaning if a connection is unavailable, the calling thread will wait indefinitely.

The default maximum number of handles per process is 16,384, though this can be affected by system-wide memory limits. Each handle consumes kernel memory.

The default timeout for established TCP connections in nf_conntrack is 432,000 seconds (5 days), configurable via nf_conntrack_tcp_timeout_established.

The kernel closes all open file descriptors including sockets when a process terminates (via exit or signal), sending FIN packets for established connections and automatically freeing all resources. Orphaned sockets remain in TIME_WAIT briefly.

setImmediate callbacks execute once in the next check phase of the event loop and are automatically cleaned up after execution.

Shared memory segments persist until explicitly removed with shmctl(IPC_RMID) or until the system reboots, even after all processes have detached.

.NET has no default memory limit for 64-bit processes. 32-bit processes are limited to 2 GB (or 3 GB with /3GB boot flag). Container limits can be applied via configuration.

The default pipe buffer size is 65536 bytes (64 KB) on Linux, configurable via fcntl() with F_SETPIPE_SZ up to the maximum /proc/sys/fs/pipe-max-size (typically 1,048,576 bytes or 1 MB).

Boost.Thread automatically calls detach() in the destructor if the thread is joinable but not joined, leaking thread resources without crashing. The newer behavior is to call std::terminate().

The default initial heap size (-Xms) is 1/64 of physical memory for client JVM with a minimum of 8 MB, and 1/64 of physical memory for server JVM with a minimum of 8 MB.

The default maxsize for urllib3's HTTPConnectionPool is 10 connections per host, with the default num_pools set to 10.

Go has no explicit per-goroutine memory limit. Goroutines share the process's memory space, limited only by available system memory and the GOMEMLIMIT environment variable (introduced in Go 1.19) which defaults to unlimited.

Rust threads (std::thread) are automatically joined when the Thread object is dropped (via RAII), blocking until completion unless explicitly detached with spawn.

The default size of /dev/shm is half of physical RAM (50%), configurable via the size mount option in /etc/fstab or via remount.

Windows ephemeral port range defaults to 49152-65535 (16,384 ports) on modern Windows versions, with dynamic port range configurable via netsh.

Python inherits the system's ulimit -n value, which is typically 1024 or 256 on many Unix-like systems. This can be checked via resource.getrlimit(resource.RLIMIT_NOFILE).

File locks (flock, fcntl) are automatically released when any file descriptor referring to the lock is closed. All locks are released when the process terminates.

Files created with Path.GetTempFileName() are not automatically deleted. The caller is responsible for deleting them when no longer needed.

epoll file descriptors are automatically closed on process exit. The epoll instance and all associated resources are freed when the last file descriptor referring to it is closed.

psycopg2 does not buffer statements by default—it sends each execute() call immediately to the server unless using a cursor with a named server-side cursor.

MongoDB defaults to a maximum of 64000 file descriptors on Unix-like systems, but will issue a warning if the system limit is set below this threshold.

pthread_mutex_t in shared memory persists after process exit unless explicitly destroyed with pthread_mutex_destroy(). The mutex must be in an unlocked state before destruction.

process.nextTick callbacks are queued and executed before the event loop continues. They cannot be cancelled once queued and persist until execution or process termination.

Files created with mkstemp must be explicitly removed with unlink(). The function creates a uniquely-named file but does not automatically delete it. The caller is responsible for cleanup.

Ruby has a default maximum of approximately 2048 threads (depending on thread stack size and memory), though Ruby 3.0+ with Ractor may have different constraints. Each thread allocates a stack size controlled by RUBY_THREAD_VM_STACK_SIZE.

The default pthread_mutex_t created with PTHREAD_MUTEX_INITIALIZER is a "normal" mutex (PTHREAD_MUTEX_DEFAULT) which does not provide error checking or recursive locking behavior.

RAII (Resource Acquisition Is Initialization) is a C++ programming idiom where resource acquisition is tied to object initialization, and resource release is automatically performed when the object goes out of scope through its destructor. This ensures exception-safe resource cleanup without explicit release code.

If ConnectTimeout is not set in .NET's SqlConnection, the default timeout is 15 seconds.

Node.js has no built-in limit on concurrent async operations, but each async I/O operation consumes a file descriptor or handle, making the effective limit equal to the system's file descriptor limit.

Destroying a locked pthread_mutex with pthread_mutex_destroy() results in undefined behavior. The POSIX standard requires the mutex to be unlocked before destruction.

Child processes persist until they exit naturally or are explicitly killed with child.kill(). If the parent exits without dropping the Child object, the process becomes orphaned and adopted by init.

Named mutexes (CreateMutex) persist until all handles are closed with CloseHandle(). The mutex is automatically destroyed when the last handle is closed.

signalfd file descriptors are automatically closed on process exit. Signal masks must still be managed via sigprocmask even when using signalfd.

The default stack size for std::thread is implementation-defined, typically matching the pthreads default (8 MB on Linux, 512 KB or 1 MB on Windows).

Node.js cluster inherits the system's file descriptor limits. Each worker in a cluster shares the same listening socket but has its own set of file descriptors for client connections.

Directories created with fs.mkdtemp must be explicitly removed. The function creates a unique temporary directory but does not automatically delete it.

The default loginTimeout for standard JDBC connections is 0, meaning it waits indefinitely for a connection to be established.

The default timeout for TCP connections in TIME_WAIT state is 120 seconds, configurable via nf_conntrack_tcp_timeout_time_wait.

Windows has a default limit of 16,384 handles per process, though this can be affected by system-wide memory limits and the specific Windows edition.

A resource leak occurs when a program acquires a resource (such as memory, file handles, database connections, network sockets, or file descriptors) but fails to release it back to the system when it's no longer needed. This eventually leads to resource exhaustion, causing the program or system to crash or become unresponsive.

Subprocesses persist until they exit naturally or are explicitly terminated with .kill() or .terminate(). If the parent exits without waiting, subprocesses may become orphaned (adopted by init).

Unreferenced Git objects are eligible for garbage collection after 2 weeks (default gc.pruneExpire), unless explicitly pruned with git gc --prune=now.

Python asyncio tasks run until completion unless explicitly cancelled. The event loop maintains references to all tasks unless they are created with create_task() and manually awaited or cancelled.

Pods persist after termination in a Completed or Failed state until garbage collection removes them. The default termination grace period is 30 seconds.

The default number of worker threads in tokio multi-thread runtime equals the number of CPU cores (logical processors), accessible via rayon::current_num_threads().

NGINX has a default worker_connections value of 1024 per worker process. The total maximum connections equals worker_connections multiplied by the number of worker processes.

The default idle timeout is 10,000 milliseconds (10 seconds) after which idle connections are terminated. The default connection timeout is 0 (no timeout).

The try-with-resources statement automatically closes all resources that implement the AutoCloseable interface when the try block exits, either normally or due to an exception. Resources are closed in the reverse order of their creation.

PostgreSQL has a default max_connections setting of 100 connections, which can be modified in the postgresql.conf file or via the -C flag when starting the server.

Event objects persist until all handles are closed with CloseHandle(). The event is automatically destroyed when the last handle is closed.

Ruby threads are scheduled by the global interpreter lock and are automatically cleaned up when they complete. The main thread waits for all non-daemon threads before exiting.

Tokio tasks are automatically dropped when they complete or are cancelled. If a task contains resources requiring cleanup, they must be dropped within the task's future before completion.

The default maxSockets for Node.js's http.globalAgent is Infinity (unlimited) on Node.js 0.12.0+, but http.Agent limits total sockets to 256 for legacy keep-alive support.

The default net.core.wmem_default is 212,992 bytes (208 KB), and the maximum net.core.wmem_max is 4,194,304 bytes (4 MB) unless modified.

V8's garbage collector runs automatically based on heuristics and memory allocation patterns, not on a fixed timeout. It uses generational garbage collection with incremental marking.

Child processes persist until explicitly killed with .kill() or .send('SIGTERM') or until they exit naturally. The parent process must handle cleanup to avoid zombie processes.

macOS ephemeral port range defaults to 49152-65535 (16,384 ports), controlled by the net.inet.ip.portrange sysctl values (first and last).

There is no explicit limit on the number of timers, but each timer consumes memory and the system's file descriptor limit may indirectly constrain resources.

The default stack size for a new thread created with pthread_create is 8 MB (8,388,608 bytes) on most Linux systems (RLIMIT_STACK).

POSIX shared memory objects created with shm_open persist until explicitly unlinked with shm_unlink() or system reboot, similar to files in /dev/shm.

Node.js server.listen() defaults to 511 as the backlog parameter, which can be overridden by passing an explicit backlog value.

--no-ensure-ascii preserves unicode characters instead of converting to escape sequences.

That test files are named correctly according to the specified test framework.

That scripts with shebangs are executable.

Use -p / --pattern with a regex pattern (e.g., --pattern, release/.*). Can be specified multiple times.

--ignore-case folds lower case to upper case characters.

Use --ignore=type1,type2,… to ignore requirements for specific builtin types.

Run pre-commit install which sets up the hooks in .git/hooks/pre-commit.

auto (default, replaces with most frequent), crlf (forces CRLF), lf (forces LF), and no (checks without modifying).

Replaces or checks mixed line endings in files.

Run pre-commit sample-config to generate a very basic configuration.

That links to VCS websites are permalinks.

An empty string ('') which matches all files.

Attempts to load all TOML files to verify syntax.

False, meaning pre-commit will continue running hooks after failures unless set to true.

A framework for managing and maintaining multi-language pre-commit hooks that specifies a list of hooks to use and manages the installation and execution of any hook written in any language before every commit.

Runs during git push after remote refs have been updated but before any objects are transferred, receiving the remote name and location plus a list of to-be-updated refs through stdin.

Prevents addition of new git submodules, intended as a helper to migrate away from submodules.

Simply checks whether Python files parse as valid Python.

The path to the file holding the commit message, the type of commit, and the commit SHA-1 if this is an amended commit.

Use args: [--branch, staging, --branch, main] or -b / --branch (can be specified multiple times) to set protected branches.

The pre-commit hook is run first, before typing in a commit message, used to inspect the snapshot that's about to be committed. Exiting non-zero aborts the commit.

Instead of loading files, it simply parses them for syntax, enabling extensions and unsafe constructs which would otherwise be forbidden. This implies --allow-multiple-documents.

That non-binary executables have a proper shebang line.

Forbids any submodules in the repository.

Run by commands that replace commits such as git commit --amend and git rebase, receiving which command triggered the rewrite as an argument and a list of rewrites on stdin.

Replaces double quoted strings with single quoted strings.

Attempts to load all XML files to verify syntax.

--allow-missing-credentials allows the hook to pass when no credentials are detected.

.pre-commit-config.yaml which should be placed at the root of your project.

Runs before rebasing anything and can halt the process by exiting non-zero, commonly used to disallow rebasing commits that have already been pushed.

Runs before the commit message editor fires up but after the default message is created, allowing editing of the default message before the commit author sees it.

In the hooks subdirectory of the Git directory, typically .git/hooks.

Set always_run: false to allow the hook to be skipped according to file filters, but note that empty commits (git commit --allow-empty) would always be allowed.

auto mode which automatically replaces with the most frequent line ending. This is the default argument.

--assume-in-merge allows running the hook even when no merge is currently in progress.

Both main and master branches are protected by default if no branch argument is set.

Runs after a successful git merge command, used to restore data in the working tree that Git can't track such as permissions data.

Makes sure files end in a newline and only a newline.

^$ which excludes nothing by default.

Files that contain merge conflict strings such as <<<<<<<, =======, >>>>>>>.

Run pre-commit autoupdate which brings hooks to the latest tag on the default branch.

--autofix automatically formats JSON files.

Attempts to load all YAML files to verify syntax.

Use git commit --no-verify to bypass the pre-commit hook.

That all JSON files are "pretty" with sorted keys and indentation.

Debugger imports and Python 3.7+ breakpoint() calls in Python source code.

--pytest is the default, ensuring tests match .*_test\.py.

Runs after a successful git checkout, used to set up the working directory properly for the project environment.

Takes the path to a temporary file containing the commit message as a parameter; exiting non-zero aborts the commit process, used to validate commit messages.

--no-allow-dict-kwargs forbids dict keyword syntax.

Yes, no-commit-to-branch is configured by default to always_run: true, ignoring any settings of files, exclude, types or exclude_types.

2 spaces, which can be controlled with --indent option (specify a number for spaces or a string of whitespace).

--allow-multiple-documents which allows YAML files using the multi-document syntax.

Use --additional-github-domain DOMAIN which can be repeated multiple times (e.g., github.example.com for GitHub Enterprise).

--pytest (default: .*_test\.py), --pytest-test-first (test_.*\.py), --django or --unittest (test.*\.py).

--unique ensures each line is unique.

500 kilobytes, but can be customized with args: ['--maxkb=123'].

Symlinks which are changed to regular files with content of a path that the symlink was pointing to, commonly happening on Windows when users clone repositories without symlink creation permissions.

Files that cannot be created on Windows.

The existence of AWS secrets configured with the AWS CLI.

--no-sort-keys retains the original key ordering instead of sorting when autofixing.

'0' (no minimum version requirement by default).

The existence of private keys in files.

Sorts the lines in specified files alphabetically, removes blank lines, does not respect comments, and converts all newlines to line feeds (\n).

Run pip install pre-commit and add pre-commit to your requirements.txt or requirements-dev.txt file.

Files with names that would conflict on a case-insensitive filesystem like macOS HFS+ or Windows FAT.

Runs after the entire commit process is completed, takes no parameters, and can get the last commit by running git log -1 HEAD.

Run pre-commit run <hook_id> to execute an individual hook.

Run pre-commit run --all-files to execute hooks against all files in the repository.

All stages, meaning hooks run at all git hook stages by default unless overridden.

Checks for symlinks which do not point to anything.

.sample - they must be renamed to be enabled.

Attempts to load all JSON files to verify syntax validity.

Use --credentials-file CREDENTIALS_FILE to specify additional AWS CLI style configuration files in non-standard locations. Can be repeated multiple times.

[pre-commit] meaning hooks are installed as pre-commit hooks by default.

Removes UTF-8 byte order marker (BOM) from files.

Requires literal syntax when initializing empty or zero Python builtin types (e.g., {} instead of dict(), [] instead of list()).

Removes trailing whitespace from files.

No, client-side hooks are not copied when cloning a repository.

Pytest stores exception information in sys.last_value, sys.last_type, and sys.last_traceback. In interactive use, this allows dropping into postmortem debugging. You can access line numbers with sys.last_traceback.tb_lineno.

Use --test-timeout=0 to prevent tests from timing out when stopping at breakpoints during debugging.

Use --no-file-parallelism to prevent test files from running in parallel, which is necessary for proper debugging.

Use the toHaveBeenLastCalledWith matcher. For example: expect(drink).toHaveBeenLastCalledWith('mango') tests the last call's arguments.

Use the toThrow matcher. For example: expect(() => compileAndroidCode()).toThrow() or expect(() => compileAndroidCode()).toThrow('you are using the wrong JDK') to match error message text.

Use the toHaveBeenCalledWith matcher. For example: expect(drink).toHaveBeenCalledWith(beverage) checks that the function was called with specific arguments.

Use the context manager: with caplog.at_level(logging.INFO): to temporarily change the log level inside a with block.

Use pytest.raises() as a context manager: with pytest.raises(ZeroDivisionError): 1 / 0.

Use the toHaveBeenNthCalledWith(nthCall, arg1, arg2, ...) matcher to check arguments for a specific call number.

Access all log records via caplog.records (list of logging.LogRecord instances) or the final log text via caplog.text.

The faulthandler module is automatically enabled for pytest runs. The faulthandler_timeout=X configuration option can be used to dump the traceback of all threads if a test takes longer than X seconds to finish.

Use --log-file-mode=a to open the log file in append mode instead of overwrite mode.

Call caplog.clear() to reset the captured log records in a test.

Use the -p no:unraisableexception command-line option to disable warnings about unraisable exceptions.

When breakpoint() is called and PYTHONBREAKPOINT is set to the default value, pytest uses a custom internal PDB trace UI instead of the system default Pdb. When tests complete, the system defaults back to the system Pdb trace UI.

Each captured log message shows the module name, line number, log level, and message.

Use caplog.get_records(when) method where when can be "setup", "call", or "teardown" to access logs from specific stages.

Pass --inspect or --inspect-brk to the Vitest CLI to enable the Node.js inspector. The --inspect-brk option breaks before starting execution.

Use --log-file=/path/to/log/file to record the whole test suite logging calls to a file. By default, this opens in write mode (overwrites each run).

Use pytest --pdb --maxfail=3 to drop to PDB for the first three failures only.

Use -p no:faulthandler on the command-line to disable the faulthandler module.

Use toBeCloseTo instead of toEqual for floating-point comparisons because of tiny rounding errors. For example, 0.1 + 0.2 is not strictly equal to 0.3 in JavaScript.

pytest.RaisesGroup accepts: a match parameter (checks against group message), a check parameter (arbitrary callable that receives the group), flatten_subgroups (boolean), and allow_unwrapped (boolean) parameters.

By default, Vitest uses port 9229 for debugging. You can override this by passing a value to --inspect-brk, for example: --inspect-brk=127.0.0.1:3000.

Use the .resolves modifier to unwrap a fulfilled promise. For example: await expect(Promise.resolve('lemon')).resolves.toBe('lemon').

The caplog fixture allows changing the log level for captured log messages using caplog.set_level(logging.INFO).

Use toEqual which recursively checks every field of an object or array. For stricter comparison that considers undefined properties and array sparseness, use toStrictEqual.

Use pytest -x or pytest --exitfirst to stop the testing process after the first failure. This is useful for focusing on debugging one issue at a time.

Use pytest --log-format="%(asctime)s %(levelname)s %(message)s" and optionally --log-date-format="%Y-%m-%d %H:%M:%S" to customize log output format.

Assertion introspection is pytest's ability to automatically display the values of subexpressions when an assertion fails, showing function call returns, attribute accesses, comparisons, and operators without requiring boilerplate code. For example, when assert f() == 4 fails where f() returns 3, pytest displays assert 3 == 4 with + where 3 = f().

Use the toHaveBeenCalledTimes(number) matcher. For example: expect(drink).toHaveBeenCalledTimes(2) verifies the function was called exactly 2 times.

Use the -p no:threadexception command-line option to disable warnings about unhandled thread exceptions.

Use assert (0.1 + 0.2) == pytest.approx(0.3) instead of exact equality checks. pytest.approx works with scalars, lists, dictionaries, and NumPy arrays, and supports comparisons involving NaNs.

The toBe matcher uses Object.is to test exact equality, which is even better for testing than the === strict equality operator.

Use caplog.record_tuples which contains tuples of (logger_name, level, message). For example: python assert caplog.record_tuples == [("root", logging.INFO, "boo arg")]

Use the as clause to capture exception info: with pytest.raises(RuntimeError) as excinfo:. The ExceptionInfo instance provides .type, .value, and .traceback attributes.

pytest.RaisesExc specifies details about contained exceptions within an exception group, including match patterns for exception messages. It provides a matches() method for checking outside of the context manager usage.

The excinfo.group_contains() helper makes it easy to check for the presence of specific exceptions but is very bad for checking that the group does not contain any other exceptions. A test can pass even if unexpected exceptions are present in the group.

Pytest shows the failed assertion with the actual values displayed, including a "where" clause that traces the source of intermediate values. For the assertion assert f() == 4 failing, pytest shows: E assert 3 == 4 E + where 3 = f()

In strict assertion mode (available via require('node:assert/strict')), non-strict methods behave like their corresponding strict methods, and error messages display diffs. In legacy mode (default require('node:assert')), methods like deepEqual use the == operator which can have surprising results.

You can use Chrome DevTools by opening chrome://inspect in your browser, or use IDE debuggers like VS Code or IntelliJ IDEA.

Use pytest --maxfail=2 (or any number) to stop after a specified number of failures. For example, --maxfail=2 stops after two failures.

Use vitest --inspect-brk --no-file-parallelism to run tests in a single worker suitable for debugging with Chrome DevTools or other debuggers.

Pytest detects and issues warnings visible in the test run summary for unraisable exceptions (exceptions raised in del implementations) and unhandled thread exceptions. The warning categories are pytest.PytestUnraisableExceptionWarning and pytest.PytestUnhandledThreadExceptionWarning.

Use pytest --trace to invoke the Python debugger at the start of every test.

Pytest captures log messages of level WARNING or above automatically and displays them in their own section for each failed test.

Use the .rejects modifier to unwrap a rejected promise. For example: await expect(Promise.reject(new Error('octopus'))).rejects.toThrow('octopus').