Make an E-Commerce Website with Blazor WebAssembly in .NET 6
This course is a comprehensive guide to building a full-featured e-commerce application using Blazor WebAssembly and .NET 6.
You will start by setting up the development environment, including installing .NET and Visual Studio.
The course then walks you through creating a Blazor WebAssembly project and understanding its structure.
Next, you will build a “walking skeleton” of the e-commerce website, covering essential features like displaying products, creating a web API, integrating with a database using Entity Framework Core, and implementing CRUD operations.
Along the way, you’ll learn best practices such as using services with dependency injection and implementing a service response pattern.
The course dives deep into product management, teaching you how to display product details, handle categories, variants, search functionality, featured products, and pagination.
You’ll also implement a shopping cart using local storage and later migrate it to a database for authenticated users.
User authentication is a crucial aspect covered in the course, where you’ll learn to implement registration, login, and JSON Web Token (JWT) authentication.
You’ll also build user profiles and enable features like changing passwords.
Once the core functionality is in place, the course guides you through integrating a payment system using Stripe Checkout.
You’ll learn how to create a checkout session, handle successful payments, and fulfill orders.
The course also covers adding delivery addresses for orders and building an admin dashboard for managing categories, product types, and products themselves.
You’ll implement CRUD operations for these entities, allowing administrators to add, update, and delete them.
Additionally, the course includes a bonus section on uploading images and an introduction to MudBlazor, a popular UI library for Blazor applications.
You’ll learn how to associate multiple images with products and display them using MudBlazor components.
Throughout the course, you’ll work with various .NET technologies, including Entity Framework Core, Web APIs, dependency injection, and authentication middleware.
You’ll also gain experience with client-side development using Blazor WebAssembly, handling HTTP requests, and working with components and services.
Getting started with WebAssembly & Emscripten
You will start by getting an overview of WebAssembly and its purpose, ensuring you have the necessary prerequisites, and setting up your coding environment.
The first part dives into the native WebAssembly JavaScript API in the browser.
You will learn how to load a WebAssembly module, export and execute functions from it, import and call JavaScript functions, and directly access and read data from the module’s memory.
Next, you will be introduced to Emscripten, a toolset that simplifies working with WebAssembly.
The course walks you through installing Emscripten on different operating systems and compiling your first WebAssembly module from C code.
You will explore various compilation options, learn to export C functions to JavaScript, call JavaScript from C using the Emscripten library, work with memory buffers, and debug your WebAssembly modules.
The practical section includes a micro-benchmark project to compare the performance of JavaScript and WebAssembly for calculating prime numbers.
You will also build a canvas project in multiple parts, covering setup, creating data structures in WebAssembly, generating random data, rendering on a canvas, and animating the WebAssembly data.
Throughout the course, you will gain hands-on experience with key concepts like the WebAssembly API, Emscripten exports and imports, memory access, debugging, and practical applications of WebAssembly in projects.
The course covers essential topics like reading strings from memory, custom memory imports, pointer-to-string conversions, and working with the Emscripten module object.
Blazor WebAssembly Full Stack Bootcamp with .NET 5
This course teaches you to build full-stack web applications using Blazor WebAssembly and .NET 5.
You’ll start by learning the fundamentals of Blazor WebAssembly, including creating your first Razor components, handling component communication, and working with services.
The course then dives into building a game application, where you’ll learn how to create user interfaces, handle forms and validation, and implement authentication using JSON Web Tokens (JWT).
Along the way, you’ll explore the Model-View-Controller (MVC) pattern, work with Web APIs and Entity Framework for data access, and integrate with databases like SQL Server and SQLite.
As you progress, you’ll learn advanced topics like implementing one-to-many relationships, creating leaderboards, handling battles and battle histories, and deploying your application to a Windows Server using Internet Information Services (IIS).
The course also covers migrating from .NET Core 3.1 to .NET 5, taking advantage of the latest features and improvements.
Throughout the course, you’ll gain hands-on experience with essential tools and technologies like Visual Studio, Postman, Git, and GitHub.
You’ll learn how to work with CSS for styling, handle asynchronous calls, and leverage dependency injection for better code organization.
Rust & WebAssembly with JS (TS) - The Practical Guide
You’ll start by setting up your Rust environment and learning the basics, like primitive types, variables, and functions.
The course then dives into more advanced concepts like ownership, borrowing, and references, which are crucial for writing safe and efficient Rust code.
As you progress, you’ll explore data structures like strings, structs, and enums, as well as traits, which allow you to define shared behavior across types.
Modularity is also covered, teaching you how to organize your code into reusable modules.
The course then shifts its focus to WebAssembly, a binary instruction format that allows you to run Rust code in the browser.
You’ll learn how to compile Rust code to WebAssembly, load it in the browser, and interact with it using JavaScript (or TypeScript).
To solidify your understanding, you’ll build a snake game using Rust and WebAssembly.
This hands-on project will cover topics like rendering graphics, handling user input, updating game state, and more.
Along the way, you’ll learn about important concepts like pointers, memory management, and performance optimization.
The course also covers deployment, teaching you how to package your WebAssembly application for production and serve it using a development server or a command-line interface (CLI) tool.
Throughout the syllabus, you’ll find AI-assisted lectures and examples, which provide additional explanations and insights.
The course also includes optional lectures on resolving issues and understanding the lecture structure, ensuring you have the support you need to succeed.
Blazor WebAssembly - Full Stack Web Development
You’ll start by setting up your development environment with Visual Studio 2022 and creating your first Blazor project.
The course dives deep into authentication and database integration using Entity Framework Core.
You’ll learn how to configure Identity Server for authentication and create database models for user and data storage.
Setting up REST API endpoints is covered next, allowing you to serve data to your client application.
With the backend in place, you’ll explore performing CRUD (Create, Read, Update, Delete) operations in Blazor while consuming the REST API.
This includes building forms for data entry, implementing validation rules, and displaying data in lists and detail views.
The course goes beyond the basics, touching on architectural considerations like code-behind approaches for components and global error handling.
You’ll also learn value-added features like customizing Identity UI, JavaScript interoperability (including securing it with Content Security Policy), file uploads, and creating a generic HTTP client repository.
Deploying your Blazor application to production environments like Azure is covered as well.
The course even includes a bonus section with additional topics.
Throughout the journey, you’ll gain hands-on experience by building a complete web application, committing your changes to GitHub at regular intervals.
WebAssembly Beginner to Advanced
You’ll start by learning the fundamentals, including what WebAssembly is, its goals, how it works, and its relationship with Asm.js.
The course covers the creation and loading of basic WebAssembly modules, using online compilers and integrating them with JavaScript in the browser.
Next, you’ll dive into the Emscripten compiler, which allows you to compile C/C++ code to WebAssembly.
The course guides you through installing Emscripten step-by-step and even includes a performance test comparing C++, WebAssembly, and JavaScript.
As you progress, you’ll explore the low-level concepts that form the building blocks of WebAssembly modules, such as memory, tables, and global variables.
The course then takes you into the WebAssembly Text Format (Wat), teaching you to read and write the human-readable form of WebAssembly, akin to native assembly language.
The advanced sections cover more complex topics like importing and calling functions, working with strings, advanced tables and call_indirect, and dynamic linking within the Wat format.
You’ll also learn about the Emscripten Module object and how to use glue code for more intricate operations, such as calling exported C/C++ functions, calling JavaScript functions from native code, working with threads, reading from files, handling command-line arguments, and debugging WebAssembly.
If you’re interested in web development with Qt, the course has a dedicated section on compiling Qt projects to WebAssembly using Emscripten.
You’ll learn the installation process and work on a demo project.
Throughout the course, you’ll have access to source code and a bonus section covering additional topics.
Hands-On WebAssembly for C++ Programmers
You’ll start by understanding the fundamentals of WebAssembly and how it interacts with C++, witnessing its superior performance compared to JavaScript.
After grasping the basics, you’ll dive into setting up your toolchain and compiling your first C++ program to run on the web.
The course guides you through calling C++ functions from JavaScript, passing complex data types, and exploring the syntax and memory model of WebAssembly.
You’ll also learn to catch and handle exceptions, integrate modules, and override module behavior.
Moving forward, you’ll explore how WebAssembly interacts with system libraries like libc and libc++, enabling file I/O, time handling, and threading in the browser environment.
The course covers network communication using the Fetch API and its restrictions.
Transitioning to hardware interactions, you’ll convert a Pong game to use the Simple DirectMedia Layer (SDL) API, drawing graphics, handling keyboard and mouse inputs, and experimenting with WebGL for advanced graphics rendering.
Additionally, you’ll learn about windowing options and integrating widgets.
Audio processing is another exciting topic covered, where you’ll learn about SDL audio, OpenAL, playing sounds and music in your applications.
The course also dives into debugging techniques, including source maps, profiling memory and CPU, tracing execution, and utilizing sanitizers to catch undefined behavior.
Throughout the journey, you’ll work with various tools like Chrome, Firefox, and Emscripten, gaining hands-on experience in compiling, debugging, and optimizing WebAssembly applications.
The course strikes a balance between theory and practical examples, ensuring you understand the concepts while applying them to real-world scenarios.
Snake Game With Rust, JavaScript, and WebAssembly
The course takes you through building a classic snake game using Rust for the core logic and JavaScript for rendering and user interactions.
You’ll start by setting up the project and installing the necessary tools.
Then, you’ll create an instance of the Game struct from JavaScript, which will interface with the Rust code exported via WebAssembly.
The course walks you through rendering the game elements on the canvas, placing the food at random free locations, and implementing the game loop to make the snake move.
You’ll learn how to capture user input to control the snake’s direction and allow pausing the game.
As you progress, you’ll add functionality for the snake to grow when it eats food and handle game over conditions like hitting walls or biting its tail.
The course also covers saving the best score and ensuring the game looks good on any screen size.
Throughout the lectures, you’ll gain hands-on experience with WebAssembly, exporting Rust APIs to JavaScript, canvas rendering, and applying vector operations in game development.
The instructor provides links to the GitHub repository and specific commits for each part, allowing you to follow along easily.
After completing the snake game, the course encourages you to experiment by modifying the game’s appearance, adding sound effects, or even creating your own games like Tetris or Bomberman using the project structure.
You’ll learn how to deploy your game using GitHub Pages, making it accessible online.
QT C++ & WebAssembly: The Ultimate App Development Course
The course starts by setting up your development environment, guiding you through installing a virtual machine with Ubuntu and all the necessary dependencies, including WebAssembly and the Qt Framework.
Once the setup is complete, you’ll dive into programming with four well-designed projects.
The first project is the classic Tower of Hanoi game, introducing you to GUI widgets and event handling.
Next, you’ll build a Speed Reader application, working with timers and text manipulation.
The third project involves interacting with a real-world Weather API, teaching you how to handle JSON data and make network requests.
Finally, you’ll create a calculator application with a plugin architecture, exploring advanced Qt concepts.
Throughout these hands-on projects, you’ll gain experience with Qt’s signals and slots, GUI design, and other essential skills for building desktop applications.
After mastering desktop development, the course shifts gears to deploying your C++ Qt applications for the web using WebAssembly.
You’ll learn how to compile your applications and make them accessible through a URL, opening up new possibilities for cross-platform distribution.
By the end of this course, you’ll have a solid understanding of Qt development, WebAssembly integration, and the ability to build and deploy desktop and web applications using C++.