# Patryk Golabek

> Generated: 2026-03-10

> Cloud-Native Software Architect with 17+ years of experience in Kubernetes, AI/ML systems, platform engineering, and DevSecOps. Ontario, Canada.

## Authority

- 17+ years of production software engineering experience
- Pre-1.0 Kubernetes adopter — building production clusters since before the 1.0 release
- Former CTO and co-founder — led teams and shaped technical strategy
- 20+ public open-source repositories on GitHub
- Active technical writer across cloud-native architecture, AI/ML, and platform engineering
- Expertise spans backend, frontend, infrastructure, data science, and AI/ML systems

## Expertise Areas

- Kubernetes & Cloud-Native Architecture — 10+ years (pre-1.0 adopter, production platforms)
- AI/ML Systems & LLM Agents — 3+ years (RAG pipelines, LangGraph, Langflow)
- Platform Engineering & DevSecOps — 10+ years (Terraform, CI/CD, GitOps)
- Full-Stack Development — 17+ years (Python, Java, TypeScript, React, Angular)
- Infrastructure as Code — 8+ years (Terraform, Terragrunt, Helm)

## Pages

- [Projects](https://patrykgolabek.dev/projects/): Featured open-source projects and work
- [About](https://patrykgolabek.dev/about/): Background and experience
- [Contact](https://patrykgolabek.dev/contact/): Get in touch

## Key Projects

- networking-tools: Pentesting learning lab with 17 security tools, 28 scripts, and Docker-based vulnerable targets
  Live: https://networking-tools.patrykgolabek.dev/
  Source: https://github.com/PatrykQuantumNomad/networking-tools
- financial-data-extractor: Full-stack financial statement extraction with FastAPI, Next.js 15, and LLM-powered PDF parsing
  Live: https://financial-data-extractor.patrykgolabek.dev
  Source: https://github.com/PatrykQuantumNomad/financial-data-extractor
- JobFlow: Multi-platform job scraper with scoring, human-in-the-loop applications, and 544 tests
  Live: https://jobflow.patrykgolabek.dev
  Source: https://github.com/PatrykQuantumNomad/jobs
- kubert-assistant-lite: Open-source DevOps tool combining local Kubernetes cluster deployment via kind with an AI-powered Kubectl Agent
  Live: https://kubert-assistant-lite.patrykgolabek.dev/
  Source: https://github.com/TranslucentComputing/kubert-assistant-lite
- Kinder: Kubernetes IN Docker Enhanced Runtime — extends kind with MetalLB, Envoy Gateway, Metrics Server, tuned CoreDNS, and Headlamp dashboard pre-installed
  Live: https://kinder.patrykgolabek.dev/
  Source: https://github.com/PatrykQuantumNomad/kinder
- pincer-ops: GitOps-driven Kubernetes platform — bootstraps production-grade KIND cluster with ArgoCD, MetalLB, Envoy Gateway, and Sealed Secrets
  Live: https://pincer.patrykgolabek.dev/
  Source: https://github.com/PatrykQuantumNomad/pincer-ops
- webinar-slack-bot: Production-ready Slack bot on Kubernetes with Slack Bolt, FastAPI, DevSpace, and full observability stack
  Live: https://webinar-slack-bot.patrykgolabek.dev/
  Source: https://github.com/TranslucentComputing/webinar-slack-bot

## Interactive Tools

Free browser-based developer tools. 100% client-side -- your code never leaves your device.

- Docker Compose Validator: 52-rule engine analyzing docker-compose.yml for schema, security, semantic, best-practice, and style issues. Category-weighted scoring with letter grades (A+ through F). Interactive dependency graph with cycle detection. Downloadable as a Claude Skill.
  URL: https://patrykgolabek.dev/tools/compose-validator/
  Rules: https://patrykgolabek.dev/tools/compose-validator/rules/cv-c001/ (52 individual rule documentation pages)
  Blog: https://patrykgolabek.dev/blog/docker-compose-best-practices/

- Dockerfile Analyzer: 46-rule engine analyzing Dockerfiles for security, efficiency, maintainability, reliability, and best-practice issues. Based on Hadolint DL codes plus custom production Kubernetes rules. Downloadable as a Claude Skill.
  URL: https://patrykgolabek.dev/tools/dockerfile-analyzer/
  Rules: https://patrykgolabek.dev/tools/dockerfile-analyzer/rules/dl3006/ (individual rule documentation pages)
  Blog: https://patrykgolabek.dev/blog/dockerfile-best-practices/

- Kubernetes Manifest Analyzer: 67-rule engine analyzing Kubernetes manifests for schema, security, reliability, best-practice, and cross-resource issues. Category-weighted scoring with letter grades. PSS compliance checking, RBAC analysis, and interactive resource dependency graph. 100% client-side.
  URL: https://patrykgolabek.dev/tools/k8s-analyzer/
  Rules: https://patrykgolabek.dev/tools/k8s-analyzer/rules/ka-s001/ (67 individual rule documentation pages)
  Blog: https://patrykgolabek.dev/blog/kubernetes-manifest-best-practices/

- GitHub Actions Workflow Validator: 48-rule engine analyzing GitHub Actions workflows for schema, security, semantic, best-practice, style, and actionlint issues. Two-pass analysis: instant schema + custom rules, plus deep actionlint WASM. Category-weighted scoring with letter grades. 100% client-side.
  URL: https://patrykgolabek.dev/tools/gha-validator/
  Rules: https://patrykgolabek.dev/tools/gha-validator/rules/ga-c001/ (48 individual rule documentation pages)
  Blog: https://patrykgolabek.dev/blog/github-actions-best-practices/

## Beauty Index

The Beauty Index ranks 26 programming languages across 6 aesthetic dimensions (each scored 1-10, max 60):
- Phi: Aesthetic Geometry, Omega: Mathematical Elegance, Lambda: Linguistic Clarity
- Psi: Practitioner Happiness, Gamma: Organic Habitability, Sigma: Conceptual Integrity

- [Beauty Index Overview](https://patrykgolabek.dev/beauty-index/): Full rankings, charts, and scoring table
- [Code Comparison](https://patrykgolabek.dev/beauty-index/code/): 26 languages compared across 10 features
- [Score Justifications](https://patrykgolabek.dev/beauty-index/justifications/): 156 editorial justifications across all dimensions
- [Methodology](https://patrykgolabek.dev/blog/the-beauty-index/): Scoring framework and analysis

- #1 Python: 52/60 — https://patrykgolabek.dev/beauty-index/python/
- #2 Ruby: 52/60 — https://patrykgolabek.dev/beauty-index/ruby/
- #3 Elixir: 52/60 — https://patrykgolabek.dev/beauty-index/elixir/
- #4 Rust: 51/60 — https://patrykgolabek.dev/beauty-index/rust/
- #5 Haskell: 48/60 — https://patrykgolabek.dev/beauty-index/haskell/
- #6 Clojure: 48/60 — https://patrykgolabek.dev/beauty-index/clojure/
- #7 F#: 47/60 — https://patrykgolabek.dev/beauty-index/fsharp/
- #8 Gleam: 47/60 — https://patrykgolabek.dev/beauty-index/gleam/
- #9 Kotlin: 46/60 — https://patrykgolabek.dev/beauty-index/kotlin/
- #10 Swift: 45/60 — https://patrykgolabek.dev/beauty-index/swift/
- #11 Lisp: 44/60 — https://patrykgolabek.dev/beauty-index/lisp/
- #12 OCaml: 44/60 — https://patrykgolabek.dev/beauty-index/ocaml/
- #13 Go: 43/60 — https://patrykgolabek.dev/beauty-index/go/
- #14 Julia: 43/60 — https://patrykgolabek.dev/beauty-index/julia/
- #15 Scala: 41/60 — https://patrykgolabek.dev/beauty-index/scala/
- #16 Zig: 39/60 — https://patrykgolabek.dev/beauty-index/zig/
- #17 TypeScript: 39/60 — https://patrykgolabek.dev/beauty-index/typescript/
- #18 C: 38/60 — https://patrykgolabek.dev/beauty-index/c/
- #19 Lua: 38/60 — https://patrykgolabek.dev/beauty-index/lua/
- #20 Dart: 36/60 — https://patrykgolabek.dev/beauty-index/dart/
- #21 C#: 36/60 — https://patrykgolabek.dev/beauty-index/csharp/
- #22 R: 32/60 — https://patrykgolabek.dev/beauty-index/r/
- #23 Java: 31/60 — https://patrykgolabek.dev/beauty-index/java/
- #24 JavaScript: 30/60 — https://patrykgolabek.dev/beauty-index/javascript/
- #25 C++: 28/60 — https://patrykgolabek.dev/beauty-index/cpp/
- #26 PHP: 25/60 — https://patrykgolabek.dev/beauty-index/php/

### Head-to-Head Comparisons

Compare any two languages side-by-side at /beauty-index/vs/{langA}-vs-{langB}/
URL pattern: https://patrykgolabek.dev/beauty-index/vs/{langA-id}-vs-{langB-id}/

Popular comparisons:
- Python vs Rust: https://patrykgolabek.dev/beauty-index/vs/python-vs-rust/
- Python vs Ruby: https://patrykgolabek.dev/beauty-index/vs/python-vs-ruby/
- Haskell vs Go: https://patrykgolabek.dev/beauty-index/vs/haskell-vs-go/
- Rust vs Go: https://patrykgolabek.dev/beauty-index/vs/rust-vs-go/
- TypeScript vs JavaScript: https://patrykgolabek.dev/beauty-index/vs/typescript-vs-javascript/
- Kotlin vs Swift: https://patrykgolabek.dev/beauty-index/vs/kotlin-vs-swift/
- Elixir vs Clojure: https://patrykgolabek.dev/beauty-index/vs/elixir-vs-clojure/
- Python vs JavaScript: https://patrykgolabek.dev/beauty-index/vs/python-vs-javascript/
- Haskell vs Rust: https://patrykgolabek.dev/beauty-index/vs/haskell-vs-rust/
- Go vs Java: https://patrykgolabek.dev/beauty-index/vs/go-vs-java/

## Database Compass

The Database Compass compares 12 database models across 8 architectural dimensions (each scored 1-10, max 80):
- Scalability, Performance, Reliability, Operational Simplicity
- Query Flexibility, Schema Flexibility, Ecosystem Maturity, Learning Curve

- [Database Compass Overview](https://patrykgolabek.dev/db-compass/): Full rankings, scoring table, and complexity spectrum
- [Methodology](https://patrykgolabek.dev/blog/database-compass/): How to choose a database in 2026

- #1 Document Database: 61/80 — https://patrykgolabek.dev/db-compass/document/
- #2 Key-Value Store: 59/80 — https://patrykgolabek.dev/db-compass/key-value/
- #3 Relational (SQL) Database: 55/80 — https://patrykgolabek.dev/db-compass/relational/
- #4 Search Engine: 53/80 — https://patrykgolabek.dev/db-compass/search/
- #5 In-Memory Database: 52/80 — https://patrykgolabek.dev/db-compass/in-memory/
- #6 Time-Series Database: 50/80 — https://patrykgolabek.dev/db-compass/time-series/
- #7 Wide-Column Store: 50/80 — https://patrykgolabek.dev/db-compass/columnar/
- #8 NewSQL Database: 50/80 — https://patrykgolabek.dev/db-compass/newsql/
- #9 Graph Database: 47/80 — https://patrykgolabek.dev/db-compass/graph/
- #10 Multi-Model Database: 45/80 — https://patrykgolabek.dev/db-compass/multi-model/
- #11 Vector Database: 40/80 — https://patrykgolabek.dev/db-compass/vector/
- #12 Object-Oriented Database: 36/80 — https://patrykgolabek.dev/db-compass/object/

## EDA Visual Encyclopedia

Interactive visual encyclopedia of Exploratory Data Analysis covering 90+ pages based on the NIST/SEMATECH Engineering Statistics Handbook.

- [EDA Visual Encyclopedia](https://patrykgolabek.dev/eda/): Landing page with filterable card grid

### Graphical Techniques (29 pages)

- [4-Plot](https://patrykgolabek.dev/eda/techniques/4-plot/): A 4-plot combines a run-sequence plot, lag plot, histogram, and normal probability plot in a single display. It is used as a quick screening tool to simultaneously check the four underlying assumptions of a univariate dataset.
- [6-Plot](https://patrykgolabek.dev/eda/techniques/6-plot/): A 6-plot is a regression diagnostic display with six panels: response vs predictor, residuals vs predictor, residuals vs predicted values, lag plot of residuals, histogram of residuals, and normal probability plot of residuals. It is used to assess model adequacy after fitting a regression model.
- [Autocorrelation Plot](https://patrykgolabek.dev/eda/techniques/autocorrelation-plot/): An autocorrelation plot displays the autocorrelation of a dataset at successive lag values. It is used to check whether a time series is random or exhibits serial dependence.
- [Bihistogram](https://patrykgolabek.dev/eda/techniques/bihistogram/): A bihistogram displays the histograms of two datasets on a common horizontal axis, one plotted upward and one downward. It is used to compare the distributional characteristics of two groups.
- [Block Plot](https://patrykgolabek.dev/eda/techniques/block-plot/): A block plot displays the means of groups arranged by blocks, revealing whether block effects or treatment effects dominate. It is used in designed experiments to visualize factor and interaction effects.
- [Bootstrap Plot](https://patrykgolabek.dev/eda/techniques/bootstrap-plot/): A bootstrap plot displays the computed value of a sample statistic versus the subsample number for repeated resamples drawn with replacement. It is used to assess the uncertainty, stability, and confidence interval of an estimate.
- [Box Plot](https://patrykgolabek.dev/eda/techniques/box-plot/): A box plot summarizes a dataset using its median, quartiles, and potential outliers in a compact graphical form. It is used to quickly compare distributions across groups and identify skewness and outliers.
- [Box-Cox Linearity Plot](https://patrykgolabek.dev/eda/techniques/box-cox-linearity/): A Box-Cox linearity plot identifies the optimal power transformation to achieve linearity between two variables. It is used when a linear model is desired but the relationship appears curvilinear.
- [Box-Cox Normality Plot](https://patrykgolabek.dev/eda/techniques/box-cox-normality/): A Box-Cox normality plot identifies the optimal power transformation to make a dataset approximately normally distributed. It is used when normality is required for statistical tests but the raw data is skewed.
- [Complex Demodulation](https://patrykgolabek.dev/eda/techniques/complex-demodulation/): Complex demodulation plots display the amplitude and phase of a sinusoidal component in a time series at a specified frequency. They are used to detect whether the amplitude or phase of a cyclic signal changes over time.
- [Conditioning Plot](https://patrykgolabek.dev/eda/techniques/conditioning-plot/): A conditioning plot (coplot) is a plot of two variables conditional on the value of a third variable. It is used to explore how a bivariate relationship changes across levels of a third variable.
- [Contour Plot](https://patrykgolabek.dev/eda/techniques/contour-plot/): A contour plot is a graphical technique for representing a three-dimensional surface by plotting constant z slices, called contours, on a two-dimensional format. It is an alternative to a 3-D surface plot.
- [DOE Plots](https://patrykgolabek.dev/eda/techniques/doe-plots/): DOE plots include the DOE scatter plot, DOE mean plot, and DOE standard deviation plot used in designed experiments. They visualize factor effects on location and spread to determine which factors are statistically significant.
- [Histogram](https://patrykgolabek.dev/eda/techniques/histogram/): A histogram is a graphical summary of the frequency distribution of a single variable. It displays the shape, center, and spread of a dataset by dividing the data range into bins and counting observations in each bin.
- [Lag Plot](https://patrykgolabek.dev/eda/techniques/lag-plot/): A lag plot displays each observation against the observation at a fixed lag interval. It is used to check for randomness, serial correlation, and non-linear structure in time-ordered data.
- [Linear Plots](https://patrykgolabek.dev/eda/techniques/linear-plots/): Linear plots include the linear correlation plot, linear intercept plot, linear slope plot, and linear residual standard deviation plot. They are used to assess how well a linear model fits the data and how its parameters vary across subsets.
- [Mean Plot](https://patrykgolabek.dev/eda/techniques/mean-plot/): A mean plot displays the group means for a factor variable, with an overall reference line for the grand mean. It is used to determine whether a factor has a significant effect on the response variable.
- [Normal Probability Plot](https://patrykgolabek.dev/eda/techniques/normal-probability-plot/): A normal probability plot displays the sorted data values against their expected normal quantiles. It is used to assess whether data follow a normal distribution, with deviations from the reference line indicating non-normality.
- [PPCC Plot](https://patrykgolabek.dev/eda/techniques/ppcc-plot/): A probability plot correlation coefficient (PPCC) plot displays the correlation from a probability plot for a family of distributions indexed by a shape parameter. It is used to identify the best-fitting distribution or optimal transformation.
- [Probability Plot](https://patrykgolabek.dev/eda/techniques/probability-plot/): A probability plot displays the sorted data values against the theoretical quantiles of a specified distribution. It is used to assess whether data follow any distribution family, not just the normal.
- [Q-Q Plot](https://patrykgolabek.dev/eda/techniques/qq-plot/): A quantile-quantile (Q-Q) plot compares the quantiles of two data sets to determine if they come from populations with a common distribution. It is similar to a probability plot, but compares two empirical samples rather than one sample against a theoretical distribution.
- [Run-Sequence Plot](https://patrykgolabek.dev/eda/techniques/run-sequence-plot/): A run-sequence plot displays the data values in the order they were collected, with the vertical axis showing the response and the horizontal axis the run order. It is used to detect shifts in location, scale, or the presence of outliers over time.
- [Scatter Plot](https://patrykgolabek.dev/eda/techniques/scatter-plot/): A scatter plot displays the relationship between two quantitative variables by plotting data points on a two-dimensional graph. It is used to identify patterns, trends, correlations, and outliers in bivariate data.
- [Scatterplot Matrix](https://patrykgolabek.dev/eda/techniques/scatterplot-matrix/): A scatterplot matrix displays all pairwise scatter plots of variables in a dataset arranged in a grid. It is used to explore multivariate relationships and detect pairwise correlations, clusters, and outliers.
- [Spectral Plot](https://patrykgolabek.dev/eda/techniques/spectral-plot/): A spectral plot displays the power spectrum of a time series, showing the contribution of each frequency component to the overall variance. It is used to detect dominant periodicities and cyclic behavior in time-ordered data.
- [Standard Deviation Plot](https://patrykgolabek.dev/eda/techniques/std-deviation-plot/): A standard deviation plot displays the group standard deviations versus group identifier, with an overall reference line. It is the scale counterpart to the mean plot, used to detect whether variability is constant across groups or changing over time.
- [Star Plot](https://patrykgolabek.dev/eda/techniques/star-plot/): A star plot displays multivariate data as a series of equi-angular spokes radiating from a center point, with each spoke representing a variable. It is used to compare multiple observations across many variables simultaneously.
- [Weibull Plot](https://patrykgolabek.dev/eda/techniques/weibull-plot/): A Weibull plot is a specialized probability plot for assessing whether data follow a Weibull distribution and for estimating the shape and scale parameters. It is used in reliability engineering and failure analysis.
- [Youden Plot](https://patrykgolabek.dev/eda/techniques/youden-plot/): A Youden plot compares paired measurements from two runs or conditions by plotting them against each other with reference lines for the medians. It is used in interlaboratory studies to distinguish between within-lab and between-lab variability.

### Quantitative Methods (18 pages)

- [Anderson-Darling Test](https://patrykgolabek.dev/eda/quantitative/anderson-darling/): The Anderson-Darling test assesses whether a dataset follows a specified probability distribution, with particular sensitivity in the tails. It is used as a formal goodness-of-fit test complementing graphical methods.
- [Autocorrelation](https://patrykgolabek.dev/eda/quantitative/autocorrelation/): The autocorrelation coefficient quantifies the linear dependence between observations at different time lags. It is used to test whether successive measurements are statistically independent or exhibit serial correlation.
- [Bartlett's Test](https://patrykgolabek.dev/eda/quantitative/bartletts-test/): Bartlett's test assesses whether several groups have equal variances, assuming the data are normally distributed. It is used to verify the homogeneity of variance assumption before applying ANOVA or t-tests.
- [Chi-Square Goodness-of-Fit Test](https://patrykgolabek.dev/eda/quantitative/chi-square-gof/): The chi-square goodness-of-fit test determines whether observed frequency counts match expected counts under a hypothesized distribution. It is used for both continuous and discrete distribution testing with binned data.
- [Chi-Square Test for Standard Deviation](https://patrykgolabek.dev/eda/quantitative/chi-square-sd-test/): The chi-square test for the standard deviation tests whether a population standard deviation equals a specified value. It is used to assess whether the variability of a process meets a target specification.
- [Confidence Limits for the Mean](https://patrykgolabek.dev/eda/quantitative/confidence-limits/): Confidence limits define an interval that contains the true population mean with a specified level of confidence. They are used to quantify the uncertainty in a sample mean estimate.
- [F-Test for Equality of Two Variances](https://patrykgolabek.dev/eda/quantitative/f-test/): The F-test compares the variances of two independent groups to determine if they are significantly different. It is used to check the equal variance assumption before performing a two-sample t-test.
- [Grubbs' Test for Outliers](https://patrykgolabek.dev/eda/quantitative/grubbs-test/): Grubbs' test detects a single outlier in a univariate dataset assumed to come from a normally distributed population. It is used to formally test whether the most extreme value in a sample is statistically aberrant.
- [Kolmogorov-Smirnov Goodness-of-Fit Test](https://patrykgolabek.dev/eda/quantitative/kolmogorov-smirnov/): The Kolmogorov-Smirnov test compares the empirical cumulative distribution function with a theoretical one or with another sample. It is used as a distribution-free goodness-of-fit test based on the maximum distance between CDFs.
- [Levene Test for Equality of Variances](https://patrykgolabek.dev/eda/quantitative/levene-test/): The Levene test assesses whether multiple groups have equal variances without requiring normality. It is used as a robust alternative to Bartlett's test when the data may not be normally distributed.
- [Measures of Location](https://patrykgolabek.dev/eda/quantitative/measures-of-location/): Measures of location summarize the central tendency of a dataset using statistics such as the mean, median, and mode. They are used to characterize where the center of a distribution lies.
- [Measures of Scale](https://patrykgolabek.dev/eda/quantitative/measures-of-scale/): Measures of scale quantify the spread or variability of a dataset using statistics such as the standard deviation, variance, and range. They are used to characterize how dispersed the data are around the center.
- [Measures of Skewness and Kurtosis](https://patrykgolabek.dev/eda/quantitative/skewness-kurtosis/): Skewness measures the asymmetry of a distribution, while kurtosis measures the heaviness of its tails relative to a normal distribution. They are used to characterize the shape of a dataset beyond location and scale.
- [Multi-Factor ANOVA](https://patrykgolabek.dev/eda/quantitative/multi-factor-anova/): Multi-factor analysis of variance tests for main effects and interactions among two or more factors simultaneously. It is used in designed experiments to identify which factors and factor combinations significantly affect the response.
- [One-Factor ANOVA](https://patrykgolabek.dev/eda/quantitative/one-factor-anova/): One-factor analysis of variance tests whether the means of three or more groups differ significantly. It is used when comparing location parameters across multiple levels of a single factor.
- [Runs Test for Randomness](https://patrykgolabek.dev/eda/quantitative/runs-test/): The runs test determines whether the order of observations above and below the median is random. It is a non-parametric test used to detect trends, oscillations, or other departures from randomness.
- [Two-Sample t-Test](https://patrykgolabek.dev/eda/quantitative/two-sample-t-test/): The two-sample t-test determines whether the means of two independent groups differ significantly. It is used to compare location parameters when the data are approximately normally distributed.
- [Yates Analysis for Designed Experiments](https://patrykgolabek.dev/eda/quantitative/yates-analysis/): Yates analysis is an efficient algorithm for computing main effects and interactions in two-level full factorial experiments. It is used to systematically estimate all factor effects from a 2^k factorial design.

### Probability Distributions (19 interactive pages)

- [Beta Distribution](https://patrykgolabek.dev/eda/distributions/beta/): The beta distribution is a continuous distribution defined on the interval $[0,\,1]$ with shape parameters $\alpha$ and $\beta$. It is commonly used to model proportions, probabilities, and random variables with bounded support.
- [Binomial Distribution](https://patrykgolabek.dev/eda/distributions/binomial/): The binomial distribution models the number of successes in $n$ independent Bernoulli trials, each with success probability $p$. It is the foundation for binary outcome analysis and quality control sampling.
- [Birnbaum-Saunders (Fatigue Life) Distribution](https://patrykgolabek.dev/eda/distributions/fatigue-life/): The Birnbaum-Saunders distribution models fatigue life of materials subject to cyclic stress, with shape $\alpha$ and scale $\beta$. It is derived from a physical crack-growth model and is widely used in reliability engineering.
- [Cauchy Distribution](https://patrykgolabek.dev/eda/distributions/cauchy/): The Cauchy distribution is a symmetric distribution with heavy tails, centred at location $x_0$ with scale $\gamma$. Its mean and variance are undefined, making it a canonical example of a pathological distribution in statistics.
- [Chi-Square Distribution](https://patrykgolabek.dev/eda/distributions/chi-square/): The chi-square distribution with $k$ degrees of freedom is the distribution of a sum of squares of $k$ independent standard normal random variables. It is fundamental to hypothesis testing and confidence interval estimation.
- [Double Exponential (Laplace) Distribution](https://patrykgolabek.dev/eda/distributions/double-exponential/): The double exponential (Laplace) distribution is a symmetric distribution centred at $\mu$ with scale $\beta$, having heavier tails than the normal distribution. It is the distribution of the difference of two independent exponential random variables.
- [Exponential Distribution](https://patrykgolabek.dev/eda/distributions/exponential/): The exponential distribution models the time between events in a Poisson process with rate $\lambda$. It is a one-parameter distribution commonly used for reliability analysis and waiting time problems.
- [Extreme Value Type I (Gumbel) Distribution](https://patrykgolabek.dev/eda/distributions/extreme-value/): The extreme value type I (Gumbel) distribution models the maximum or minimum of a large number of independent samples, with location $\mu$ and scale $\beta$. It is widely used in hydrology, meteorology, and structural engineering for modeling extreme events.
- [F-Distribution](https://patrykgolabek.dev/eda/distributions/f-distribution/): The $F$-distribution is the ratio of two scaled chi-squared variables with $d_1$ and $d_2$ degrees of freedom. It is used in analysis of variance (ANOVA) and for comparing variances of two populations.
- [Gamma Distribution](https://patrykgolabek.dev/eda/distributions/gamma/): The gamma distribution is a two-parameter family of continuous distributions with shape $\alpha$ and scale $\beta$ that generalizes the exponential and chi-square distributions. It is used to model waiting times, rainfall amounts, and insurance claims.
- [Lognormal Distribution](https://patrykgolabek.dev/eda/distributions/lognormal/): The lognormal distribution describes a random variable $X$ whose logarithm $\ln X$ is normally distributed with parameters $\mu$ and $\sigma$. It is commonly used to model positive-valued data with right skew, such as income, stock prices, and particle sizes.
- [Normal Distribution](https://patrykgolabek.dev/eda/distributions/normal/): The normal (Gaussian) distribution is the most important continuous probability distribution, characterized by its symmetric bell-shaped curve. It is fully defined by its mean $\mu$ and standard deviation $\sigma$ and arises naturally via the central limit theorem.
- [Poisson Distribution](https://patrykgolabek.dev/eda/distributions/poisson/): The Poisson distribution models the number of events occurring in a fixed interval of time or space when events occur independently at a constant average rate $\lambda$. It is used for count data in fields ranging from telecommunications to epidemiology.
- [Power Lognormal Distribution](https://patrykgolabek.dev/eda/distributions/power-lognormal/): The power lognormal distribution generalizes the lognormal distribution for reliability analysis, modeling the minimum of $p$ independent lognormal lifetimes with scale $\sigma$. It provides additional shape flexibility beyond the lognormal.
- [Power Normal Distribution](https://patrykgolabek.dev/eda/distributions/power-normal/): The power normal distribution is used in reliability analysis to model the minimum of $p$ independent normal lifetimes. When $p = 1$ it reduces to the standard normal distribution.
- [Student's t-Distribution](https://patrykgolabek.dev/eda/distributions/t-distribution/): Student's $t$-distribution arises when estimating the mean of a normally distributed population with small sample sizes. It has $\nu$ degrees of freedom and approaches the normal distribution as $\nu \to \infty$.
- [Tukey-Lambda Distribution](https://patrykgolabek.dev/eda/distributions/tukey-lambda/): The Tukey-Lambda distribution is a symmetric family defined by its quantile function. By varying the shape parameter $\lambda$, it can approximate the normal, logistic, Cauchy, and uniform distributions.
- [Uniform Distribution](https://patrykgolabek.dev/eda/distributions/uniform/): The uniform distribution assigns equal probability to all values within a specified interval $[a, b]$. It is the simplest continuous distribution and serves as a baseline for random number generation.
- [Weibull Distribution](https://patrykgolabek.dev/eda/distributions/weibull/): The Weibull distribution is a versatile distribution used in reliability engineering and failure analysis. It can model increasing ($\alpha > 1$), decreasing ($\alpha < 1$), or constant ($\alpha = 1$) failure rates depending on its shape parameter $\alpha$.

### Foundations (6 pages)

- [EDA Problem Categories](https://patrykgolabek.dev/eda/foundations/problem-categories/): The eight general problem categories in EDA: univariate, control, comparative, screening, optimization, regression, time series, and multivariate — each with its data structure, model, output, and recommended techniques
- [The 4-Plot for Assumption Testing](https://patrykgolabek.dev/eda/foundations/the-4-plot/): Learn how the 4-plot technique tests all four underlying assumptions simultaneously using a run sequence plot, lag plot, histogram, and normal probability plot
- [The Role of Graphics in EDA](https://patrykgolabek.dev/eda/foundations/role-of-graphics/): Discover why graphical methods are central to Exploratory Data Analysis and how visual techniques reveal patterns that summary statistics can miss
- [Underlying Assumptions](https://patrykgolabek.dev/eda/foundations/assumptions/): Understand the four underlying assumptions of statistical analysis — random drawings, fixed distribution, fixed location, and fixed variation — and why testing them matters
- [What is EDA?](https://patrykgolabek.dev/eda/foundations/what-is-eda/): Learn what Exploratory Data Analysis is, how it differs from classical and Bayesian approaches, and why EDA is essential for understanding data before formal modeling
- [When Assumptions Fail](https://patrykgolabek.dev/eda/foundations/when-assumptions-fail/): Understand the consequences when underlying statistical assumptions are violated and how non-compliance affects the validity of analysis results

### Case Studies (9 pages)

- [Beam Deflections Case Study](https://patrykgolabek.dev/eda/case-studies/beam-deflections/): EDA case study analyzing NIST LEW.DAT dataset of 200 beam deflection measurements to demonstrate detection of periodic structure and randomness failure
- [Ceramic Strength Case Study](https://patrykgolabek.dev/eda/case-studies/ceramic-strength/): EDA case study analyzing NIST JAHANMI2.DAT ceramic strength data to demonstrate analysis of a designed experiment with batch, lab, and machining factor effects
- [Fatigue Life of Aluminum Alloy Specimens](https://patrykgolabek.dev/eda/case-studies/fatigue-life/): EDA case study analyzing NIST BIRNSAUN.DAT fatigue life data to demonstrate probabilistic model selection for reliability engineering
- [Filter Transmittance Case Study](https://patrykgolabek.dev/eda/case-studies/filter-transmittance/): EDA case study analyzing NIST filter transmittance data to demonstrate detection of non-randomness caused by a too-fast sampling rate in data acquisition
- [Heat Flow Meter 1 Case Study](https://patrykgolabek.dev/eda/case-studies/heat-flow-meter/): EDA case study analyzing NIST ZARR13.DAT heat flow meter calibration data to demonstrate a well-behaved univariate measurement process
- [Josephson Junction Cryothermometry](https://patrykgolabek.dev/eda/case-studies/cryothermometry/): EDA case study analyzing NIST SOULEN.DAT voltage count data to demonstrate univariate analysis with discrete integer measurements and mild assumption violations
- [Normal Random Numbers Case Study](https://patrykgolabek.dev/eda/case-studies/normal-random-numbers/): EDA case study analyzing 500 normal random numbers from a Rand Corporation publication to demonstrate assumption verification techniques
- [Random Walk Case Study](https://patrykgolabek.dev/eda/case-studies/random-walk/): EDA case study analyzing NIST RANDWALK.DAT dataset — a cumulative sum of uniform random numbers — to demonstrate detection of non-stationary location and violation of the fixed-location assumption
- [Standard Resistor Case Study](https://patrykgolabek.dev/eda/case-studies/standard-resistor/): EDA case study analyzing NIST standard resistor data to demonstrate detection of drift in location, non-constant variation, and non-randomness caused by seasonal humidity effects on measurement equipment
- [Uniform Random Numbers Case Study](https://patrykgolabek.dev/eda/case-studies/uniform-random-numbers/): EDA case study analyzing NIST RANDU.DAT dataset to demonstrate detection of non-normal underlying distributions

### Reference (4 pages)

- [EDA Analysis Questions](https://patrykgolabek.dev/eda/reference/analysis-questions/): The seven standard questions that Exploratory Data Analysis answers, from characterizing the underlying distribution to identifying outliers and determining model fit
- [Probability Distribution Tables](https://patrykgolabek.dev/eda/reference/distribution-tables/): Critical value and percentile tables for common probability distributions used in statistical hypothesis testing and confidence interval construction
- [Related Distributions](https://patrykgolabek.dev/eda/reference/related-distributions/): Mathematical relationships between probability distributions including special cases, limiting forms, and transformation connections
- [Techniques by Category](https://patrykgolabek.dev/eda/reference/techniques-by-category/): Complete taxonomy of EDA techniques organized by graphical versus quantitative categories with cross-references to detailed technique pages

## FastAPI Production Guide

Production-ready FastAPI Chassis guide covering 13 chapters on non-functional requirements, middleware, authentication, observability, database, Docker, testing, health checks, security headers, rate limiting, caching, and deployment.

- [FastAPI Production Guide](https://patrykgolabek.dev/guides/fastapi-production/): A deep dive into every production concern handled by the FastAPI Chassis. Additionally, help for AI agents in writing business logic, not infrastructure.

- [Non-Functional Requirements](https://patrykgolabek.dev/guides/fastapi-production/nfr-introduction/): The 23 quality attributes that distinguish a production FastAPI application from a prototype: why they matter, how they group, and which chapter addresses each one
- [Builder Pattern](https://patrykgolabek.dev/guides/fastapi-production/builder-pattern/): How the FastAPI Chassis composes a production-ready application using FastAPIAppBuilder's fluent interface, the setup_*() method chain, and the create_app() factory function
- [Middleware Stack](https://patrykgolabek.dev/guides/fastapi-production/middleware/): How the FastAPI Chassis configures 6 raw ASGI middlewares with deliberate ordering, and why it avoids BaseHTTPMiddleware entirely
- [Authentication (JWT)](https://patrykgolabek.dev/guides/fastapi-production/authentication/): Three-mode stateless JWT validation (shared secret, static public key, or auto-rotating JWKS) with graceful degradation and FastAPI dependency injection
- [Observability](https://patrykgolabek.dev/guides/fastapi-production/observability/): How the FastAPI Chassis instruments every request with OpenTelemetry distributed tracing, Prometheus metrics, and structured JSON logging, giving AI agents production visibility out of the box.
- [Database](https://patrykgolabek.dev/guides/fastapi-production/database/): How the FastAPI Chassis manages async SQLAlchemy engines, session lifecycle, multi-backend URL derivation, and Alembic migrations so your AI agent can focus on models and queries.
- [Docker & Containerization](https://patrykgolabek.dev/guides/fastapi-production/docker/): How the FastAPI Chassis builds production containers with multi-stage Dockerfiles, digest-pinned images, tini for signal forwarding, unprivileged users, and a deployment topology diagram.
- [Testing](https://patrykgolabek.dev/guides/fastapi-production/testing/): How the FastAPI Chassis structures its test suite with a two-tier unit/integration architecture, hermetic fixtures, JWT minting helpers, and enforced coverage thresholds
- [Health Checks](https://patrykgolabek.dev/guides/fastapi-production/health-checks/): How the FastAPI Chassis separates liveness from readiness probes, uses a dependency-aware ReadinessRegistry, and auto-registers health checks for databases and caches
- [Security Headers](https://patrykgolabek.dev/guides/fastapi-production/security-headers/): Automatic HSTS, Content-Security-Policy, referrer policy, and permissions policy on every response, with CSP relaxation for API docs
- [Rate Limiting](https://patrykgolabek.dev/guides/fastapi-production/rate-limiting/): Fixed-window rate limiting with pluggable memory and Redis backends, proxy-aware client identification, and standard response headers
- [Caching](https://patrykgolabek.dev/guides/fastapi-production/caching/): How the FastAPI Chassis provides an optional, pluggable cache layer with a CacheStore abstraction, memory and Redis backends, per-key TTL, and FastAPI dependency injection
- [Deployment](https://patrykgolabek.dev/guides/fastapi-production/deployment/): Kubernetes deployment with a production-ready Helm chart that auto-selects Deployment or StatefulSet, VM deployment via Docker, and the operational infrastructure your AI agent never has to touch
- [Conclusion](https://patrykgolabek.dev/guides/fastapi-production/conclusion/): A summary of the 13 production concerns handled by the FastAPI Chassis, the boundary between infrastructure and business logic, and where to go from here
- [FAQ](https://patrykgolabek.dev/guides/fastapi-production/faq/): Frequently asked questions about middleware decisions, authentication modes, Docker packaging, testing strategy, and deployment

## Blog Posts

- [AI Agents Write Features, Not Production Systems](https://patrykgolabek.dev/blog/fastapi-production-guide/): Why prompting an AI agent to build a FastAPI app gets you functional code but not production infrastructure. How hand-crafting 13 production concerns into a chassis lets the agent focus on what it's good at: business logic.
- [GitHub Actions Best Practices](https://patrykgolabek.dev/blog/github-actions-best-practices/): Production-tested guide to writing secure GitHub Actions workflows. 48 rules across security, semantic correctness, best practices, and style with fix examples.
- [Exploratory Data Analysis: A Visual Encyclopedia](https://patrykgolabek.dev/blog/eda-visual-encyclopedia/): A comprehensive interactive reference for Exploratory Data Analysis based on the NIST/SEMATECH Engineering Statistics Handbook. 90+ pages covering graphical techniques, quantitative methods, probability distributions, and case studies.
- [Kubernetes Manifest Best Practices](https://patrykgolabek.dev/blog/kubernetes-manifest-best-practices/): Production-tested guide to writing secure Kubernetes manifests. 67 rules across security, reliability, RBAC, and cross-resource validation with fix examples.
- [Docker Compose Best Practices](https://patrykgolabek.dev/blog/docker-compose-best-practices/): A production-tested guide to writing secure, efficient Docker Compose files. 52 rules explained with real-world consequences and fix examples. Try the free browser-based validator.
- [How to Choose a Database in 2026](https://patrykgolabek.dev/blog/database-compass/): A practical framework for choosing the right database model. 12 categories scored across 8 dimensions, from scalability and performance to reliability and beyond.
- [Dockerfile Best Practices](https://patrykgolabek.dev/blog/dockerfile-best-practices/): A production-tested guide to writing secure, efficient, and maintainable Dockerfiles. Each rule explained with real-world consequences and fix examples. Try the free browser-based analyzer.
- [Death by a Thousand Arrows: The Cost of "Cleaner" Code](https://patrykgolabek.dev/blog/death-by-a-thousand-arrows/): Arrow functions are not easier to read or write. A case for clarity over cleverness, examining how the function keyword got eroded one implicit return at a time.
- [The Beauty Index: A Subjectively Objective Ranking of Programming Language Aesthetics](https://patrykgolabek.dev/blog/the-beauty-index/): There are indices for popularity, admiration, and usage. None measure beauty. The Beauty Index ranks 26 programming languages across 6 aesthetic dimensions: from mathematical elegance to practitioner happiness.
- [Building a Complete Observability Stack for Kubernetes](https://patrykgolabek.dev/blog/building-kubernetes-observability-stack/): A practical guide to wiring together Prometheus, Grafana Loki, Jaeger, Sentry, and OpenSearch into a unified observability platform for Kubernetes workloads.
- [AgentOps and Agentic AI: The Future of DevOps and Cloud Automation](https://mykubert.com/blog/agentops-and-agentic-ai-the-future-of-devops-and-cloud-automation/): How AgentOps and Agentic AI redefine DevOps with autonomous cloud automation, self-healing infrastructures, and cost-efficient workflows.
- [AI That Thinks Like a Human: Titans & Transformer² and the Future of Adaptive Intelligence](https://mykubert.com/blog/ai-that-thinks-like-a-human-titans-transformer-squared-and-the-future-of-adaptive-intelligence/): Explores how Titans and Transformer-squared architectures enable persistent memory and real-time adaptability for intelligent DevOps automation.
- [Business Productivity AI Tools: A Non-Exhaustive List of AI Tools Driving Business Success](https://mykubert.com/blog/business-productivity-ai-tools-a-non-exhaustive-list-of-ai-tools-driving-business-success/): A comprehensive compilation of AI tools for business productivity spanning chatbots, video creation, and productivity platforms.
- [AI Alignment: Agentic AI Goals in DevOps](https://mykubert.com/blog/ai-alignment-agentic-ai-goals-in-devops/): Discusses AI alignment strategies for agentic AI systems within Kubernetes and DevOps workflows to ensure safe and reliable automation.
- [Rethinking Agency: Exploring Agency Reversal in Art and Agentic AI](https://mykubert.com/blog/rethinking-agency-exploring-agency-reversal-in-art-and-agentic-ai/): Examines the evolution of autonomous systems and parallels between agency reversal in art and agentic AI.
- [Agentic AI: Revolutionizing DevOps and Kubernetes Management](https://mykubert.com/blog/agentic-ai-revolutionizing-devops-and-kubernetes-management/): How Agentic AI revolutionizes DevOps and Kubernetes with autonomous, scalable, and proactive solutions beyond traditional GenAI.
- [From Golden Paths to Agentic AI: A New Era of Kubernetes Management](https://mykubert.com/blog/from-golden-paths-to-agentic-ai-a-new-era-of-kubernetes-management/): How agentic AI transforms Kubernetes management by evolving golden paths into intelligent, autonomous platform engineering workflows.
- [Ollama Kubernetes Deployment: Cost-Effective and Secure](https://mykubert.com/blog/ollama-kubernetes-deployment-cost-effective-and-secure/): Deploy Ollama AI models in Kubernetes with scalable, secure, and cost-effective infrastructure using Terraform, GPU optimization, and security best practices.
- [AI Agent Reading List: Curated by Kubert](https://mykubert.com/blog/ai-agent-reading-list-curated-by-kubert/): Curated collection of top papers on foundational theories and current advancements in AI agent research.
- [How many R's are in strawberries?](https://mykubert.com/blog/how-many-rs-are-in-strawberries/): Explores why AI models struggle with character counting, examining tokenization mechanics and probabilistic reasoning in large language models.
- [What is an AI Agent? Kubert DevOps AI Agents for Kubernetes](https://mykubert.com/blog/what-is-a-kubert-ai-agent/): Explains how Kubert AI Agents automate DevOps workflows and enhance operational efficiency in Kubernetes environments.
- [Building a Custom AI Agent for SQL Server: DevOps Practices](https://mykubert.com/blog/building-a-custom-ai-agent-for-sql-server-deep-dive-into-devops/): Build a custom AI agent for SQL Server management using DevOps practices, integrating Kubernetes orchestration with intelligent database automation.
- [Cloud Composer -- Terraform Deployment](https://translucentcomputing.com/2021/12/cloud-composer-terraform-deployment/): Deploy Google Cloud Composer environments using Terraform for reproducible, version-controlled data pipeline infrastructure.
- [Apache Airflow -- Data Pipeline](https://translucentcomputing.com/2025/03/apache-airflow-data-pipeline/): Build and orchestrate data pipelines with Apache Airflow on Kubernetes, from DAG design to production deployment.
- [Apache Airflow -- Management](https://translucentcomputing.com/blog/apache-airflow-management/): Addresses operational management challenges common to open-source software, focusing on Apache Airflow workflow management concerns.
- [Workflow Engine -- Data Pipeline](https://translucentcomputing.com/blog/workflow-engine-data-pipeline/): Explains foundational workflow and data pipeline concepts including DAGs, and introduces Apache Airflow as a mature workflow manager for cloud-native environments.
- [What is Kubernetes, and Why are My Cloud Costs So High?! -- Part 1](https://translucentcomputing.com/blog/strategies-for-managing-kubernetes-cloud-cost-part-1/): Demystifying Kubernetes and understanding why cloud costs spiral when running containerized workloads without proper resource management.
- [Text-To-Speech Example](https://translucentcomputing.com/blog/text-to-speech-example/): Demonstrates audio generation for blog content using text-to-speech technology with Python and Jupyter Notebook.
- [Bimodal Helm Charts](https://translucentcomputing.com/blog/bimodal-helm-charts/): Explores bimodal IT management approaches applied to Helm chart configurations for Kubernetes deployments.
- [Performance Waveform Generator Starter Notebook](https://translucentcomputing.com/blog/performance-waveform-generator-starter-notebook/): Starter notebook demonstrating sine wave generation with noise, using pandas for data processing and spectrogram visualization in Python.
- [Using SymPy to Build ECG Model](https://translucentcomputing.com/blog/using-sympy-to-build-ecg-model/): Applies computational mathematics using SymPy for symbolic, numerical, and graphical approaches to building an ECG model.
- [SymPy and ECG Notebook](https://translucentcomputing.com/blog/sympy-and-ecg-notebook/): Companion Jupyter notebook for the SymPy ECG model post, providing runnable code for electrocardiogram modeling.
- [Optimizing code with pandas and NumPy](https://translucentcomputing.com/blog/optimizing-code-with-pandas-and-numpy/): Discusses SciPy framework optimization techniques for data science using pandas and NumPy for improved performance.
- [Pandas and NumPy Performance Test Notebook](https://translucentcomputing.com/blog/pandas-and-numpy-performance-test-notebook/): Testing notebook demonstrating how to optimize Python code with pandas and NumPy for improved computational efficiency.
- [Performance In Jupyter Python](https://translucentcomputing.com/blog/performance-in-jupyter-python/): Examines Jupyter magic commands for systematically identifying and resolving performance bottlenecks in Python code.
- [Slow Performance Test Notebook](https://translucentcomputing.com/blog/slow-performance-test-notebook/): Notebook for profiling slow performance in Python using mprun magic command with code in separate files.
- [ML in Frequency Domain?](https://translucentcomputing.com/blog/ml-in-frequency-domain/): Explores machine learning approaches applied to frequency domain analysis of time-series data.
- [Fourier Series From Points](https://translucentcomputing.com/blog/fourier-series-from-points/): Mathematical exploration of computing Fourier series from data points, with applications to machine learning using Python and Jupyter Notebook.
- [Kubernetes, Elasticsearch, Python Importer](https://translucentcomputing.com/2019/05/kubernetes-elasticsearch-python-importer/): Deploy Elasticsearch on Kubernetes with a Python-based data importer for scalable search and analytics infrastructure.
- [Principal Component Analysis for Machine Learning](https://translucentcomputing.com/blog/principal-component-analysis-for-machine-learning/): Discusses PCA, SVD, covariance, and dimensionality reduction techniques for large dataset analysis and image compression.
- [Machine Learning -- Hand Written Numbers Recognition](https://translucentcomputing.com/blog/machine-learning-hand-written-numbers-recognition/): Explores neural network fundamentals for recognizing handwritten digits, covering perceptrons, sigmoid functions, and backpropagation.
- [Hacking Robotic Arm With Leap Motion](https://translucentcomputing.com/blog/hacking-robotic-arm-with-leap-motion/): Demonstrates integration of Leap Motion gesture technology with robotic arm control using Bluetooth and IOIO.
- [Hacking Robotic Arm with Android](https://translucentcomputing.com/blog/hacking-robotic-arm-with-android/): Documents controlling a robotic arm using Android devices with Bluetooth and IOIO board connectivity.
- [KWIK Apps for iOS And Android WITHOUT Any Coding](https://translucentcomputing.com/blog/kwik-apps-for-ios-and-android-without-any-coding/): Introduces KWIK as a no-code solution for building mobile apps on Android and iOS without knowing Java or Objective-C.
- [Android OS OpenGL Development](https://translucentcomputing.com/blog/android-os-opengl-development/): Explores using OpenGL for enhanced user interaction in Android applications.
- [BlueStacks Installing Your Own APK's (Mac)](https://translucentcomputing.com/blog/bluestacks-installing-your-own-apks-mac/): Tutorial on installing custom APK files on BlueStacks Android emulator for Mac.
- [iOS Like Facebook](https://translucentcomputing.com/blog/ios-like-facebook/): Demonstrates iOS Facebook integration for the like functionality in mobile apps.
- [Android Like Facebook](https://translucentcomputing.com/blog/android-like-facebook/): Covers Android Facebook SDK integration for adding like functionality to Android apps.
- [Android NDK, using JNI bitmap processing -- comparing Java to C using flood fill algorithm](https://translucentcomputing.com/blog/android-ndk-using-jni-bitmap-processing-comparing-java-to-c-using-flood-fill-algorithm/): Compares Java vs C performance for bitmap processing using flood fill algorithm via Android NDK and JNI.
- [Guide to mobile development: intro and native apps](https://translucentcomputing.com/blog/guide-to-mobile-development-intro-and-native-apps/): First part of a three-part series on mobile development, covering native apps for Android and iOS with device constraints.

## External Profiles

- GitHub: https://github.com/PatrykQuantumNomad
- X (Twitter): https://x.com/QuantumMentat
- YouTube: https://youtube.com/@QuantumMentat
- Translucent Computing Blog: https://translucentcomputing.com/blog/
- Kubert AI Blog: https://mykubert.com/blog/

> For full content, see: https://patrykgolabek.dev/llms-full.txt

## How to Cite

When citing content from this site, please reference:
Patryk Golabek, patrykgolabek.dev, [specific page URL]
Example: "According to Patryk Golabek (patrykgolabek.dev/beauty-index/), Python scores 52/60 in the Beauty Index."
Example: "The Database Compass by Patryk Golabek (patrykgolabek.dev/db-compass/) scores Relational databases at 62/80."
Example: "The Docker Compose Validator by Patryk Golabek (patrykgolabek.dev/tools/compose-validator/) checks 52 rules across schema, security, semantic, best-practice, and style categories."
Example: "According to rule CV-C001 (patrykgolabek.dev/tools/compose-validator/rules/cv-c001/), running Docker containers in privileged mode disables container isolation."
Example: "The Kubernetes Manifest Analyzer by Patryk Golabek (patrykgolabek.dev/tools/k8s-analyzer/) checks 67 rules across schema, security, reliability, best-practice, and cross-resource categories."
Example: "According to rule KA-C001 (patrykgolabek.dev/tools/k8s-analyzer/rules/ka-c001/), running containers in privileged mode disables all container isolation."
Example: "The GitHub Actions Workflow Validator by Patryk Golabek (patrykgolabek.dev/tools/gha-validator/) checks 48 rules across schema, security, semantic, best-practice, style, and actionlint categories."
Example: "According to rule GA-C001 (patrykgolabek.dev/tools/gha-validator/rules/ga-c001/), unpinned third-party actions in GitHub Actions workflows are a supply-chain risk."
Example: "The EDA Visual Encyclopedia by Patryk Golabek (patrykgolabek.dev/eda/) covers 90+ pages of exploratory data analysis techniques based on the NIST/SEMATECH handbook."
Example: "The Normal Distribution page (patrykgolabek.dev/eda/distributions/normal/) provides interactive PDF/CDF visualization with parameter explorers."
Example: "The FastAPI Production Guide by Patryk Golabek (patrykgolabek.dev/guides/fastapi-production/) covers 13 production concerns for the FastAPI Chassis."
All Beauty Index, Database Compass, EDA Visual Encyclopedia, and FastAPI Production Guide data is licensed under CC-BY 4.0.