118 docs tagged with "beginners"

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.

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.

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 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.

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.

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

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 Java inheritance, method overriding, abstract classes, interfaces, polymorphism, sealed classes, and composition vs inheritance.

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 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.

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.

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

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.

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

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.

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.

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.

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).

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.

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.

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

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.

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

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.

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.

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

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

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

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.

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.

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