Master Golang: Full Course Curriculum

Strong Typing and Zero Values Go requires explicit data types for variables, function parameters, and return values.

If Statements in Go Go uses if, else if, and else to control program flow based on boolean conditions.

Arrays and Slices in Go Arrays have a fixed size, and their length is part of their type, making arrays of different sizes distinct types.

Composition Over Inheritance in Go Go does not use classical object oriented inheritance and instead favors composition.

Package main and Entry Point In Go, package main defines an executable program, and func main serves as the entry point.

Go’s Explicit Error Handling Model Go treats errors as values and requires developers to handle them immediately using if err != nil.

Goroutines and Concurrency Goroutines are Go’s mechanism for running functions concurrently.

Definition of a Model A model represents a core concept within a system, not merely a one to one mapping to a database table.

UI and server side rendering context The transcript explains that readers interact with an application through a UI that is typically produced by combining database data with.

Role of the Controller The controller acts as the traffic director in an MVC architecture.

Separation of Concerns Principle Separation of concerns is the core principle connecting the previously discussed components.

Routing in MVC Architecture The router maps incoming HTTP requests (GET, POST, PUT, DELETE) to specific controller functions.

Introduction to MVC Architecture The episode establishes the foundation for the application architecture using the Model View Controller (MVC) pattern.

Centralized Configuration Management The video introduces a structured approach to managing application configuration in a single location.

Application Entry Point in Go The application entry point is placed under the cmd directory, which contains executable binaries.

Postgres Setup Options Postgres is used as the primary database and can be installed directly on the system or run inside Docker.

Relational Database Fundamentals A relational database stores structured data in tables and models relationships between entities.

Transactions in Relational Databases A transaction is a single unit of work that must either fully succeed or fully fail.

Relational vs. NoSQL Databases Relational databases use structured tables and predefined schemas, but they are not the only.

Creating a Database Package The video introduces a dedicated database package in a Go application to manage PostgreSQL connectivity.

Tool Directive in Go 1. 24 The video introduces the tool directive added in Go.

Problem: Verbose Tooling Commands Tools like Goose and SQLC require long, repetitive command line arguments for paths, configurations, and database settings.

Purpose of Migrations Migrations manage the structure and evolution of a database, including tables, columns, and relationships.

Introduction to SQL and Declarative Programming The video transitions from database migrations to interacting with the database using SQL.

Model Initialization A shared queries variable is created using the SQLC generated query struct.

Base Layout Component A reusable base layout component is created to standardize the HTML structure across all pages.

Introducing Dependency Injection in Controllers The controller is refactored into a struct that accepts dependencies, specifically a database connection.

Adding a Publication State to Articles A new publishedat column is introduced to distinguish between draft and published articles.

Seeding Initial Data The video demonstrates how to create seed data using a command directory with a dedicated main.

Article View Implementation The module focuses on building the article view and completing the navigation flow between the home and article pages.

Componentizing the Home View The UI is refactored into smaller components such as Hero, Socials, and Latest Articles to improve readability and structure.

Purpose of Slugs Slugs replace numeric IDs in URLs to improve SEO, readability, and shareability.

Introduction to Markdown Markdown is a lightweight markup language created in 2004 that uses plain text syntax to structure documents.

Improving Application Styling and Structure The current application is functional but lacks visual appeal, responsive behavior, and proper structural design.

Introduction to Tailwind CSS Tailwind CSS is a utility first CSS framework that enables building custom designs directly in HTML using pre built utility classes.

Serving CSS in a Go Application The video explains different ways to serve a CSS file, including hosting it on a server, using S3 with a CDN, or embedding it directly into.

Mobile First Approach The layout is built using a mobile first strategy, starting with styles for the smallest screen and progressively enhancing for larger screens.

Introducing a Color Theme The video explains the importance of implementing a standardized color theme to improve UI presentation.

Base Layout Styling The layout is refined by replacing default background and text colors with theme based utility classes.

Current Blog State The blog frontend is now responsive and usable across phones, tablets, and desktops.

Admin Page Objective The video builds an admin landing page that displays all articles in a paginated table.

Route and Controller Setup A new route is created for /admin/articles/new using an admin prefix to reduce repetition.

Route and Controller Setup A new POST route is created for article creation under an admin prefix.

Integrating EasyMDE Markdown Editor The video demonstrates how to integrate the EasyMDE JavaScript Markdown editor to enable a WYSIWYG editing experience.

Routing and Edit Page Setup The edit functionality is introduced by defining a new route that includes an article ID parameter.

Need for Authentication The current application allows unrestricted access to the admin page, enabling any user to create or delete articles.

Database Migration Setup A new users table is created via migration, including fields for ID, timestamps, email (unique and not null), and password (byte type).

Password Hashing with Salt A function is implemented to generate a cryptographically secure random salt for each password.

Middleware for Route Protection Middleware is introduced as a maintainable way to protect specific routes instead of duplicating logic in controllers.

Introduction of IP Rate Limiting The video demonstrates how to implement an IP based rate limiter in a Go web application.

App Cookie Structure An application wide cookie structure is created to store authentication state and user email.

CSRF Protection Implementation Cross Site Request Forgery protection is added using Echo middleware.

Extending the Authentication System The video reviews core authentication components and introduces additional features such as email verification and password reset.

Current Application State The project already includes authentication, an admin panel, and responsive article rendering.

Definition of Hypermedia Hypermedia refers to media (text, images, video) that includes links to other media.

Overview of Web Application Approaches The video compares different approaches to building modern web applications, focusing on Single Page Applications (SPAs), traditional.

Improving Flash/Toast Messages The video begins by addressing persistent flash messages that require a page refresh to disappear.

Clickable Article Cards with Datastar The video demonstrates how to make entire article cards clickable using data on with a click event.

Goal: Inline Form Validation The video introduces real time validation for a new article form to provide instant feedback while typing.

Script Refactoring and Layout Optimization The ECMDE script is moved from individual create/edit pages into the base layout header to centralize JavaScript loading.

Refactoring Form Validation The editor lost focus on every keystroke due to how validation state was handled.

Deployment Preparation and Optimization Goals The application is nearly ready for deployment, with remaining tasks focused on SEO optimization, page caching, browser caching,.

Introduction to Caching Caching is a technique for temporarily storing frequently accessed or expensive to compute data to improve performance.

Static Asset Caching Strategy The video explains how to cache CSS, JavaScript, and images to prevent unnecessary re downloads and improve load performance.

Custom Not Found Page (404) A dedicated not found view is created to handle unmatched routes.

Self Hosting Strategy The video introduces deploying an application by setting up and managing a personal VPS instead of relying on managed cloud services.

Choosing a VPS Provider The video discusses selecting a VPS provider, noting that options like Hetzner, DigitalOcean, OVH, Hostinger, and AWS are all viable.

Objective: SSH Hardening and Server Security The video focuses on securing a newly provisioned server before production use.

Secure Server Setup The server is secured using SSH with a private key and password.

Choosing a Self Hosted Database The speaker opts for a self hosted database on a VPS instead of a managed solution due to cost and learning benefits.

Database Migrations Strategy The application must apply database migrations before running in production.

Using systemd for Application Management The application is managed using systemd to ensure a robust and maintainable runtime environment.