179 docs tagged with "beginners"

git stash, git cherry-pick, git bisect for bug hunting, git blame, and git shortlog.

Conditional types, mapped types, template literal types, the infer keyword, and recursive types with real-world use cases.

Organising CSS for maintainability -- BEM naming, file structure, CSS resets vs normalisers, utility classes, component-scoped styles, and preprocessor overview.

Learn JavaScript arrays -- creating, accessing, mutating, iterating with map/filter/reduce, destructuring, and the spread operator.

The Users & Permissions plugin, JWT authentication, user registration, roles, API tokens, and controlling access to your Strapi API.

CSS background images, gradients, background shorthand, border-radius for rounded corners, box-shadow, text-shadow, and multiple backgrounds.

TypeScript's primitive types, type inference, type annotations, arrays, tuples, and the any, unknown, never, and void types.

git add, git commit, git status, git log, git diff, and writing good commit messages with Conventional Commits.

What branches are, creating and switching between them, deleting branches, HEAD and detached HEAD state, and when to branch.

A super-beginner, start-to-finish tutorial for building a simple blog page using only HTML, CSS, and vanilla JavaScript -- with an optional section on adding Vite later.

Build a REST API with Java's built-in HttpServer -- HTTP basics, request handling, JSON serialization, routing, and exposing the task manager over HTTP.

Build a complete Notes application with registration, login, CRUD operations, routing, templates, and database integration using concepts from the entire guide.

Using Core Components, the responsive grid, navigation, header and footer, building a homepage and article page, and page properties.

TypeScript class syntax, access modifiers, readonly, constructors, inheritance, abstract classes, and implementing interfaces.

Learn Java OOP basics -- classes, objects, constructors, access modifiers, encapsulation, toString, equals/hashCode, static members, and records.

CSS and JS management in AEM -- clientlib structure, categories, dependencies, embedding, proxy serving, and the ui.frontend module.

Learn Java collections -- ArrayList, HashMap, HashSet, iterating, generics, immutable collections, and choosing the right collection.

Vec for dynamic arrays, String for owned UTF-8 text, and HashMap for key-value storage -- creating, accessing, iterating, and common patterns.

CSS colour formats (named, hex, rgb, hsl), opacity, font properties, text styling, web-safe fonts, and loading Google Fonts.

Touch UI dialogs with Granite/Coral -- field types, tabs, multifields, image upload, validation, and conditional visibility.

Dependency management with Composer, installing packages, PSR-4 autoloading, semantic versioning, and security best practices.

Spawning threads, move closures for threads, message passing with channels (mpsc), shared state with Arc and Mutex, the Send and Sync traits, and an introduction to async/await with tokio.

Environment-based configuration, PostgreSQL setup, deploying Strapi to a VPS with PM2, nginx reverse proxy, HTTPS, and security hardening.

Content Fragment Models, creating and managing fragments, the AEM GraphQL API, persisted queries, and headless content delivery.

Defining collection types, single types, field types, components, and dynamic zones in Strapi 5.

Learn Java control flow -- if/else, switch expressions, for/while/do-while loops, enhanced for-each, break, continue, and common patterns.

Learn how to make decisions and repeat actions in JavaScript with if/else, switch, ternary operators, and loops.

Making decisions with if/else/elseif, switch and match, looping with while, do-while, for and foreach, and combining control structures in real programs.

if/else as expressions, loop, while, for with ranges and iterators, break and continue with labels, early introduction to match, and returning values from blocks.

CSS custom properties (variables) -- defining, using, scoping, fallback values, theming, building a dark mode toggle, and dynamic updates with JavaScript.

CSS Grid layout -- defining rows and columns, the fr unit, grid areas, gap, auto-fit/auto-fill, minmax(), and implicit vs explicit grids.

Extending Strapi's default CRUD controllers, creating custom actions, delegating business logic to services, and sanitizing output.

Using browser DevTools to debug CSS, understanding margin collapse, overflow issues, centring gotchas, z-index problems, and cross-browser testing.

Building for release, cross-compilation, creating a systemd service, setting up nginx as a reverse proxy, HTTPS with Let's Encrypt, Docker multi-stage builds, and CI/CD with GitHub Actions.

Deploy your Java REST API to a VPS -- installing the JDK, running as a systemd service, configuring nginx as a reverse proxy, and HTTPS with Let's Encrypt.

Deploy your website to a Virtual Private Server -- server setup, SSH, nginx configuration, HTTPS with Let's Encrypt, and basic security hardening.

Git repo structure, Cloud Manager pipelines, environments, Rapid Development Environments, content transfer, and going to production.

Dispatcher architecture, cache rules, filters, rewrites, vanity URLs, cache invalidation, and local Dispatcher SDK testing.

How CSS display modes (block, inline, inline-block) and positioning (static, relative, absolute, fixed, sticky) control element flow and placement.

Containerizing Strapi with Docker, docker-compose for development, and setting up automated deployments with GitHub Actions.

Learn how to define and manage multi-container applications with Docker Compose, covering services, volumes, networks, and a full worked example.

Learn how to build and push Docker images in GitHub Actions, cache layers for faster CI builds, and deploy by pulling and restarting containers.

Learn how Docker networks work, how containers communicate with each other by name, and how port mapping exposes services to the host.

Playwright setup, writing your first test, page navigation, clicks, form fills, selectors, headless execution, traces and screenshots on failure, and CI integration.

Numeric enums, string enums, const enums, literal types, discriminated unions, and exhaustive checks in TypeScript.

Learn how to manage configuration and secrets in Docker using ENV, ARG, .env files, runtime injection, and Docker secrets — without baking sensitive data into images.

Learn Java error handling -- try/catch/finally, checked vs unchecked exceptions, custom exceptions, try-with-resources, and best practices.

Handle errors gracefully in JavaScript -- try/catch/finally, error types, custom errors, async error handling, and common patterns.

panic! vs recoverable errors, Result in depth, the ? operator, unwrap and expect, custom error types, the From trait for error conversion, the thiserror crate, and when to panic vs return a Result.

PHP error levels, configuring error reporting, exceptions with try/catch/finally, custom exception classes, and debugging techniques including Xdebug.

Learn how to handle user interactions in JavaScript -- event listeners, the event object, bubbling, delegation, forms, and keyboard/mouse events.

Learn Java file I/O -- Path, Files, reading and writing text files, directories, BufferedReader/Writer, and simple CSV parsing.

Create, copy, move, delete, and find files and directories with touch, mkdir, cp, mv, rm, ln, and find.

Navigate the Linux filesystem with pwd, ls, cd, and tree, and understand the standard directory hierarchy.

CSS Flexbox layout -- flex containers and items, direction, wrapping, alignment, sizing with flex-grow/shrink/basis, gap, and common patterns.

Learn JavaScript functions -- declarations, expressions, arrow functions, parameters, scope, closures, and callbacks.

Defining and calling functions, parameters and return values, type declarations, variable scope, closures, arrow functions, and built-in PHP functions.

Defining functions, parameters and return types, the difference between expressions and statements, implicit returns, the unit type, nested functions, diverging functions, and documentation comments.

Typed parameters, return types, optional and default parameters, rest params, function overloads, void vs never, and arrow functions in TypeScript.

Write reusable bash functions with local variables, arguments, error handling with set -e and trap, and heredocs.

Generic functions, interfaces, and classes in TypeScript, plus constraints with extends, default type parameters, and keyof and typeof operators.

GitHub Flow, GitFlow, trunk-based development, and the fork workflow for open source — and how to choose the right one.

Learn Gradle with Kotlin DSL -- project structure, dependency management, building fat JARs, and improving the REST API project with Jackson for JSON handling.

Learn how to configure Docker health checks, inspect container health status, manage logs with docker logs, and choose the right log driver for production.

What git hooks are, pre-commit, commit-msg, and pre-push hooks, with practical examples and tools like husky and lefthook.

The HTML Template Language in depth -- expressions, block statements, global objects, the Use API, and best practices.

Learn enough HTML and CSS to build web pages -- document structure, semantic elements, forms, CSS selectors, the box model, flexbox, and responsive design.

Learn how to pull images, run containers with essential flags, manage container lifecycle, and clean up your local environment.

Learn Java inheritance, method overriding, abstract classes, interfaces, polymorphism, sealed classes, and composition vs inheritance.

What makes a test an integration test, testing database interactions, testing HTTP endpoints with Supertest and MockMvc, and Docker-based testing with Testcontainers.

Defining object shapes with interface and type, optional and readonly properties, extending interfaces, intersection types, and structural typing.

What Java is, how the JDK/JRE/JVM relate, installing the JDK, compiling and running your first program, and choosing an IDE.

What JavaScript is, where it runs, how to set up your development environment, and writing your first program.

What Rust is, why it exists, how it compares to other languages, installing the toolchain with rustup, writing your first program, understanding Cargo, setting up your editor, and reading compiler errors.

What TypeScript is, why it exists, how to install it via npm, tsconfig basics, compiling with tsc, and your first typed program.

What CSS is, how it works with HTML, the three ways to add styles, the anatomy of a CSS rule, writing your first stylesheet, and a quick look at browser DevTools.

What AEM is, the technology stack (Sling, JCR, OSGi), AEMaaCS vs on-premise, installing the SDK, generating a project with the Maven archetype, and a project structure walkthrough.

What PHP is, how the web works, installing PHP on every major operating system, writing your first script, and understanding the PHP request lifecycle.

What a headless CMS is, why Strapi, installing Strapi 5, understanding the project structure, and your first look at the admin panel.

Learn what Docker is, how containers differ from virtual machines, and how to install and verify Docker on your system.

What Git is, distributed vs centralised VCS, installing Git, initial configuration, git init, .gitignore, and the three areas of a Git repository.

What Linux is, an overview of common distributions, why developers use it, and how to connect to a remote server via SSH.

Why testing matters, the testing pyramid, cost of bugs, coverage as a metric, and a tooling overview for JavaScript/TypeScript and Java projects.

Closure syntax, capturing variables, Fn/FnMut/FnOnce traits, the Iterator trait, iterator adaptors like map/filter/fold/collect, chaining, lazy evaluation, and the difference between iter, into_iter, and iter_mut.

Reacting to content events with Document Service middleware, configuring webhooks, and integrating with external services.

Why lifetimes exist, lifetime annotations in function signatures and structs, the three lifetime elision rules, the 'static lifetime, and common lifetime patterns and pitfalls.

Using the admin panel to create, edit, and publish content -- drafts, publishing workflow, media library, and bulk operations.

Learn Apache Maven -- project structure, dependency management, building fat JARs, and improving the REST API project with Gson for JSON handling.

Upload providers, S3 and Cloudinary integration, image optimization, responsive formats, upload validation, and media management.

Fast-forward vs three-way merges, resolving conflicts step by step, git mergetool, and aborting a merge.

Learn Java methods -- defining and calling static methods, parameters, return types, overloading, varargs, scope, and recursion.

Mockito setup, @Mock and @InjectMocks, when().thenReturn(), verify(), ArgumentCaptor, mocking exceptions, and spy objects.

jest.fn(), jest.spyOn(), jest.mock() for modules, clearing and resetting mocks, mocking fetch and axios, and testing async code.

Recent CSS additions -- native nesting, the :has() selector, container queries, @layer, logical properties, color-mix(), accent-color, and subgrid.

PHP 8.0 through 8.4 highlights including named arguments, enums, readonly properties, property hooks, and choosing your PHP version.

Organizing code with mod, pub, and use, file-based module structure, re-exports, library vs binary crates, workspaces, Cargo.toml dependencies, crates.io, semantic versioning, and feature flags.

ES modules in TypeScript, import and export patterns, declaration files (.d.ts), DefinitelyTyped, and writing your own type declarations.

Blueprints, Live Copies, rollout configurations, language copies, the translation framework, and i18n dictionaries.

Learn how to use multi-stage builds to produce small, secure production images by separating build-time and runtime dependencies.

Diagnose and work with Linux networking using ip, curl, wget, ss, dig, SSH config, scp, and rsync.

Classes and objects, properties and methods, constructors, visibility modifiers, getters and setters, static members, class constants, and a practical Product and ShoppingCart example.

Learn JavaScript objects -- literals, properties, methods, this, destructuring, spread, Object methods, and JSON.

Inheritance, abstract classes, interfaces, traits, namespaces, autoloading, and building flexible object-oriented systems.

Learn how PHP combines values with operators -- arithmetic, assignment, comparison, logical, and string concatenation. Understand loose vs strict comparison and operator precedence.

Avoid NullPointerException with Java's Optional -- creation, unwrapping, chaining, and best practices for handling missing values.

OSGi bundles, services, the component lifecycle, the Web Console, and configuration management in AEM.

The stack and the heap, ownership rules, move semantics, the Copy and Clone traits, references and borrowing, mutable references, dangling references, String vs &str, and slices.

Install, update, and remove software packages on Debian/Ubuntu with apt, RHEL/Fedora with dnf, and Alpine with apk.

match exhaustiveness, destructuring structs and enums, if let, while let, the matches! macro, match guards, the wildcard pattern, nested patterns, and matching on Option and Result.

Database indexing, query optimization, caching strategies, CDN setup, and monitoring for high-performance Strapi applications.

Understand Linux file permissions, ownership, chmod, chown, umask, and sudo for secure server access control.

An end-to-end exercise covering initialising a repo, feature branches, simulated PR review, squash-merge, and tagging a release.

End-to-end exercise provisioning a fresh Ubuntu VPS, securing it, deploying a Node.js app as a systemd service, and configuring log rotation.

End-to-end exercise — build and test a small TypeScript utility library with Vitest (unit and integration tests), full coverage report, and GitHub Actions CI.

Six hands-on projects -- from a simple component to a production Dispatcher config -- to reinforce everything covered in the guide.

Six hands-on CSS projects from beginner to advanced -- personal profile card, navigation bar, photo gallery, landing page, dashboard layout, and CSS art.

Six hands-on project ideas -- from beginner to advanced -- to reinforce everything you learned in the PHP Beginners Guide.

Eight hands-on project ideas -- from beginner to advanced -- to reinforce everything you learned in the Rust Beginners Guide.

Six hands-on project ideas -- from beginner to advanced -- to reinforce everything you learned in the Strapi 5 Beginners Guide.

Monitor, control, and manage Linux processes and system services using ps, top, kill, systemctl, and journalctl.

Learn how to harden Docker containers for production — non-root users, read-only filesystems, minimal base images, resource limits, restart policies, and a complete end-to-end project.

Build a multi-page vanilla JavaScript website from scratch -- navigation, theme toggle, form validation, dynamic content, and local storage.

Build a complete command-line task manager in Java -- CRUD operations, file-based persistence, input validation, and packaging as a runnable JAR.

Build a complete CLI application with clap for argument parsing, serde for JSON serialization, file-based storage, proper error handling, and a modular project structure.

CSS pseudo-classes for targeting element states (:hover, :focus, :nth-child) and pseudo-elements for creating virtual content (::before, ::after).

React Testing Library setup, render/screen/fireEvent/userEvent, querying by role and text, testing forms, and testing components that fetch async data.

git rebase vs merge, interactive rebase for squashing and editing commits, and the golden rule of rebasing.

Learn how to push and pull images to Docker Hub, GHCR, and private registries, apply tagging conventions, and scan images for vulnerabilities.

Master JavaScript regular expressions -- patterns, character classes, quantifiers, groups, lookaheads, and practical validation examples.

Defining one-to-one, one-to-many, and many-to-many relations between content types to build a blog data model.

git clone, managing remotes, git fetch, git pull, git push, tracking branches, and upstream relationships.

Building layouts that work on every screen size -- the viewport meta tag, media queries, mobile-first development, breakpoints, responsive images, and fluid typography.

Strapi's auto-generated REST API -- endpoints, filtering, sorting, pagination, field selection, population, and testing with curl.

Building a REST API with Actix Web: project setup, routes, handlers, extractors, JSON with serde, application state, middleware, CORS, and connecting to SQLite.

Custom routes for new endpoints, access control policies, request/response middleware, and the Strapi request lifecycle.

How CSS targets HTML elements -- element, class, ID, universal, grouping, descendant, child, sibling, and attribute selectors.

HTTP statelessness, cookies with setcookie(), PHP sessions, flash messages, and building a secure login/logout system.

Write bash scripts with variables, conditionals, loops, and command substitution to automate repetitive server tasks.

Injecting JCR content into Java models -- annotations, adaptables, child resources, OSGi services, exporters, and best practices.

Jest snapshot testing pros and cons, updating snapshots, when to use them, and an introduction to Storybook for visual component testing.

How CSS decides which rule wins -- the cascade algorithm, specificity calculation, inheritance, the !important keyword, and cascade layers.

Functional Java -- lambda expressions, method references, the Stream API, and practical data processing pipelines.

Master PHP strings -- concatenation, heredoc, common functions, and multibyte handling. Then dive into indexed and associative arrays, looping, essential functions, and practical examples.

Defining structs, field init shorthand, tuple structs, unit structs, impl blocks, methods, associated functions, enums, enum variants with data, Option, and Result.

Administer a Linux server — disk usage, cron jobs, log management, and environment variable configuration.

Lightweight vs annotated tags, creating and pushing tags, semantic versioning, deleting tags, and checking out tags.

Editable templates, template types, structure vs initial content, component policies, allowed components, and page structure.

Coverage metrics (line, branch, function), configuring Istanbul and JaCoCo, setting thresholds, what good coverage means, and collecting coverage in CI.

The red-green-refactor cycle, when TDD makes sense, a worked example building a shopping cart in both TypeScript and Java, and common TDD pitfalls.

Write your first Java tests -- JUnit 5 setup, assertions, test structure, parameterized tests, and testing the Task Manager and REST API.

Unit tests with #[test], the cfg(test) module, assert macros, testing panics, integration tests in the tests/ directory, doc tests, cargo test options, and test organization.

Unit testing services and controllers, integration testing API endpoints, and end-to-end testing strategies for Strapi 5.

Read, search, and transform text files using cat, grep, sed, awk, and shell pipes and redirection.

How browsers calculate element sizes using the CSS box model -- content, padding, border, margin, box-sizing, and debugging with DevTools.

Learn how JavaScript interacts with web pages through the DOM -- selecting elements, modifying content, creating and removing elements, and traversing the tree.

The Java Content Repository, node types and properties, resource resolution, CRXDE Lite, and how Apache Sling maps URLs to content.

Defining traits, implementing traits for types, default methods, generic functions and structs, trait bounds, where clauses, standard library traits, derive macros, and trait objects.

CSS transitions for smooth state changes, transform functions (translate, rotate, scale, skew), keyframe animations, timing functions, and performance tips.

Common Strapi issues and solutions, debugging techniques, and a complete guide for migrating from Strapi 4 to Strapi 5.

Key tsconfig.json options explained, strict mode, target and lib, path aliases, project references, ts-node, tsx, and ESLint integration.

TypeScript adds static types to JavaScript -- learn type annotations, interfaces, generics, union types, and how to set up a TypeScript project.

TypeScript with Node.js, TypeScript with React including event types and hooks, common real-world patterns, and migrating a JavaScript project to TypeScript.

Setting up TypeScript in Strapi 5, generating types from content schemas, typing controllers, services, and Document Service queries.

git restore, git reset (soft/mixed/hard), git revert, git clean, amending commits, and using reflog as a safety net.

JUnit 5 setup with Maven and Gradle, @Test, lifecycle annotations, Assertions, @DisplayName, @Nested, and parameterised tests.

Setting up Jest and Vitest, writing describe/it/test blocks, using expect matchers, lifecycle hooks, and running your test suite.

CSS length units -- px, em, rem, percentages, viewport units, and when to use each one for font sizes, spacing, and layout.

Practical examples of TypeScript's built-in utility types — Partial, Required, Readonly, Pick, Omit, Record, Exclude, Extract, NonNullable, ReturnType, and Parameters.

Declaring variables with the dollar sign, understanding PHP's data types, working with constants, type juggling, and inspecting values with var_dump.

Declaring variables with let, understanding immutability by default, the mut keyword, shadowing, scalar types, compound types, type inference, type annotations, constants, and numeric overflow.

Learn Java's primitive types, String basics, type casting, var, final, arithmetic, comparison, and logical operators.

Learn about JavaScript variables (let, const, var), primitive data types, type coercion, operators, and template literals.

Understand named volumes and bind mounts, when to use each, and how to persist data across container restarts and rebuilds.

Learn how to fetch data from APIs, handle JSON responses, use async/await, and store data with localStorage and sessionStorage.

Relational databases, PDO, CRUD operations, prepared statements, transactions, and building a simple task manager.

Reading and writing files, CSV and JSON, directory operations, file uploads, path functions, and security best practices.

HTML forms, GET and POST requests, superglobals, input validation, and building a contact form.

Learn how to write a Dockerfile to build custom images, understand layer caching, use .dockerignore, and tag and push your builds.

Component anatomy in AEM -- the cq:Component node, HTL template, dialog, and Sling Model. Creating, deploying, and using a simple component.