Navigation

In this video, we enhance the user experience of our survey application by improving navigation flow and tightening up some important logic. You’ll see how to guide users more intuitively through the app while ensuring clean, secure, and predictable behavior.

What We Cover
- Fixed the query in take_store by adding a missing where survey_id filter
- Added a welcome page that lists all active surveys
- Prevent users from retaking a survey they’ve already completed
- Updated the “thanks” page with a Redo Survey link
- Stretch Goal: Introduced a simple top-level navigation menu to improve app-wide usability


#Laravel #PHP #WebDevelopment #FullStackDev #TekCasts #WebAppDesign

Nested Structures & Loops w/Objects

As your programs grow more complex, you’ll often need to work with data inside of data. In this episode, we explore how to combine arrays and objects to model richer, more realistic structures.

🎯 What you’ll learn:
• How to create and work with arrays inside arrays (like a game board)
• How to structure objects inside objects (like a user and their account)
• How to manage arrays of objects (like a list of students)
• How to handle arrays inside objects (like student grades)

🎥 What you’ll see:
• Code examples of each structure
• How to access nested values
• How to loop through nested data using for loops or for...of

By the end of this episode, you’ll understand how to organize complex data and access it confidently — a big step toward working with real-world applications! 🗃️🔁

New Fortify + Breeze Package

In this video we walk through my custom fork of Laravel Breeze (repo: rcravens/breeze), showing how to get a full authentication system up and running in Laravel — with views, routes, and backend logic all wired up thanks to Laravel Fortify + Breeze.

Whether you’re building a brand-new Laravel project or retrofitting auth into an existing one, this setup gives you a clean, flexible, and fully functional auth flow that’s easy to customize.

✅ What You’ll Get
- A minimal auth scaffold that “just works” — login, registration, password reset, email verification, profile update, password change, and more.
- Blade-based views + Tailwind styling for a clean UI.
- Full route list and handlers (Fortify + Breeze) including register, login, logout, password reset, email verification, profile update, etc.
- A structure that works in fresh projects or existing Laravel apps that didn’t start with a “starter kit.”


🔧 How to Use It
- `composer require rcravens/breeze`
- Run `php artisan breeze:install`, choosing "Laravel Forge + Blade Views" and your preferred options.
- Migrate your database, compile assets — and you’re ready to go.
- Explore routes like /register, /login, /forgot-password, /profile, etc. — everything is wired up for you.


📚 Useful Links & Resources
- GitHub Repo: https://github.com/rcravens/breeze
- Official Laravel Starter Kits documentation (covers Fortify + Breeze): https://laravel.com/docs/starter-kits
- Laravel Breeze overview article: https://laravel-news.com/laravel-breeze


#Laravel #LaravelBreeze #LaravelFortify #PHP #WebDevelopment #Auth #TailwindCSS #FullStack #OpenSource #TekCasts #CleanCode #Backend #Frontend #DeveloperTools

Objects - Key / Value Pairs

Objects are one of the most powerful and flexible tools in JavaScript. In this episode, we’ll explore how to represent real-world things — like people, places, or ideas — using key/value pairs.

🎯 What you’ll learn:
• What objects are and why they matter
• How to define and access object properties
• The difference between dot notation and bracket notation
• How to add, update, and delete properties dynamically

🎥 What you’ll see:
• A walkthrough of building a simple person object
• Real-time code edits and console logging
• Examples that mirror how data is structured in real apps

After this episode, you’ll see how objects give your data shape and make your code more expressive and organized. 🗂️📦

Operators & Expressions

Now that you know how to store data, it’s time to work with it! In this episode, we’ll explore how JavaScript uses operators and expressions to perform calculations, compare values, and make decisions. 🚀

🎯 Here’s what we’ll cover:
• Master arithmetic operators like addition, subtraction, multiplication, division, remainder, and exponentiation.
• Use assignment operators to update variable values quickly and efficiently.
• Compare values with comparison operators like ==, ===, !=, <, >, <=, and >=.
• Combine logic with logical operators: and (&&), or (||), and not (!).

🎥 Visual Walkthroughs:
• See real-world examples of manipulating numbers and booleans.
• Watch how combining different operators creates dynamic expressions.
• Practice thinking like a computer: true, false, and everything in between!

By the end of this episode, you’ll be writing powerful expressions and making JavaScript do some real thinking for you! 🧠⚡️

Other Browser APIs

🌐✨ Unlock the Hidden Superpowers of Your Browser! ✨🌐

Did you know your browser can remember things, track your location, talk to your clipboard, and even access your camera? 🚀 In this video, we’ll dive into the world of Browser APIs and see how JavaScript can hook into these powerful tools.

Here’s what you’ll learn:
🗄️ Storage APIs — localStorage, sessionStorage, and cookies (where do your app’s secrets live?)
📍 Geolocation — get your users’ coordinates (with their permission 😉)
🖥️ Navigator API — online/offline detection, device info, and more
📋 Clipboard & Notifications — small but mighty features for modern apps
📸 Camera Access — yes, your browser can take photos!

By the end, you’ll see your browser not just as a window to the web, but as a full-featured platform ready to power real-world apps. ⚡

Parameters, Return Values, and Scope

In this episode, we go deeper into how functions communicate — by receiving input, producing output, and knowing where variables “live.” 🧩

🎯 Here’s what we’ll cover:
• How to pass data into functions using parameters and arguments.
• Use return values to get results back from functions.
• Understand scope — where your variables exist and who can see them:
• Local (block), function, and global scope.
• Get a taste of lexical scope with a simple nested function.

🎥 Visual Walkthroughs:
• Watch functions take in inputs and return meaningful results.
• See clear, visual examples of variable scope in action.
• Spot common mistakes like trying to access variables outside their scope.

After this episode, you’ll be writing smarter functions that take input, give output, and stay in their own lane! 🧠➡️🧪➡️📦

Photo Deletion

🖼️ Improved Photo Show Page


In photo.show, hide the summary and reviews if none exist


🔗 Delete Route & Form


Add a new route using the DELETE method
In photo.show, display a delete form only if the logged-in user owns the photo
Include a hidden input field: _METHOD = DELETE
Update the Router class to detect the method via:
$_POST['_METHOD'] ?? $_SERVER['REQUEST_METHOD']


🔧 Controller Refactor


Split responsibilities:
ReviewController: keep only the store method, and fix redirect_back() usage
PhotoController: remove the store method


🧨 Destroy Method in PhotoController


Ensure the user is authenticated
Validate the photo exists
Validate ownership of the photo
Delete the photo file:
Add directory() method to the Photo model
Add convert_to_path() method to the Photo model
Delete the corresponding database record:
Add a delete() method to the base Model class


📌 That wraps up the deletion flow and lands us at v26-delete-photos — now users can clean up after themselves!

Popular JavaScript Frameworks

Your JavaScript framework journey is about to level up 🔍📦

We’ve built our own lightweight Node.js MVC framework — now let’s look outward and explore how it stacks up against several strong contenders in the ecosystem. Why use a framework, when vanilla Node gives you full control? What trade-offs come with more structure? In this episode, we dig deep into those questions.

👉 In this episode, you’ll learn how to:
🚀 Understand the value frameworks bring: structure, built-in features, community, performance
⚙️ Compare what we’ve built against mature solutions
🧭 Decide when it’s worth adopting a full framework and when you might stick with custom
⚖️ Spot the key trade-offs between flexibility and convention

📚 Frameworks we cover:
[03:19] Next.js — https://nextjs.org/
[06:39] NestJS — https://nestjs.com/
[10:38] Express.js — https://expressjs.com/
[13:38] Nuxt.js — https://nuxt.com/
[16:00] Meteor — https://www.meteor.com/
[17:58] Koa.js — https://koajs.com/
[19:20] Fastify — https://fastify.io/
[21:39] Remix — https://remix.run/
[24:04] Sails.js — https://sailsjs.com/
[26:32] AdonisJS — https://adonisjs.com/
[29:06] Hapi.js — https://hapi.dev/


By the end, you’ll not only appreciate how well your custom framework works — you’ll also be ready to evaluate the full-scale options and pick the right tool when it’s time to scale.

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners: https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser: https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment


Libraries / Docs mentioned:
- Node.js HTTP: https://nodejs.org/api/http.html
- Node.js URL: https://nodejs.org/api/url.html

Processes and Jobs - Monitor, Kill, Background Jobs, Crontab, SystemD

This video is part of the Linux Crash Course series. This video will cover how to manager processes and jobs. We will cover the following:

1. How to monitor running processes
2. How to kill or stop existing processes
3. Run a script in the background as a job
4. Run a script at a scheduled interval (e.g., once per minute...) using crontab
5. Run a script as a service using systemd

Github Repo: https://github.com/rcravens/linux-crash-course

Properties and Methods

Unlock the power of Properties and Methods in PHP OOP! In this action-packed lesson, we dive into public and private properties & methods, breaking down the magic of encapsulation 🔒. Watch as we create a class, instantiate objects, and interact with public properties & methods from the outside 🌎. But wait—what about private ones? 🤔 No worries! I’ll show you how to work with them inside the class like a pro.

Get ready to level up your PHP skills one method at a time! ⚡👨‍💻

Publishing Your Package on Packagist

Now it’s time to publish our package and make it available to the world! 🌍 We’ll walk through submitting our package to Packagist and using Composer to install it in a project.

📌 What you’ll learn:
✅ Registering a package on Packagist
✅ Using Composer to install your package
✅ Replacing old code with the new package

By the end of this video, your PHP package will be live and ready for developers to use! 🚀

🔔 Subscribe for more PHP tutorials!

🔗 Resources:
• Packagist Guide

Question Data Model

In this episode, we shift from static components to data-driven questions by introducing a simple Question Data Model. This prepares our Survey App to dynamically render questions based on data — not hard-coded markup.

💡 What You’ll Learn
- How to represent survey questions as PHP objects
- Passing structured question data into Blade components
- Using props to render reusable question types
- Handling dynamic attributes like placeholders, required flags, and default answers
- Setting up for conditional logic and future dynamic surveys

🧠 You’ll see how clean data structures unlock flexibility in your Blade components — a key step toward building a fully dynamic survey system.

📺 Up Next: Survey Data Model — where we combine question data into full survey definitions and begin organizing sections for more complex forms.

#Laravel #PHP #WebDevelopment #TekCasts #Blade #Eloquent #FullStack #SoftwareEngineering #LaravelDevelopers #CleanCode #ComponentDrivenDevelopment

Recap & Next Steps

Your Node.js journey comes full circle 🌎✨

In this final episode of JavaScript on the Server, we recap everything you’ve learned — from your first console.log() to deploying a full-featured web app — and explore what comes next 🚀

👉 In this episode, you’ll:

🧩 Review each module and how it fits into the bigger picture
⚙️ Connect key concepts like routing, MVC, sessions, and middleware
💡 See how frameworks build on the foundation you’ve created
🧭 Discover practical next steps to deepen your skills
🔥 Leave with a clear path forward for your JavaScript and Node.js mastery

By the end, you’ll have a strong grasp of how the server-side ecosystem works — and the confidence to keep building, learning, and exploring 💪

💡 Relevant Links

Previous TekCasts series:
- JavaScript for Beginners → https://tekcasts.com/play/javascript-for-beginners-what-is-javascript
- JavaScript in the Browser → https://tekcasts.com/play/javascript-in-the-browser-browser-runtime-environment

Key Topics from this Series:
- Node.js HTTP → https://nodejs.org/api/http.html
- Node.js fs → https://nodejs.org/api/fs.html
- Node.js path → https://nodejs.org/api/path.html
- EJS Templates → https://ejs.co/
- Express (for further learning) → https://expressjs.com/

Redirection and Pipes - Output & Input, Chaining Commands

This video is part of the Linux Crash Course series. This video will continue exploring the Linux File System. In this video I will discuss redirecting stdin, stdout, and stderr. In addition, we will look a chaining commands together using pipes.

Github Repo: https://github.com/rcravens/linux-crash-course

Resource Controllers

In this video, we continue building our survey application by exploring Resource Controllers, CRUD operations, and RESTful routing conventions in Laravel.

You’ll learn how Laravel connects controllers, models, and routes using expressive, convention-driven patterns that dramatically simplify your codebase.

What We Cover
✔ Controllers
- Off-loading logic from route files
- Organizing application behavior into coherent action methods
- Coordinating Models and Views

✔ Eloquent Models
- Representing database tables as objects
- Simplifying database interactions
- Handling model relationships
- Working with PHP instead of SQL

✔ CRUD Fundamentals
- Create, Read, Update, Delete
- Why nearly every model needs these operations

✔ RESTful Routes
- Mapping CRUD operations to HTTP verbs
- GET, POST, PUT/PATCH, DELETE
- Using _method to simulate non-GET/POST verbs in forms

✔ Resource Controllers
- Scaffolding with: `php artisan make:controller SurveyController --resource`
- Understanding index, create, store, show, edit, update, destroy
- Conventions that keep your controllers clean and predictable

✔ Resourceful Routing
- Connecting all CRUD routes with a single line: `Route::resource('surveys', SurveyController::class);`
- Overview table of every generated route, verb, URI, and action

✔ Nested Resources & Relationships
- Handling survey sections with nested resource routes
- Using ->scoped() to ensure child models belong to parent models
- Auto-generated nested route names (e.g., surveys.sections.index)

Links & References
- Laravel Resource Controllers Documentation: https://laravel.com/docs/12.x/controllers#resource-controllers

If you're learning Laravel the pragmatic way — by building real features, with clean code, using the framework as intended — hit subscribe and follow the full series!

#Laravel #PHP #RESTful #CRUD #CleanCode #WebDev #TekCasts