Cursos de Desarrollo
Los mismos datos para todos, vengan de Udemy o de Coursera: precio, valoración, duración e idioma. 1.285 cursos encontrados. Afinar la búsqueda
NodeJS Internals and Architecture
My favorite thing in software engineering is the art of making it transparent. Node is one of the most popular runtimes used on backend engineering yet I feel it is the least understood. I surely felt this way at times. I spent months working on a course to demystify NodeJS Internals and Architecture and distilled this in this comprehensive course. I built this course is for the engineers who can't stand working with something opaque. They love to understand what is running behind the engine. They enjoy tearing apart 1 the line of code into its original 1000 lines. They question why is the output of a Node program is unpredictable. They want to know when does the Node process exit. They want to know why Node takes so long to start in some cases. They appreciate how Node works on all operating systems and would like to know how it does that. For example by understanding the internals of HTTP module, you can write a backend in Node that accepts and process more requests. Every line of code you write you would think of how and when Node will process it. By understanding the event loop and the different stages you can tune and re-order your code to achieve best performance and even consistent result. Ever wrote a program in Node that fails 1% of the time while succeeds 99%? Understanding Node architecture helps you make your program predicable. As opposed to adding workaround because you don't understand. We all did that. It is all about removing blockage and letting the main loop phases “breath”. When we build software the problem is we often go against the grain. Understanding where the friction is in Node allow you to work with it as oppose to against it. In this course I cover the following - NodeJS Architecture I cover the various phases in the event loop and what exactly happens in each phase, how promises are just callbacks, how and when modules are loaded and their effect on performance, Node packages anatomy and more - Node Internals This is where we go one layer deeper, how Node truly achieves asynchronous IO with libuv, and how each protocol in node is implemented. How concurrent node works on both user level threads and process level. - Node Optimization and Performance Now that we understand the internals and architecture of Node, this is where we discuss tips how to make the code runs more efficiently and more performance. And only when we exhaust all other avenues Node provides ways to extend it with C++ add-ons where JavaScript just can't no longer hold. This course is for intermediate students who are familiar with Node and want to understand how it works. While not required, I recommend taking the fundamentals of operating system course as a prerequisite of this course.
Se préparer au Professional Cloud Database Engineer
Ce cours aide les participants à se préparer à l'examen de certification Professional Cloud Database Engineer. Les participants se familiariseront avec les sujets d'examen au moyen d'une série de cours, de questions de diagnostic et de contrôles des connaissances. Au terme de ce cours, ils disposeront d'un livret d'exercices personnalisé qui les guidera pour le reste de leur préparation à la certification.
Flutter Mobile App: Build Chatbot with Firebase & Gemini AI
Flutter Mobile App Development with Firebase & Gemini AI Master Flutter app development by building modern, AI-powered mobile applications using Firebase and Gemini AI. This comprehensive course teaches you how to create production-ready Flutter applications with authentication, Cloud Firestore, AI chatbots, image understanding, persistent conversations, and real-world features used in today's mobile apps. Whether you're a beginner or an experienced developer, you'll learn how to build scalable Flutter applications while integrating Google's latest AI technologies. By the end of the course, you'll have the skills to develop intelligent mobile apps that can understand text, process images, remember previous conversations, and provide AI-powered assistance. What You'll Learn • Flutter app development from beginner to advanced • Build cross-platform Android and iOS applications • Integrate Firebase Authentication and Cloud Firestore • Develop AI chatbots using Gemini AI • Create conversational AI experiences with persistent chat history • Manage AI conversation context and memory • Store and restore conversations using Firebase Firestore • Build multimodal AI features with image processing • Use Provider for scalable state management • Design clean, responsive Flutter user interfaces • Connect Flutter apps with REST APIs and asynchronous services • Implement secure user authentication and cloud data storage • Build production-ready mobile applications using best practices Technologies Covered • Flutter • Dart • Firebase • Firebase Authentication • Cloud Firestore • Gemini AI • AI Chatbots • Provider • Image Picker • REST APIs • Async Programming Real-World Projects Throughout this course, you'll build practical applications that demonstrate real-world Flutter app development, including AI assistants, intelligent chatbots, Firebase-powered mobile apps, image analysis, and persistent AI conversations. This course is regularly updated with the latest Flutter, Firebase, and Gemini AI features, ensuring you learn modern development practices that are in demand across the mobile app industry.
Gen AI: Beyond the Chatbot
Gen AI: Beyond the Chatbot is the first course of the Gen AI Leader learning path and has no prerequisites. This course aims to move beyond the basic understanding of chatbots to explore the true potential of generative AI for your organization. You explore concepts like foundation models and prompt engineering, which are crucial for leveraging the power of gen AI. The course also guides you through important considerations you should make when developing a successful gen AI strategy for your organization.
Vim Masterclass
Did you know that the most productive command line experts exploit the powerful features of the Vim text editor? The problem is that if you want to get really good with Vim it can take you an extremely long time if you're trying to learn it on your own. That's why the Vim Masterclass was created. This course gives you the absolute shortest path to learning the basics. It also provides you the fastest way to learn the most advanced features, too. By the time you finish the Vim Masterclass you'll know how to: • Work with multiple files, including how to move data back and forth between different files, copying & pasting from one file to another, and quickly jumping to another file. You'll also learn how to view multiple files at the same time using Vim's windowing system. • Use the must-know keyboard shortcuts and how to remember them easily. You'll actually learn how to "think in Vim" so you don't even have to memorize each and every command, saving you countless hours of work. • Find and replace entire blocks of information within a file. That includes how to refactor your code by renaming all variables in a file or set of files, reliably. Of course, you'll learn simple find and replace techniques to replace a word in an entire file and much more. • Cut, copy and paste. You'll find out how to make the most of Vim's built-in clipboard system, use Vim's clipboard history, and how to access your system's clipboard from within Vim. • Visually select blocks of text and perform edits on those blocks like moving the block, deleting the block, indenting/shifting the block, and more. You'll understand Vim's text objects so you can quickly select single or multiple words, lines, paragraphs, HTML/XML tags, code blocks, and more. • How to make vertical edits and use Vim's Visual Block Mode. (Some call this column editing mode or rectangle mode…) • Enable syntax highlighting for source code, configuration files, or any type of file you edit often. That includes how to customize the color scheme and color code text in Vim. • Employ simple to advanced navigation techniques so you can go exactly to where you need in a file very fast. • Practical application tips such as how to edit source code, scripts, HTML, and more. You'll find lots of opportunities for practice in this course. • Make the most of the built-in help system to quickly find what you need, all without leaving Vim. • Use MacVim and gVim on Linux and Windows. This includes learning the advantages and disadvantages of both the textual interface and the graphical interfaces to Vim. • Create, save, and replay macros to normalize data and quickly repeat complicated edits. You'll learn how to append or prepend text to every line in a text file, how to format one line of text and apply that formatting to a specified area in the file and more. In short, you'll learn how to automate everything in Vim. • Create custom shortcuts and personalized key mappings. If you want to create a shortcut for something you do often, you'll find out how to make your life a whole lot easier. • Indent and shift blocks of text. You'll also learn how to enable auto indentation so you can quickly clean up and prettify your source code. • And more... When you start the course, you'll be able to use vim almost immediately. I want to make sure you get up and running as quickly as possible. That's why at the beginning of the course you'll learn how to start vim, how to make simple edits, and how to save your changes. After that, we'll build on your knowledge and even get into some really advanced techniques such as editing multiple files at once, creating macros, making global substitutions in many files at the same time, ways to format and normalize data, how to "think in vim", and much more. Having taught thousands of students over the years, I know people learn best by doing. That's why I've packed this course with tons of practice exercises. For each exercise you, get detailed, step-by-step instructions. I encourage you to try the labs on your own first. Then I walk through the exercise while you look over my shoulder. Not only will you learn the concepts, you'll watch me demonstrate how to put those concepts to good use, and you'll practice those new skills immediately so that you really understand and retain what you're learning. This course is ideal for anyone who works on the command line often. Whether you're a system administrator, a developer, a database administrator, or anyone else who has to edit files in a command line environment, this course is for you. Even though this course does cover the graphical version of vim, it is NOT for people who are looking for "what you see is what you get" (WYSIWYG) word processing help. No, this course is for people who want to get really efficient at editing plain text files, such as server configuration files, shell scripts, source code, and any other type of textual data. So, if you're tired of being scared of vim, or just aren't making the progress you'd hope to by just dabbling in vim, it's time to take your vim skills to the next level by enrolling in this course. Enroll Now!
Inteligencia Artificial centrada en el ser humano
Este curso presenta los fundamentos conceptuales de la inteligencia artificial. Comienza con los antecedentes históricos. Los principales conceptos se desarrollarán de forma sistemática y se analizarán desde una perspectiva filosófica. Las preguntas principales son: ¿Qué es la inteligencia y qué significa pensar y hablar un idioma?, ¿Cuáles son las implicaciones éticas y sociales de la inteligencia artificial? Los objetivos son los siguientes: 1. Reconocer y comprender las ideas principales de la IA. 2. Analizar los conceptos fundamentales de la IA. 3. Evaluar estos conceptos fundamentales desde una perspectiva filosófica, ética y social
Unreal Engine 5: One Course Solution For Material
Learn everything you need to know for creating and upstanding what's going on in materials for Unreal Engine 5. We will first learn the most basic stuff for creating materials in the first section, such as data types, lerp, UV to get you right on track for materials. After the first section, with everything we learned, we'll dive deeper into materials to create our first master material. Understanding how a master material works is essential for working inside of Unreal Engine. And we do it completely from scratch. We'll also be going over usage of different maps like base color, normal, roughness and etc. In the third section, we'll start create a scene using vertex painting from scratch. You'll learn the entire process from planning to rendering. After this section, you should be able to create any scene that you want. In the final section, we'll be creating an auto landscape material right from scratch. In this section, not only will you apply all the things you learned previously, but you'll also learn how to create different masks for blending materials, auto foliage, runtime virtual texture, tiling break up techniques and all the other cool stuff. After this course, you should able to read most of the complicated graphs and follow any tutorials about materials you like.
Introduction to JavaScript Arrays
By the end of this project you will understand how data is stored in and retrieved from arrays in JavaScript. You will use the Notepad++ editor to write JavaScript code to work with arrays. In addition to creating and populating an array, you will learn multiple methods of accessing data from arrays using JavaScript code. Arrays are a great way to store multiple values of a similar type and are commonly used in programming. Note: This course works best for learners who are based in the North America region. We’re currently working on providing the same experience in other regions.
Python 3: Deep Dive (Part 1 - Functional)
Hello! This is Part 1 of a series of courses intended to dive into the inner mechanics and more complicated aspects of Python 3. This is not a beginner course! If you've been coding Python for a week or a couple of months, you probably should keep writing Python for a bit longer before tackling this series. On the other hand, if you've been studying or programming in Python for a while, and are now starting to ask yourself questions such as: • I wonder how this works? • is there another, more pythonic, way, of doing this? • what's a closure? is that the same as a lambda? • I know how to use a decorator someone else wrote, but how does it work? How do I write my own? • why do some boolean expressions not return a boolean value? How can I use that to my advantage? • how does the import mechanism in Python work, and why am I getting side effects? • and similar types of question... then this course is for you. To get the most out of this course, you should be prepared to pause the coding videos, and attempt to write code before I do! Sit back during the concept/theory videos, but lean in for the code videos! Please make sure you review the pre-requisites for this course (below) - although I give a brief refresh of basic concepts at the beginning of the course, those are concepts you should already be very comfortable with as you being this course. In this course series, I will give you a much more fundamental and deeper understanding of the Python language and the standard library. Python is called a "batteries-included" language for good reason - there is a ton of functionality in base Python that remains to be explored and studied. So this course is not about explaining my favorite 3rd party libraries - it's about Python, as a language, and the standard library. In particular this course is based on the canonical CPython. You will also need Jupyter Notebooks to view the downloadable fully-annotated Python notebooks. It's about helping you explore Python and answer questions you are asking yourself as you develop more and more with the language. In Python 3: Deep Dive (Part 1) we will take a much closer look at: • Variables - in particular that they are just symbols pointing to objects in memory (references) • Namespaces and scopes • Python's numeric types • Python boolean type - there's more to a simple or statement than you might think! • Run-time vs compile-time and how that affects function defaults, decorators, importing modules, etc • Functions in general (including lambdas) • Functional programming techniques (such as map, reduce, filter, zip, etc) • Closures • Decorators • Imports, modules and packages • Tuples as data structures • Named tuples Course Prerequisites This is an intermediate to advanced Python course. To have the full benefit of this course you should be comfortable with the basic Python language including: • variables and simple types such as str , bool , int and float types • for and while loops • if...else... statements • using simple lists , tuples , dictionaries and sets • defining functions (using the def statement) • writing simple classes using the class keyword and the __init__ method, writing instance methods, creating basic properties using @property decorators • importing modules from the standard library (e.g. import math) You should also: • have Python 3.6 (or higher) installed on your system • be able to write and run Python programs using either: • the command line, or • a favorite IDE (such as PyCharm), • have Jupyter Notebooks installed (which I use throughout this course so as to provide you fully annotated Python code samples)
Digital Campaign Tracking and Optimization Fundamentals
You'll gain practical skills to track, analyze, and optimize digital marketing campaigns across multiple channels. Learn to implement UTM parameters for accurate campaign tracking, navigate social media management platforms to schedule content with strategic hashtags, and use email marketing tools to create engaging newsletters while measuring key performance indicators. You'll also conduct keyword research and analyze cost-per-click data to inform paid advertising decisions. This hands-on course uniquely combines technical tracking implementation with performance analysis, giving you the complete skillset needed to measure campaign effectiveness and make data-driven marketing decisions. By integrating analytics tools with content creation and campaign management, you'll develop the cross-functional expertise that makes digital marketing professionals valuable in today's data-driven landscape.
Android Lifecycles Masterclass
Lifecycles are central topic in Android app development because all main Android components, such as Activities, Fragments, and ViewModels, have unique Lifecycles. That's why a deep understanding of Android Lifecycles is essential for becoming a good Android developer and building reliable and responsive Android applications. Furthermore, many Android job interviews include questions about Lifecycles, underscoring their fundamental importance. Unfortunately, there are many different Lifecycles in Android and even small mistakes in their handling can lead to tricky bugs. These bugs often appear in real-world Android applications and require extensive effort to investigate and resolve. In this course, you'll master Android Lifecycles. From foundational concepts to advanced strategies, we'll cover everything you need to know about this important topic. You will learn: • Why Android components need lifecycles. • The lifecycles of the main Android components: • Process • Application • Activity • Fragment • ViewModel • Service • Overlapping vs non-overlapping lifecycles. • Multi-resume feature. • How to handle Configuration Changes. • How to handle Process Death. • Best practices for efficient Lifecycle management. • Hacks and ad hoc solutions for unique Lifecycle-related challenges. • Common pitfalls and gotchas to avoid in your projects. The tutorial code for this course is available in an open-source, real Android application. This application will demonstrate all the material taught in the lectures, and allow you to test tricky lifecycle behaviors when working on your own projects. So, whether you're a newcomer to Android, or a seasoned Android developer, you'll find a wealth of new information in this course. Enroll now, and join me on this epic journey into the depths of Android lifecycles!
Python and Rust with Linux Command Line Tools
This course is designed for beginners and those with some programming experience in either Python or Rust that want to implement automation and utilities in the command-line. Although no prior knowledge of Python or Rust is required, basic programming knowledge is recommended as well as some familiarity with the command-line interface (CLI). Throughout the course, you will gain a solid foundation for building efficient, reliable, and high-performance command-line tools that can help you automate tasks for data engineering, systems engineering, and DevOps. By completing this course, you will have the skills to develop and distribute sophisticated and efficient command-line tools.
Multiplayer in Unreal with GAS and AWS Dedicated Servers
This course walks you through the complete process of building a competitive 5v5 multiplayer game using Unreal Engine, the Gameplay Ability System (GAS), and AWS for cloud deployment. You'll learn to implement core gameplay mechanics in C++, design scalable systems with a modular architecture, and deploy dedicated servers using Docker and AWS—allowing players to connect and play from anywhere in the world. By the end of the course, you'll have a fully functional MOBA-style game with: • User login and account system • Lobby creation and matchmaking • Character selection • A complete game loop • Dedicated server deployment on AWS The course starts with implementing the basic character components, enhanced input system and movement control. A proper IK foot will also be implemented with Control Rig. The Gameplay Ability Systems will then be utilized to implement the character attributes and abilities, ensuring multiplayer support from the beginning, and tested throughout the course. The abilities can be learned, upgraded, and their effects are level driven. The ability system also uses attribute driven algorithms to determine character health, regeneration, and many other character properties, following industry standard implementations. Two fully playable player characters with a total of twelve abilities will be implemented in the game, a melee combo, a ranged attack, four abilities for each of the player characters, and two shared passive abilities. With GAS and a flexible OOP approach, the game can be scaled up with more players with ease. A comprehensive AI driven minion is also implemented with the AI module of Unreal Engine. The AI has proper team id configuration, perception and forgetting routine, and can be reused for other types of games. A Completed inventory and shop system that is fully compatible with the Gameplay Ability is also implemented. The systems support multiplayer, using server authoritative approach, and support item stacking, consumption, granting abilities, and combinations. A combination widget will be implemented to show the entire combination tree of any selected item in the shop. Each of the components of the Game has complete UI implementation and a sophisticated animation blueprint will also be built to ensure the rich visuals of the gameplay. There are many other systems that are created in the course, explore the course curriculum for a full breakdown of each system covered. The course primarily uses C++ to implement the gameplay mechanics. With a modular approach, many systems are decoupled and can be repurposed for different types of games.
Node.js Foundations: Core Concepts & Async Patterns
This course covers the essential concepts of Node.js, emphasizing its event-driven architecture and significance in modern backend development. Professionals will understand how Node.js enables scalable, non-blocking applications. Learners will explore the module system, callbacks, and asynchronous control flow, building skills to write maintainable, efficient Node.js code. Practical exercises reinforce each concept, helping participants apply techniques to real-world projects. What sets this course apart is its focus on combining theory with hands-on examples. Students learn both the principles and practical implementations of callbacks, promises, and async/await patterns in real Node.js workflows. This course benefits developers, programmers, and anyone with basic JavaScript knowledge looking to deepen their backend skills. No prior Node.js experience is required, but familiarity with JavaScript is recommended. This course is part one of a three-course Specialization designed to provide a comprehensive learning pathway in this subject area. While it delivers standalone value and practical skills, learners seeking a more integrated and in-depth progression may benefit from completing the full Specialization.
Cutting-Edge AI: Deep Reinforcement Learning in PyTorch (v2)
This course contains the use of artificial intelligence (it's an AI course, duh!). The world of Artificial Intelligence is moving fast, and Deep Reinforcement Learning (DRL) is the engine driving its most impressive breakthroughs—from mastering complex games to autonomous robotics and high-frequency trading. Welcome to Version 2. We’ve completely rebuilt this course from the ground up to reflect the modern AI landscape. This isn't just a minor update; it’s a total transformation designed to take you from a curious coder to a DRL expert. Why Version 2? We listened to your feedback and updated every component to ensure you’re learning with the most relevant, industry-standard tools available today: • PyTorch Native: We’ve ditched the clunky syntax of TensorFlow 1 for the elegance and flexibility of PyTorch, the preferred framework for AI researchers worldwide. • Free MuJoCo Integration: Take advantage of the industry-leading physics engine, MuJoCo, which is now open-source and free to use for your robotics simulations. • Refined Explanations: We’ve streamlined the theory, making the "math-heavy" concepts intuitive, clear, and actually fun to learn. What You’ll Master This course bridges the gap between academic theory and production-ready code. You won't just learn how to use libraries; you’ll learn how to build these sophisticated agents from scratch. 1. The Foundations (The RL Brain) Before diving into deep networks, we ensure your foundation is rock-solid. You’ll master Markov Decision Processes (MDPs) and the Bellman Equation - the mathematical heart of how an agent "values" its future. 2. Deep Deterministic Policy Gradient (DDPG) Learn the algorithm that brought Reinforcement Learning into continuous action spaces. Unlike DQN, which chooses from a list of buttons, DDPG allows agents to operate in worlds with infinite possibilities—like precisely rotating a robotic arm or adjusting a throttle. 3. TD3 (Twin-Delayed DDPG) Move beyond the basics with TD3, the "corrected" version of DDPG. You'll learn how to tackle the common problem of overestimation bias using clipped double-Q learning and delayed policy updates, resulting in much more stable and reliable agents. 4. The VIP Project: Algorithmic Trading Put your skills to the test in a high-stakes environment. You will build a custom environment for Position Sizing in Algorithmic Trading. You'll code the environment from scratch, then deploy your DDPG and TD3 agents to manage risk and maximize returns in a simulated market. Key Highlights • Preliminaries: Gymnasium basics, Vector Environments, and the "Autoreset" paradigm. • DQN Review: A quick refresher on the architecture that started the DRL revolution. • DDPG Mastery: Three-part deep dive into the theory and PyTorch implementation. • State-of-the-Art: TD3 implementation and a sneak peek into Soft Actor-Critic (SAC). • The VIP Project: End-to-end Algorithmic Trading bot development. Is This Course For You? If you are a programmer, data scientist, or AI enthusiast who wants to go beyond "plug-and-play" tutorials and truly understand the mechanics of Deep RL, this is your roadmap. We don't just show you what buttons to press; we show you how the engine works. Are you ready to build agents that can learn, adapt, and conquer? Enroll now and start building the next generation of intelligent systems! Suggested prerequisites: • calculus • probability and statistics • Python coding: if/else, loops, lists, dicts, sets • Numpy coding: matrix and vector operations, loading a CSV file • Neural networks, backpropagation, hyperparameter optimization • Can write a feedforward neural network in PyTorch • Can write a convolutional neural network in PyTorch • Markov Decision Proccesses (MDPs) • Know how to implement Temporal Difference Learning to train RL Agents
Introduction to Android graphics
This course will bring you up to speed with the fundamentals of 2D graphics and 3D graphics in Android. This course provides the ideal primer for more advanced courses and applications, for example, OpenGL, as well as Virtual Reality in Android. This course is unique because it covers the key concepts and theory of 2D and 3D graphics while also showing you how to implement these in Android practically. This provides a solid understanding and grasp of the subject matter which will be applicable in a variety of settings. The final assignment will provide you with an artefact which you can use for your professional portfolio to evidence your skills.
Advanced CSS and Sass: Flexbox, Grid, Animations and More!
Have you been coding CSS for some time, but want to take your game to the next level? Do you feel confused with CSS jargon like inheritance, specificity, or the cascade? What if there was one resource, one place, where you could learn all the advanced and modern CSS techniques and properties you've been reading about? Good news: there is! Welcome to "Advanced CSS and Sass", the most advanced, the most modern, and the most complete CSS course on the internet. It's everything you want in an advanced CSS course, and more. You will learn complex CSS animations, advanced responsive design techniques, flexbox layouts, Sass, CSS architecture, fundamental CSS concepts, and so much more. Like in all my courses, you will build beautiful and carefully designed projects, that will make you proud of yourself and leave you ready to build complex projects on your own. After finishing this course, you will: 1) Be up to speed with the most modern and advanced CSS properties and techniques; 2) Have mastered the cutting-edge layout technologies Flexbox and CSS Grid; 3) Be ready to build responsive layouts for all kinds of devices and situations; 4) Truly understand how CSS works behind the scenes; 5) Be able to architect large CSS codebases for reusability and maintainability using Sass. Please note that this course is NOT for absolute beginners, so you should already be at an intermediate level in HTML and CSS (please check out my other course if that's not the case). This course is massive, coming in at 28+ hours. Here is exactly what you will learn: • Tons of modern cutting-edge CSS techniques to create stunning designs and effects: clip-path, background-clip, mask-image, background-blend-mode, shape-outside, filter, backdrop-filter, object-fit, transform, column-count, hyphens, perspective, calc() and custom CSS properties; • Advanced CSS animations with @keyframes, animation, and transition; • Advanced CSS selectors, pseudo-classes, and pseudo-elements required for modern CSS development; • How CSS works behind the scenes: the cascade, specificity, inheritance, value processing, the visual formatting model, the box model, box types, positioning schemes, and stacking contexts; • CSS architecture: The 7-1 rule, component-based design, the BEM methodology, writing reusable, maintainable, and scalable code; • Introduction to Sass: variables, nesting, partials, imports, mixins, functions, extends, and more; • Using Sass in real-world projects: setting global variables, building for reusability, architecting CSS, and managing media queries; • The NPM ecosystem: setting up a development process to compile Sass and automatic browser reload, and creating a build process to concatenate, prefix, and compress CSS files; • Modern responsive design: fluid grids, layout types, flexible images, using media queries to test for different screen widths, pixel densities, and touch capabilities; • Advanced responsive design workflows: mobile-first vs desktop-first strategies, selecting breakpoints, em vs rem units and feature queries to test for browser support; • Responsive images in HTML and CSS for faster pageloads: resolution switching, density switching, art direction; • SVG images in HTML and CSS: how and why to use SVG, generating SVG sprites, changing SVG colors in CSS and best practices; • Videos in HTML and CSS: building a background video effect; • Flexbox layouts: main concepts, introduction to both flex container and flex item-specific properties, advanced positioning techniques applied to a huge real-world project; • CSS Grid layouts: main concepts, CSS grid vs flexbox, and layout techniques applied to a real-world project. This part alone could be an entire course! Why should you take this course? So you saw that the course is absolutely full-packed with content. But maybe you're still not sure if you should actually learn advanced CSS? That's probably because CSS is so easy to get started with. In fact, most developers highly underestimate the importance and power of CSS. But nothing could be further away from the truth! CSS is what makes our design come to life. And there is so much we can do with it! Mastering advanced techniques like flexbox, CSS grid, and animations, will give you an edge over many CSS developers out there who still use outdated methods. Plus, CSS can become a real nightmare when you try to master it, and when you have to maintain large projects. So having a good grasp on fundamental concepts is an absolute must for any serious front-end developer. And this course will help you with all that! So, should you take this course? The answer is most likely a big YES! And I packed so much content into this course, that no matter if you're just starting out, or if you're already an experienced front-end developer, there is definitely gonna be something for you in this course. And this is what you get by signing up today: • 28h of Up-to-date HD-quality videos, that are easy to search and reference (great for Udemy Business students) • Professional English captions (not the auto-generated ones) • Downloadable design assets + starter code and final code for each section • Downloadable slides for theory videos (not boring, I promise!) • Free support in the course Q&A • Lots of small challenges are included in the videos so you can track your progress. If you're still with me at this point, then please watch the promo video to take a look at the course projects, and I promise you will be amazed :) After that, I hope to welcome you as a new student in my course. I'm sure you're gonna love it!
Advanced Kubernetes: Monitoring & Troubleshooting
Advance your Kubernetes expertise with a focus on high availability, monitoring, disaster recovery, and real-world troubleshooting. Prepare to tackle complex operational challenges in production environments. This course covers advanced operational topics in Kubernetes, including high availability, load balancing, and resilient cluster design. Learners will explore monitoring best practices, backup strategies, disaster recovery planning, and in-depth troubleshooting techniques for common and advanced issues. The course also addresses common mistakes, technical communication, and real-world interview scenarios to help you excel in demanding technical roles. By presenting real-world scenarios, common pitfalls, and expert insights, this course empowers learners to confidently manage, monitor, and troubleshoot Kubernetes clusters. The approach emphasizes practical knowledge and interview readiness for advanced operational topics. This course is part three of a three-course Specialization designed to build a complete and cohesive understanding of the subject. While it offers valuable skills on its own, you'll gain the most benefit by progressing through all three courses as a structured learning journey. This course is based on Cracking the Kubernetes Interview, by Viktor Vedmich and Alexander Dovnar. Packt is one of the world's most prolific publishers of cutting-edge technical content. For over two decades we've made it our mission to curate and publish the knowledge of only the very best technical experts. We focus on real-world courses that help our customers get the job done, with coverage that extends across a wide range of established and cutting-edge technical topics. If you're an individual or an organisation that embraces learning by doing, Packt is the perfect fit for you.
Unreal engine 5:Advance locomotion system ALS (Intermediate)
Have you ever wondered why your game animations don't quite reach the polished level of AAA titles like Alan Wake 2? It's all about the system behind the scenes called ALS, or Advanced Locomotion System. In this course, we delve into the intricacies from the ground up, starting with idle animations. We progress through cycle animations, utilizing the latest features of Unreal Engine to ensure seamless transitions with precise distance matching. Additive animations bring a natural sway to characters while walking or jogging. Pivot animations enhance the fluidity of sudden direction changes, followed by a deep dive into turn-in-place systems for lifelike motion. We cover crouching mechanics, master jumping animations for smooth execution, and synchronize all movements seamlessly with sync groups. Moving onto firearm mechanics, we employ layered systems for organized code, coupled with advanced foot tracing techniques for realistic ground interaction. Weapon animations, including reloading and firing sequences, are meticulously crafted. Audio immersion is key, adjusting footstep volume dynamically based on character speed, while visual effects like impact reactions and muzzle flashes add depth to the experience. UI elements, inspired by modern designs, provide vital information about ammunition and health status. Pickup systems are modularized for flexibility, while landscape and procedural content generation are explored in-depth. Meet the formidable Kraken enemy, boasting a variety of attacks and behaviors. But mastering these techniques isn't without guidance. Learn advanced debugging methods, from visual aids like arrows to blueprint organization tricks. Join our vibrant Discord community, where myself and fellow enthusiasts, like Max, are on hand to offer support and insight. Embark on this journey with us and unlock the secrets to elevating your game animations to AAA standards. Let's begin together
Entity Framework Core - A Full Tour
Updated in May 2025. This course now features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. Master Entity Framework Core and build efficient data-driven applications with this comprehensive course. You'll learn how to set up your environment, create and manage data models, interact with databases, and optimize performance using EF Core’s powerful features. Whether you're new to EF Core or looking to refine your skills, this course will guide you through essential concepts and advanced techniques. You'll start with the fundamentals, including installing the necessary tools, setting up projects in Visual Studio, and understanding the database context. Then, you'll dive into querying data using LINQ, tracking changes, and performing CRUD operations. You'll explore database migrations, relationships, and data manipulation strategies to ensure seamless integration with your applications. As you progress, you'll work with raw SQL, stored procedures, and ASP.NET Core integration, gaining practical insights into EF Core’s advanced capabilities. You'll also cover performance optimization techniques, data validation, concurrency handling, and transaction management. These lessons will equip you with the knowledge to handle complex real-world scenarios. This course is ideal for developers, software engineers, and database administrators looking to enhance their .NET data access skills. A basic understanding of C# and relational databases is recommended but not required. Whether you're a beginner or an experienced developer, this course will help you harness the full potential of Entity Framework Core.
EssentialSQL: Data Modeling & Relational Data Architecture
This course is perfect if you're looking for entry-level course to learn data modeling and relational database table design. Its singular purpose is to teach you relational database logical design using simple to understand English. We'll walk though modeling requirements, building the conceptual data model, and logical database model. Finally we create scripts to create the physical tables. If you looking to understand data architecture, then you'll find this course very practical! Join me as we work through Lou's, the owner of several pizza shops, to model, design and create a database he can use to track is business. In this Course you will Learn to: • Create a conceptual data model based on Lou's Pizza Shops' requirements. • Use ER (Entity-Relationship) diagrams to model and design database tables and relationships between one another. • Appreciate and design around data modification anomalies. • Identify a properly formed database table. • Answer common interview questions related to relational database normalization and data architecture. • Spot a poorly designed table. • Communicate with others about table design. • Finally understand those confounding normalization rules! • Identify database normalization issues within our design and know how to fix them. • Use an ERD (Entity Relationship Diagram) to create database scripts. Nothing is worse than • Being excited to learn something new but not knowing where to start. • Wasting time learning the wrong features. • Being overwhelmed with options and not know which to use. Imagine Having... • Knowledge - Knowing how to quickly understand database design to take your SQL to the next level. • Confidence - Feeling good that you’re on the right track. • Accomplishment - Having a sense of accomplishment that you've learned something most cannot. • Fun - Having fun learning databases! By the time you’ve completed this course you’ll be able to design and implement relational databases using tables, keys, relationships, and SQL commands in MySQL, PostgresSQL, and SQL Server to meet user and operational needs.
Software Project Management Skills
Learn how to analyze, plan, and manage software projects effectively using industry-aligned project management frameworks, Agile methodologies, scheduling techniques, and leadership practices. This course provides practical skills for managing software development projects from initiation through successful delivery. The course begins with the foundations of software project management, including project lifecycle models, PMBOK, CMMI, Agile, and Rational Unified Process (RUP). Learners will understand how modern software development methodologies support structured project execution and adaptability in dynamic environments. As the course progresses, learners explore software risk management, including identifying, analyzing, and mitigating project risks while integrating time management practices to improve planning efficiency. The course also covers scheduling techniques, critical path analysis, and software quality management to help ensure successful project outcomes. Advanced modules focus on scope management, change control, stakeholder engagement, leadership, and team management. Learners will understand how to control scope creep, manage software project complexity, motivate teams, and improve collaboration in high-pressure environments. The course also introduces advanced project management practices such as software asset management and software process models, helping learners build a comprehensive understanding of modern software project environments. What makes this course unique is its integrated, end-to-end approach to software project management, combining technical planning, risk management, quality control, leadership, and stakeholder communication into one practical learning experience. By the end of the course, learners will be able to confidently manage software projects, improve team productivity, and handle project challenges effectively in professional software environments.
Practical Deep Learning: Master PyTorch in 15 Days
Have you ever watched AI automatically classify images or detect spam and thought, “I wish I could do that”? Have you ever wondered how a spam filter works? Or do you want to master Deep Learning in a hands-on way? With this course, you’ll learn how to build and deploy your own deep learning models in just 15 days - gaining practical, hands-on experience every step of the way. Why This Course? From day one, you’ll get comfortable with the essential concepts that power modern AI. No fluff, no endless theory - you'll learn by building real-world projects like Spam filters, or image detections. By the end, you won’t just know what neurons and neural networks are - you’ll be able to train, refine, and apply them to projects that truly matter. Who Is This Course For? • Absolute beginners eager to break into the world of AI and deep learning. • Data enthusiasts who want to strengthen their portfolios with hands-on projects. • Developers and data scientists looking to deepen their PyTorch and model deployment skills. • Anyone who craves a clear roadmap to mastering deep learning, one day at a time. What Makes This Course Unique? • Day-by-Day Progression: Follow a structured, 15-day plan that ensures you never feel lost or overwhelmed. • Real-World Projects: Predict used car prices, detect spam in SMS, classify handwritten digits, recognize fashion items—all using deep learning techniques. • Modern Tools & Frameworks: Master industry-standard tools like PyTorch and dive into CNNs, transfer learning with ResNet, and more. • Practical Deployment: Learn how to turn your trained models into interactive apps with Gradio, making your projects truly come alive. By the End of This Course, You Will: • Confidently implement, train, and evaluate deep learning models. • Understand how to prepare and process various types of data, from text to images. • Know how to improve and optimize your models to achieve better performance. • Be ready to deploy your AI solutions, making them accessible and interactive for real users. No Prior Experience Needed Whether you’re a coding novice or a data analyst stepping into AI, this course starts from the very basics. You’ll be guided through installing Python, PyTorch, and setting up your coding environment, all the way to training full-fledged neural networks on your GPU. Get Ready to Dive In If you’ve always wanted to get into deep learning, now is your chance. Enroll today and join me on a practical, hands-on journey that will transform the way you see and build AI solutions. In 15 days, you’ll have gone from curious beginner to proud deep learning practitioner—with real projects to show for it.
Diseñar una experiencia del usuario de una iniciativa de interés público y prepararse para el trabajo
Diseñar una experiencia del usuario de una iniciativa de interés público y prepararse para el trabajo es el séptimo y último curso de un programa que te brindará las habilidades que necesitas para convertirte en un diseñador de UX de nivel básico. En este curso, diseñarás una aplicación móvil dedicada y un sitio web adaptable centrados en una iniciativa de interés público. Podrás mostrar lo que aprendiste durante el programa de certificación para realizar el proceso de diseño de principio a fin: empatizar con los usuarios, definir sus dificultades, proponer soluciones de diseño, crear prototipos y esquemas de páginas, y probar diseños para recopilar retroalimentación. Al final de este curso, tendrás un proyecto de diseño multiplataforma nuevo que podrás incluir en tu portfolio profesional de UX. Con este curso, te prepararás para obtener tu primer trabajo como diseñador de UX. Además, te prepararás a fin de presentarte en entrevistas para puestos de diseñador de UX de nivel básico, accederás a consejos de Googlers en función de sus propias experiencias en entrevistas y conocerás sus puntos de vista únicos en calidad de gerentes contratantes. Por último, podrás pulir el portfolio profesional de UX que desarrollaste durante el programa y dejarlo preparado para presentarlo en solicitudes de empleo. En el curso, que dictarán personas que trabajan actualmente como diseñadores e investigadores de UX de Google, realizarás actividades prácticas que simulan escenarios reales de diseño de UX. Los alumnos que completen los siete cursos de este programa de certificados adquirirán las habilidades necesarias para solicitar trabajos de nivel básico como diseñadores de UX. Al final de este curso, podrás hacer los siguiente: - Aplicar cada paso del proceso de diseño de UX (empatizar, definir, idear, crear prototipos y probar diseños) para crear diseños centrados en una iniciativa de interés público. - Identificar las diferencias entre las aplicaciones móviles dedicadas y las aplicaciones web adaptables. - Comprender los conceptos de mejora progresiva y degradación agraciada para el diseño en diversos dispositivos. - Desarrollar esquemas de páginas, maquetas y prototipos de alta y baja fidelidad en Figma y Adobe XD. - Agregar un proyecto de diseño nuevo a tu portfolio profesional de UX. - Preparar tu portfolio de trabajos de diseño para presentarlo en solicitudes de empleo. - Presentarte en una entrevista para un trabajo de diseño de UX de nivel básico. - Determinar si trabajar de manera independiente en proyectos de diseño es adecuado para ti. Este curso está destinado a diseñadores de UX de nivel básico que hayan realizado los seis cursos previos del Certificado de diseño de UX de Google.
Blender 3D: Hard Surface Modelling
Want to get seriously good at 3D art - and have fun doing it? This course is all about levelling up your Blender skills so you can build awesome models and feel confident creating your own stuff from scratch. You'll build a stylised car, from scratch. All while gaining the tools and techniques to model anything you can imagine - from sci-fi props to whole game worlds. Learn how to plan your models properly, use Blender’s modifier stack like a boss and create clean, flexible geometry that’s easy to edit and looks amazing. We’ll cover pro workflows like edge flow, support loops, and non-destructive modelling - so you're not just following along, you're learning how to think like a 3D artist. By the end, you’ll have a finished model you’re proud of - and the skills to start building your own vehicles, environments, robots… whatever your creative brain comes up with. What you’ll learn: • Build a stylised car while learning solid modelling workflows • Master Blender’s modifier stack for non-destructive modelling • Create clean edge flow with bevels, creases, and support loops • Learn how to refine and add detail without making a mess • Shade, light and render your final model like a pro • Gain the confidence to model whatever you imagine next You don’t need to be an expert. If you’ve played around with Blender and know the basics, you’re ready. Already done the Blender Creator course? Even better - this is your next step. Ready to level up your modelling skills? Jump in and get started today.
Official Next Js Tutorial Code Along - React Web Development
This course features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. Are you ready to master Next.js and React web development? This course is designed to guide you through the process of becoming proficient in building dynamic, high-performance web applications. From the basics of web development to advanced concepts in Next.js, you will be exposed to every step of the journey. Along the way, you'll gain practical experience through hands-on projects and code-along examples. The course starts with an introduction to foundational web development concepts such as HTML, CSS, and JavaScript. Once you’re comfortable with the basics, you’ll dive into React, learning how to write components, manage state, and utilize hooks to enhance your app’s functionality. As you progress, you'll migrate from React to Next.js, understanding server-side rendering (SSR), static site generation (SSG), and client-side rendering (CSR). Each lesson builds upon the last, ensuring a smooth learning curve while also reinforcing key concepts. The course is designed to provide you with the necessary tools to confidently build, deploy, and optimize full-stack applications using Next.js. You’ll gain insights into performance optimization techniques like code splitting, prefetching, and dynamic routing, as well as working with metadata and assets. By the end of the course, you'll be equipped to deploy a fully functional Next.js app with real-world features, preparing you for professional development tasks. Who will benefit from the course? This course is perfect for beginners with a basic understanding of web development, as well as React developers who want to elevate their skills with Next.js. There are no advanced prerequisites, but familiarity with HTML, CSS, and JavaScript is recommended. This course is ideal for aspiring front-end developers, full-stack developers, and anyone looking to learn modern web development tools and techniques. By the end of the course, you will be able to build and deploy production-ready Next.js applications, integrate dynamic content with React, optimize your app's performance, and leverage modern web development techniques in a professional setting.
Salesforce Integration Masterclass - 2026 Updates
Course Format Notice Some of the sections in this course are pre-recorded from live training sessions. As the sessions focus on detailed explanations, practical demonstrations, and real-world discussions, video durations may vary from 1 to 3 hours. If you prefer deep-dive learning with classroom-style teaching, this course will be a great fit for you. As we are living in a world where everything is related to each other and collaboration is a key thing to succeed. This course is designed to learn Salesforce Integration from the very beginning and then advanced to Advance Salesforce Integration. In this course, you will be able to learn every basic information about Salesforce Integration. By integrating Salesforce with other applications, organizations can now tap to vast unknown resources and provide them with much greater operational visibility. This course leverage all types of Authentication that can be used while integration with any third-party system including API Key, Basic, OAuth 2.0, OAuth 1.0, JWT &, etc. In this course, you will also learn how to use different API REST & SOAP, which is best in which case. At the end of the course, you will be able to write any kind of integration for sure. Course Format Notice The videos in this course are pre-recorded from live training sessions. As the sessions focus on detailed explanations, practical demonstrations, and real-world discussions, video durations may vary from 1 to 3 hours. If you prefer deep-dive learning with classroom-style teaching, this course will be a great fit for you. Note: - The course contains a Major project to Integrate Salesforce with the AWSS3 system. Bonus:- • You will get the PPT of each lecture • Code related to each lecture • New Videos will be added in the coming future related to other integration topics • Plenty no of Assignments for you to practice the integration • Live Project implementation along with me • Course Completion Certification • Multiple Assignments are there for most of the sections.
Next.js 14 from Scratch
Updated in May 2025. This course now features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. This comprehensive course is designed to equip you with the skills needed to build modern, high-performance web applications using Next.js 14. You'll learn how to create dynamic websites with ease, leveraging server-side rendering, API routes, and authentication systems. By the end of the course, you'll be able to develop and deploy a full-stack property rental platform. The course begins with a deep dive into the fundamentals of Next.js, including understanding its core features, setting up your development environment, and building a project from scratch. You'll start by creating a property rental website, PropertyPulse, and will walk through essential Next.js features such as file-based routing, components, and conditional rendering. As the course progresses, you'll learn how to integrate a MongoDB database, set up API routes for CRUD operations, and implement advanced features like user authentication with Google OAuth. You'll build a robust backend using Mongoose to handle database interactions and explore the creation of dynamic property pages, bookmarking, and messaging functionalities. This course is ideal for developers with some basic understanding of JavaScript and React who want to take their skills to the next level with Next.js. You'll learn practical techniques for building, managing, and deploying full-stack applications, including integration with external tools like Cloudinary and Vercel. If you're interested in developing modern web applications, this course offers an in-depth and hands-on experience.
Hibernate and Spring Data JPA: Beginner to Guru
Hibernate is the default JPA implementation used by Spring Data JPA. NOTE: Java 17 and Spring Boot 3 are required for this course. JPA stands for Java Persistence API. This is a common Java API used to work with Relational Databases. Spring Data JPA is an abstraction built on top of the JPA API specification. Being an abstraction, Spring Data JPA makes working with database entities very efficient. Spring Data JPA eliminates a lot of the boilerplate / cerimonial code, and allows developers to focus on developing business logic. The downside of the efficient abstraction is that accessing the database can become a mystery. Developers who just understand how to use Spring Data JPA do not understand the complexities of JDBC and Hibernate. You will start this course with a basic demonstration of Spring Data JPA. In this section you will learn how to work with a H2 in-memory database. You'll see how easy it is to work with Spring Data JPA. You will also begin to understand how the Hibernate interaction is being abstracted away. Since JPA is the Java API for working with Relational Databases, the course takes a closer look at Relational Databases and MySQL specifically. MySQL is the most popular open source relational database in the world. You will learn how to configure Spring Boot to test with a H2 in-memory database and to run integration tests against a MySQL database. This is a common real-world example leveraging the power of Spring and Hibernate to give you a very flexible environment. Once we've established a persistent database, we can explore using database migration tools. Liquibase and Flyway are two very popular database migration tools. Spring Boot supports both options. And you will learn about both options and database security best practices. By establishing a MySQL database, Spring Boot Integration Tests, and automated database migrations we can use Test Driven Development to explore the features of JDBC and Hibernate. In the course you will learn: • What is the DAO pattern, and how to implement it using JDBC, Spring's JDBCTemplate, and Hibernate • Relational Database Principles • Schema Creation in MySQL • Schema Generation using Hibernate • Database Migrations using Liquibase • Database Migrations using Flyway • Database Integration Testing using Spring Boot and JUnit 5 • Defining Primary Key's with Hibernate • Hibernate Criteria Queries • Named JPA Queries • Spring Data JPA query methods • Spring Data JPA @Query Annotation • Entity Relationships - One to One, One to Many, Many to One, Many to Many • Embedded Types • Natural Keys • Composite Keys • Spring Data JPA Query Methods • Paging and Sorting • Database Transaction Management • Database Fetch Operations • Data Validation • JPA Inheritance • Hibernate Interceptors and Listeners • JPA Callbacks • Legacy Database Mapping • Using Multiple Data Sources • Spring Data REST Learn Hibernate and Spring Data JPA - Enroll today!
Create & Animate 3D Broadcast Graphics in Cinema 4D
Learners will design a stylized 3D cityscape, refine architectural detail, animate dynamic textures, and craft cinematic camera sequences for broadcast-quality motion graphics. By completing this course, learners gain the practical skills to build polished 3D environments, develop professional animation workflows, and deliver visually compelling broadcast packages using Cinema 4D. This hands-on course walks learners through the complete production pipeline—from blocking out city structures and enhancing skyline depth, to optimizing scene organization and preparing assets for broadcast. They will also explore motion-driven texture design, advanced layering techniques, and multiview cinematic camera work, enabling them to produce seamless, high-impact motion graphics suitable for real-world broadcast scenarios. What makes this course unique is its industry-focused, project-based structure. Learners not only build a full city environment but also animate textures, rig mechanical elements, and direct camera motion like a broadcast designer. By the end, they will be confident in transforming complex 3D scenes into dynamic, professional broadcast compositions.
Unreal Engine 5 C++: Advanced Frontend UI Programming
In this comprehensive course, you’ll build a fully-featured, AAA-quality frontend UI system entirely from scratch using Unreal Engine 5’s Common UI framework and C++. From layered menus to full gamepad support, you’ll learn how to create immersive and modular interfaces designed for real-world projects. You’ll start by setting up the core UI foundation. We’ll create a primary layout widget, register widget stacks using gameplay tags, and implement asynchronous functions for pushing widgets onto the screen. Once that’s in place, you’ll build a responsive “Press Any Key” screen and display it using your new widget flow. Next, you’ll create a dynamic main menu system. We’ll use Common UI buttons backed by native C++ classes to add contextual button descriptions, action buttons, and a flexible confirmation screen. We’ll also ensure full gamepad support is seamlessly integrated. Along the way, you’ll learn how to structure UI features in a modular, reusable way for both Blueprint and C++ projects. Once the core menu is complete, you’ll move on to building a robust options menu. This system will feature tab buttons at the top, a detailed view panel on the right, and support for multiple settings categories including gameplay, audio, graphics, and input. You’ll learn how to combine data objects with Unreal’s Data Registry system to dynamically populate the UI. After setting up the structure, we’ll focus on functionality. You’ll implement logic to reset values to default, customize how list entry widgets are generated, and create a custom Game User Settings system to store and load player preferences from config files. With that foundation in place, we’ll dive into creating audio and video settings. You’ll add controls for adjusting window mode, resolution, shadow quality, frame rate limit, and more—while managing data dependencies and conditional logic properly for a clean, scalable architecture. Finally, you’ll implement startup and in-game loading screens that integrate seamlessly into your project’s UI flow, giving players a polished experience from launch to gameplay.
Java Core Review and Interview Guide
This course features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. Master Java concepts and ace your interviews with this comprehensive course, designed to review essential Java core topics. You'll dive deep into Java features from Java 10 to Java 24, including modularization, new APIs, pattern matching, and virtual threads. The course also covers in-depth Java interview preparation, focusing on key concepts like the JVM, memory management, garbage collection, and concurrency. You will also get a chance to explore advanced topics such as functional programming, collections, and thread safety. Throughout the course, you'll work through practical examples, learning how to apply Java's powerful features in real-world scenarios. The structured content ensures that you grasp essential concepts like object-oriented programming, exception handling, and Java platform fundamentals. By the end, you'll be well-prepared to tackle any technical interview or work on sophisticated Java projects. This course is ideal for developers looking to solidify their Java skills and for those preparing for Java-related job interviews. No prior expertise in advanced Java is required, but familiarity with basic Java concepts will help you progress smoothly. Get ready to take your Java knowledge to the next level!
The Ultimate Unreal Engine 2D Game Development Course
Welcome to The Ultimate Unreal Engine 2D Game Development Course. This is the most comprehensive and effective course you'll ever find about making 2D and 2D/3D hybrid games with Unreal Engine 5. Through teaching Unreal Engine on YouTube and also in person at a Japanese Game Dev school for the past couple of years I've gained an understanding of what students are really looking for and designed this course to teach you Paper 2D and PaperZD step by step in a structured manner. If you're completely new to Unreal Engine you can check out the Unreal Engine 5 Crash Course which is included in one of the early chapters. We'll start out slowly by making a one-button-minigame that teaches you about how to import sprites and use them in your scene. You'll also learn about project settings we need to adjust and about the enhanced input action system which we'll use throughout all of the other chapters in this course as well. The second game will teach you all about using sprite sheets and how we can create flipbooks. We'll also look at how to switch between the idle and run flipbook during gameplay and how to play footstep sounds on the correct animation frames. Since we want the background to be dynamically adjustable I'll also teach you how we can use a background sprite in a blueprint, attach collisions to them and dynamically change them in the construction script depending on how long we want the stage to be. The Third game is a classic platformer game and will be the first projects using the free PaperZD plugin to improve the workflow of making 2D games with Unreal Engine. Here you'll learn how to set up an animation source and animation blueprint file with PaperZD and use them to create animation graphs and animation notifies. We'll also create enemies that can detect walls and ledges to change the direction they walk in and can interact with the player when being stomped on or touching the player character. You'll also learn how to create a one-way platform that we can jump through form the bottom, but don't fall through from the top. The forth game will combine all the things we've learned and will be the first 2D/3D hybrid game we create. This means that our characters are 2D pixel art, however the backgrounds are 3D environments which allow us to make use of all of the amazing features of Unreal Engine. For this game we don't only have platformer mechanics, but we'll also implement hitboxes, a stun system a damage system and many more things you'll need to know about for most of your games. To lean into metroidvania mechanics we also create an unlockable sword throw ability, which allows you to stick swords into the wall and use them as platforms to reach higher areas.
Diseño de sitios web y ciberseguridad
Domina los fundamentos del diseño web y la ciberseguridad con este curso introductorio. Aprende HTML desde su sintaxis básica hasta las etiquetas esenciales, creando páginas web bien estructuradas con encabezados, párrafos, listas y enlaces. Incorpora imágenes, videos y elementos interactivos como formularios y botones para enriquecer la experiencia del usuario. Mejora la accesibilidad y el SEO de tus páginas web utilizando etiquetas semánticas. ¿Por qué tomar este curso? Este curso te ofrecerá conocimientos prácticos y actualizados sobre diseño web y ciberseguridad, ideal para principiantes. Conocerás la importancia de la usabilidad, accesibilidad y el diseño responsivo; comprenderás tecnologías esenciales como HTML y CSS, y aprenderás a gestionar contenido con CMS como WordPress. Además, te familiarizarás con el diseño centrado en el usuario, garantizando experiencias web atractivas y funcionales. Finalmente, podrás identificar amenazas cibernéticas comunes, proteger tus datos personales y entender cómo funcionan los principales elementos de la seguridad en línea. Dirigido a una audiencia global, es perfecto para principiantes, futuros desarrolladores y cualquier persona interesada en crear sitios web. Este curso te preparará para enfrentar los desafíos del entorno digital actual y te proporcionará las herramientas necesarias para iniciar tu carrera en el campo del diseño web y la ciberseguridad.
Complete Kotlin development masterclass
This course is a unique experience on Udemy. There are loads of Kotlin resources online to choose from, but this is the only course that takes you from a complete beginner in software development, teaches you the fundamentals, advanced topics, and makes you an expert in this field. In addition, you have loads of practice exercises, challenges and projects to work on. I didn't just add a bunch of exercises at the end. Instead, each concept is put in code and practiced so that we make sure you apply and learn everything through action. You get over 30 hours of on-demand videos, exercises and most importantly projects to apply the knowledge we talk about. I've spent years building applications in Kotlin, and years again teaching people how to build code for themselves. This is the most complete course I've ever done, and it's all to help you on your journey to become an expert developer. We will cover basic topics such as • language fundamentals • collections • flow control • loops • handling errors and exceptions • functions • packages As well as advanced topics such as • Object Oriented Programming • Principles of development • Standard functions • Types of classes • Extensions • Generics • Coroutines And we will put everything in practice through examples and projects. If you want to take ONE COURSE to master Kotlin take this course.
Build and Deploy a Drupal CMS Website for an Ad Agency
By completing this course, learners will be able to analyze real-world business requirements, design a structured CMS website, implement dynamic content sections, and deploy a complete advertisement agency website using Drupal. Learners will gain practical experience in building professional website components such as headers, menus, banners, team sections, services, portfolios, pricing layouts, blogs, testimonials, contact forms, and footers within a CMS-driven environment. This course guides learners step by step through the full lifecycle of a Drupal project, beginning with project planning and a case study and progressing through content development, visual structuring, and final website deployment. Each module focuses on hands-on implementation, ensuring that learners not only understand Drupal concepts but also apply them directly in a real project context. What makes this course unique is its end-to-end, project-based approach, where learners build a complete advertisement agency website from scratch rather than working with isolated examples. By the end of the course, learners will have a fully functional CMS website and the practical skills required to design, manage, and customize Drupal-based business websites confidently.
Create a Complete Grid-Based Puzzle Game in Godot 4 with C#
This course will cover everything you need to know about creating a small 2D grid-based puzzle game from start to finish in the Godot Engine 4.3+ using C# scripting. This course covers many aspects of creating a grid-based puzzle game including: • Building placement on a grid with variable tile sizes • Querying grid state using LINQ with C# data structures like HashSets and Dictionaries • Creating levels using the new Godot 4.3 TileMapLayer, including multi-level maps with y-sorting, animated tiles, and custom tile data • Saving and loading level completion progress • Implementing audio including building placement and destruction effects and music This list is not exhaustive - please see the course outline for a glimpse into the topics that are covered. The goal of this course is to show you how to take an empty project and turn it into a small, complete game. In doing so, this course will give you a robust exposure to many aspects of the Godot engine from C# scripting, to input handling, to tile maps, to saving and loading data, to audio, and more. By the time you complete this course, you will feel comfortable working on your own projects in Godot 4.3+ and C#. You will walk away from this course with a solid foundational understanding of making games that are not only functional but also fun. This course will help you greatly if: • You are ready to dive into a crash course for Godot 4.3+ with C# • You are comfortable in Unity and want to transfer your C# scripting skills to Godot • You have some game development knowledge and want to learn Godot • You have some programming knowledge and want to make games • You struggle to complete games and want to start and finish a project Please note that this course is focused purely on the start-to-finish process of making a grid-based puzzle game. With that goal in mind, there is no time spent explaining fundamental programming concepts of statically typed languages. Familiarity with programming and statically typed languages is strongly recommended before taking this course. Several lessons are available to for you to preview for free. Please take a look at those videos before enrolling to determine if the pace of this course is right for you!
Introduction to Test and Behavior Driven Development
Successful developers need to not only build the right software but build it right. To know your software works correctly, you need to test each unit of code. One of the best methods for this unit-level testing is test driven development. This course provides a detailed overview of test driven development (TDD). First, you’ll learn what automated testing is and why it is essential for building robust applications resilient to failure. You’ll explore the basics of testing, including test cases, testing levels, and the traditional release cycle. You’ll learn about TDD and its complement, behavior driven development (BDD): TDD tests individual units of code while BDD tests how these units work together. Then you’ll examine TDD in detail. You’ll explore TDD’s benefits, concepts, and popular tools, and you’ll hone your new testing skills through hands-on labs. You’ll create TDD test cases by writing test assertions and building test fixtures, and you’ll run these test cases by using the Nose testing package. You’ll then practice more advanced TDD methods such as increasing code coverage, generating and using fake data, and testing mock objects.
Master Redis - From Beginner to Advanced, 20+ hours
Redis Data Structures? Yes, Publish/Subscribe models? Yes, Replication/Clustering? Yes, Lua Scripts? Yes Database Designs? Yesindeed and much more... I've design this course from step-by-step move from basic to advanced topics. Here is a partial list of some of the topics that are covered in various sections for 18+ hours videos of this course: • The course is design based on the latest version i.e. Redis 6.2 • Deep dive into Redis Data Structures to store, update and retrieve information • Step-by-step walkthrough to perform simple to complex queries • How to create a data structure from the scratch, Creating and modifying data structure • Walks you through examples that demonstrate how to use it effectively • You'll begin by getting Redis set up properly and then exploring the key-value model • Explore various data types and commands in Redis • Learn Redis data structures through practically demonstrated use cases • Detail examples on working with Strings, Lists, Sets, Sorted Sets, Hashes, Bitmap, HyperLoglogs data structures • Dive into real use cases including simple caching, distributed ad targeting, and more • Understanding TTL (Time to Live) or Key Expiry in Redis • Publish/subscribe and configuration • Manage data replication and persistence in Redis • Administering your Redis Database • Advanced aspects of Redis high availability and clustering • Scale Redis to multiple servers with Redis Cluster • Setting up Redis Replication (Master + Slave) - Development or Demo Scenario • Database Design from RDBMS tables to Redis Database Structures • Best practices, tips and tricks, and expert techniques to scale Redis • Whats new in Redis 6.2 • Learn Lua Scripting for interacting with data structures, apply EVAL commands and more. • Extend Redis with Redis Module • Deep dive into RediSearch to perform complex Searches • Use RedisInsight to view Redis database visually • Use RedisJSON to build JSON based document solutions • Understand how Redis enterprise enhances Redis EchoSystem This comprehensive course will teach you everything about Redis to use in your next big project! Master the Redis database, and see how to apply it with real world database and queries. This course comes with 30-day money back guarantee! So Sign up today and master Redis!
Apply Object-Oriented Programming to Build Organograms
Learners will understand, apply, and analyze object-oriented programming concepts in C++ to model real-world organizational structures using organograms. By the end of this course, learners will be able to design class hierarchies, implement inheritance-based relationships, execute and validate programs, and visualize organizational logic through structured output. This course provides a hands-on, practical approach to mastering C++ OOP by focusing on a real-world use case rather than isolated syntax. Learners gain clarity on how base classes and derived classes work together to represent hierarchical roles, how multiple inheritance can introduce complexity, and how execution and visualization confirm logical correctness. Step-by-step coding demonstrations help bridge the gap between theory and implementation. What makes this course unique is its problem-driven learning model, where learners build a complete organogram program from scratch, reinforcing concepts through continuous application. Instead of abstract examples, the course emphasizes realistic organizational modeling, helping learners develop transferable design skills. This structured, practical methodology makes the course ideal for students and professionals seeking to strengthen their object-oriented thinking and apply C++ effectively in real-world scenarios.
Introduction to AI and Machine Learning with Go (Golang)
Are you a Go developer ready to explore the exciting world of AI and machine learning? This course is your comprehensive guide, designed specifically for Gophers who want to add powerful AI skills to their toolkit. Much of the code in this course is written in Go, but some of it is written in Python, where it makes sense to do so, and this means that before taking this course you should have a basic understanding of both languages. We'll start with fundamental AI concepts, building a strong foundation with practical, hands-on projects. Then, we'll dive into the world of machine learning, tackling everything from classic regression models to modern neural networks. You'll learn how to leverage Go for high-performance AI applications, and discover how to integrate it with Python and cutting-edge tools like Hugging Face and LLMs for state-of-the-art solutions. What You'll Learn • Search Algorithms & Intelligent Agents: Master core AI search algorithms like A* and Dijkstra's by solving mazes and building a robot vacuum. • Propositional Logic & Model Checking: knowledge based AI agents often need to make decisions based on available information in the world they operate in. Propositional logic and model checking are two different approaches to solving this problem. • Uncertainty: Learn how AI agents handle randomness by creating a Battleship AI and a card-counting Blackjack player. • Machine Learning Fundamentals: Get a practical understanding of linear regression by building models in both Python and Go to predict housing prices. • Deep Learning & Neural Networks: Build a neural network from scratch for housing price prediction and a Convolutional Neural Network (CNN) for image classification. • Natural Language Processing (NLP): Discover the power of NLP by creating an extractive summarization program in Go. You'll also learn to interface with external models from Hugging Face and harness the power of Large Language Models (LLMs) to create hybrid summarization systems. • Large Language Models (LLMs): Learn how to connect your Go programs to Large Language Models like ChatGPT. We'll use a locally hosted LLM using Ollama, but the code we write will be 100% compatible with OpenAI, which is used to connect to most LLMs. Course Requirements This course is for intermediate to advanced Go developers. You should be comfortable with Go syntax and core concepts. A basic understanding of data structures like graphs and trees is also helpful, but not required. You should also have a basic understanding of Python. All you need is a computer running Windows, macOS, or Linux. While a GPU will speed up certain deep learning tasks, it is not essential; everything will run on a CPU. Why This Course? This isn't just another machine learning course; it's tailored for Go programmers. You'll learn how to build production-ready AI and machine learning applications that leverage Go's performance and concurrency. By the end, you'll have a portfolio of projects and the skills to confidently build your own intelligent applications. Ready to build the future of AI with Go? Enroll now and start your journey!
Data Manipulation in JavaScript
This course builds on the skills from the previous course and goes further into managing and manipulating data with JavaScript. You will learn methods for validating and handling data provided by users or coming from an external data source. This course includes a challenge in the form of a seat reservation system, as well as a project that pulls data in from an external data source. The course objectives include validation basics in JavaScript and jQuery; jQuery form validation plugin features; arrow functions; asynchronous functions; and the JavaScript event loop.
Microservices with Node JS and React
Event-Based Architecture? Covered! Server side rendering with React? Yep. Scalable, production-ready code? Its here! This course requires you to download Docker Desktop from Docker. If you are a Udemy Business user, please check with your employer before downloading software. Microservices are the number one solution for building and scaling out apps that are intended to grow. Just one little issue: there are few resources online that delve into the most complex and nasty issues around them! I built this course to fix that. This course tackles every major issues around microservices head on. From challenges with data replication to confusing unordered event streams, every major challenge of building microservices is covered. Beyond focusing on the basics of microservices, this course is a perfect introduction to the world of full-stack development. You will work all the way from the frontend, assembling a React app using Hooks, to the backend, including database design and deployment strategies. Every step along the way is covered in tremendous detail, with ample diagrams to ensure every step is crystal clear. Many other resources show only the easiest, simplest apps written with microservices. This course does the opposite: we focus on the most challenging aspects of microservices, challenges that you will likely encounter every single day. You will see these difficulties first hand, then solve them with easy-to-understand strategies. How This Course Works This course doesn't focus on using an off-the-shelf microservices framework. Many exist, but they hide the inner workings and challenges of microservices away from you. Instead, we will be using a minimal number of libraries, and write as much custom code as possible. This will expose you to challenging problems and clever solutions when handling subjects like async events! What Technology You'll Use Because we are building a full stack application, we will use a variety of technologies. On the frontend, we'll use React and Next JS to present content to users. Each service is created using Node and Express. Data for each service is held in either a Mongo database or Redis. The entire app is deployed and runs in Docker containers executed in a Kubernetes cluster. Finally, almost all of the code in this course is written with Typescript. This is a scary list of technologies! Not familiar with some of these? No problem! The course is built assuming that you only know the basics of Javascript and Express. No other knowledge is needed - you will learn everything you need to know. What You'll Be Able to Do By the time you complete this course, you will be able to: • Architect a multi-service application • Determine whether your app is a good fit for a microservices approach • Understand and solve the challenges in async, event-based communication between services • Use Docker and Kubernetes to deploy a multi-service app to any cloud provider • Organize and enhance the reusability of code in large projects What You'll Learn An absolute incredible number of topics are covered in this course. Here is a partial list of what you'll do: • Practice patterns to create scalable microservices for a variety of app domains • Build a Server-Side-Rendered React app using Hooks and Next JS • Write a custom implementation of an event bus • Optionally, run a development environment through a cloud provider • Guarantee consistently structured responses from your different API's • See best practices in communication between different services • Configure and scale your services using Kubernetes Deployments • Document and enforce structure constraints on events shared across microservices • Limit access to your APIs using JWT-based authentication • And much more! This is the course I wish I had when I was learning microservices. A course that focuses on the hardest parts, gives clear explanations, and discusses the pros and cons of different design options. Sign up today and join me in mastering microservices!
Intermediate Jetpack Compose & Mobile App Development
This course features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. Unlock your potential in mobile app development by mastering Jetpack Compose and building fully functional, interactive apps. This course empowers you to create dynamic UI components, manage state efficiently, and implement smooth animations, preparing you for real-world Android development projects. You will begin by exploring the Mood Map app, learning how to set up projects, implement Scaffold layouts, navigation, floating action buttons, and integrate emoji pickers. Then, you'll progress through advanced UI elements, data visualization with charts, and reusable composables. Coding exercises and smaller projects reinforce these concepts, building confidence in applying them independently. Next, the course guides you through creating various apps including Greetings, Animations, and GeoBlur apps. You’ll learn best practices like MVVM architecture, ViewModel state management, JSON data handling, and custom UI components. Each project emphasizes clean code, responsiveness, and interactive design patterns. This course is ideal for developers with basic Kotlin knowledge aiming to elevate their Jetpack Compose skills. No prior advanced Android experience is needed, making it suitable for intermediate learners who want hands-on, project-based learning with clear guidance. By the end of the course, you will be able to design and implement interactive mobile apps using Jetpack Compose, manage state with ViewModel and StateFlow, create reusable UI components, and visualize data through custom charts and dynamic layouts.
The HTML & CSS Bootcamp 2026 Edition
**Modern in-depth HTML & CSS course!** ** Check out the promo video to see the beautiful, responsive projects we build in this course! ** This course will teach you everything you need to know about HTML, CSS, and web design to build your own stunning websites from scratch. Instead of just watching me code, you’ll learn how to structure and build any website you can think of. My background is in teaching in-person bootcamp programs around the world, where I work directly with students to help them learn web development and change careers. This course is based on all my experience in the classroom. Unlike most Udemy courses, this course includes dozens of exercises and challenges which ask you to recreate components, build layouts, and practice HTML and CSS. Practice is the most important tool I have to help you learn, and this course includes lots of it! This course covers a huge amount of information, but it’s designed to be approachable for complete beginners and intermediate developers alike. • We start with the basics of HTML: structuring documents, creating text elements, tables, and forms. Then we learn about semantic markup and creating accessible webpages • Next, we cover the basics of CSS: working with selectors, color systems, and styling text elements. • From there, we cover critical CSS concepts including the box model, specificity, the cascade, and CSS units. • Next you’ll learn all about backgrounds, gradients, filters, positioning elements, working with transitions and transformations, and many other more intermediate CSS properties. • We then spend nearly 10 hours learning how to create complex CSS layouts using Flexbox and CSS Grid. We then build multiple projects with complicated layouts. • You’ll learn how to build responsive layouts that look good on all screen sizes, from large desktops to tablets and mobile devices. • Finally, we wrap up the course with our massive final project that we build together from scratch. This project combines everything we’ve learned in the course into one huge website built with thousands of lines of HTML & CSS. Check out the promo video to learn more about the final project. This course includes: • Over 37 hours of high quality videos • Downloadable assets, starter coder, and solutions for all sections • Dozens of exercises, challenges, and quizzes • Downloadable slides and cheatsheets, including beautiful diagrams and syntax references • Included support in the course Q&A forums • Access to our exclusive discord community with thousands of students About me (your instructor) I’m a teacher with extensive real-world teaching experience. I’ve taught thousands of students how to code at my in-person coding bootcamps around the globe. My graduates work at companies including Google, Tesla, Apple, Airbnb, and pretty much any big company you can name. My in-person teaching background informs the online experiences I create for students. Unlike most Udemy instructors, I’ve actually taught this material in a classroom full of students for nearly a decade. I know what works and what doesn’t work!
Créer un diagramme de Brainstorming avec Creately
Ce projet vous permet de créer des diagrammes de Brainstorming avec Creately. Vous découvrirez la plateforme Creately, logiciel en ligne de conception de diagrammes. Vous comprendrez les diverses fonctionnalités de la plateforme et serez capables de créer des diagrammes de Brainstorming personnalisés et professionnels pour votre entreprise. Vous apprendrez à utiliser Creately pour créer des diagrammes de Brainstorming variés et professionnels. Ce projet est destiné aux petites et moyennes entreprises.
Modern Event-Driven Spring Boot: Kafka & Spring Cloud Stream
The course has been completely re-recorded in 2026 for Spring Boot 4 and modern KRaft-powered Apache Kafka 4. Build production-ready event-driven microservices using Apache Kafka and Spring Cloud Stream from fundamentals to advanced patterns, testing, security, and a complete real-world project. This course is designed for backend developers who want a practical, no-fluff path to mastering event-driven architecture with Spring Boot. What you will learn: • Kafka Fundamentals (from scratch) • Core concepts: topics, partitions, offsets, consumer groups • Ordering, keys, rebalancing, scaling consumers • Producer/consumer configuration and performance tuning • CLI tools and hands-on demos • Spring Cloud Stream: Build Real Applications • Consumer, producer, and processor services • Reactive vs imperative approaches • Message routing and event processing patterns • Dynamic producers with StreamBridge • Advanced Kafka Engineering Topics • Scaling and parallel processing • Batch processing • Message acknowledgement strategies • Error handling, retries, DLQ • Transactions and exactly-once semantics (myth vs reality) • Kafka Cluster Deep Dive • Replication and fault tolerance • Broker configuration and listeners • Running multi-broker clusters with Docker • Testing & Security • Integration testing with TestBinder and Test Containers • Serialization pitfalls in tests • Kafka security with SASL/SSL Why this course is different: • Hands-on demos for every concept • Focus on production realities • Covers both Kafka internals and Spring abstraction • Includes scaling, failure scenarios, and testing Elevate Your Career with In-Demand Kafka Skills: • Become a valuable asset to your team by building high-performance data pipelines. • Stay ahead of the curve in the rapidly growing field of real-time data processing. • Command a competitive salary in the high-demand Kafka job market.
Machine Learning with Neural Networks
This course explores the principles of machine learning through the lens of one of its most powerful and versatile model classes: the artificial neural network. We will cover the fundamental machine learning concepts of modeling, training, and generalization. You will learn how to process the input data with feed-forward operations, how to train a neural network model using gradient-based optimization and the backpropagation algorithm, and how to ensure it performs well on new data using regularization. In the final module, we discuss Bayesian neural networks, learning how to build models that not only make predictions but also quantify their own uncertainty.
Unreal Engine 5 Blueprints Multiplayer CRASH COURSE
It's time to learn Multiplayer Gameplay Programming in Unreal Engine! Using 100% Blueprints! In this CRASH COURSE, you will quickly learn the fundamentals of Unreal Engine Multiplayer. You will gain the skills to program multiplayer gameplay in any game genre! Many students struggle with multiplayer. Trust me, I've been there! In my 10+ years of experience of Unreal Engine gameplay programming, I've learned many lessons the hard way. I've found that multiplayer gameplay programming can be easy, as long as you understand the core principles behind multiplayer theory and how Unreal Engine's framework is built around multiplayer at its core. To program your games for multiplayer, you don't have to be an expert. You simply need to learn the basic concepts behind what makes multiplayer games work. This course is a condensed summary of the core principles you must understand to program multiplayer games. After completing this course, you will understand the fundamentals of multiplayer theory, how Unreal Engine implements multiplayer, and how upgrade your single player games to multiplayer, and how to structure your games for multiplayer from the start of your project's creation! This course dives deep into multiplayer theories, and you will be presented with a challenge to test your understanding of each topic so that you can get hands-on experience implementing each technique. After trying out each challenge on your own, you will then watch me solve each challenge and provide you with the steps to complete the problem. Each topic is summarized in a concise recap, and each section ends with a quiz to test your understanding so that you can continue onto the next topic with confidence. This course is structured into the following sections: MULTIPLAYER FUNDAMENTALS We will introduce the core multiplayer terms and concepts, including: • The Client-Server Model - how it differs from Peer-to-Peer connections, and how Unreal Engine uses this model • Testing Multiplayer - How you can easily simulate standalone, listen server, and dedicated server games in the engine's Play-In-Editor (PIE) • LAN Connection - You will create a LAN game, connecting with other computers in your own local network • Listen Servers Via Steam - I provide you with a plugin that allows you to quickly connect to other players via the Steam Online Subsystem ACTOR REPLICATION Actors are the heart of Unreal Engine levels. Actors possess the capability to replicate. • Actor Replication - You will see how easy it is to enable replication for Actors, how this allows for the replication of variables, and how to replicate movement to sync the server and client versions of each Actor • Authority and Net Role - Once you understand these simple yet crucial concepts, you will understand how to determine which machine a given Actor is on, affording you the power to make important gameplay decisions for your logic • Attachment - All games involve some form of attachment. You must learn how attachment works in multiplayer for Actors (or doesn't work, if you don't know what you're doing) • Variable Replication - The crux of multiplayer programming. Replicated variables are the workhorse of all multiplayer games and you will see just how easy it is to make them (and thus how responsible you have to be) • Rep Notifies - Sometimes, you just want to trigger a response of a variable's replication. Rep Notifies are functions designed to trigger in response to variable replication, and even access the pre-replicated value. • Replication Conditions - Variables replicate when they change. You have the power to decide whether that happens and when, and to which machines, under what circumstances. You learn how in this lecture. • Custom Rep Conditions - Your games may grow complex. You may find that you need a variable to only replicate sometimes, based on a custom condition you concoct. You will learn how. • Ownership - You cannot program in multiplayer effectively unless you understand what Ownership means in Unreal Engine. This includes owning connection: which machine is in charge of the object in question. This will be demystified for you in this lecture. • Actor Components - Components can replicate too, but you need to understand how that happens, and how their owning net connection is tied to their owning Actor. REMOTE EVENTS One of the most powerful tools in Unreal Engine's multiplayer framework, remote events do what replicated variables cannot. • Run on Client - When you need to call an event on the server and have it execute on the owning client, Run on Client Events are your go-to. • Run on Server - While replication only works from server-to-client, Run on Server Events are how you get information from client to server. • Multicast - With great power comes great responsibility. To call a function on the server and have it run on all clients, Multicast Events are the tool to use. • Relevancy and Priority - Net updates aren't just always happening - sometimes, Actors aren't relevant to other Actors. In addition, some Actors must replicate more often than others. This lecture shows you how relevancy and priority works. CLASS FRAMEWORK Understanding which class is designed for which task can greatly simplify your project's overall structure. You must understand what each core engine class is used for to program your games for multiplayer effectively. • The Game Mode - Avoid noob mistakes like trying to access the Game Mode on clients. Learn how the Game Mode dictates the rules of the game and the default classes that are spawned • The Game State - Information about the game, which needs to replicate to clients, is stored on this class. • The Player State - Where should you store your players' scores? Their teams? Player-specific data rests on this very important class • The Player Controller - Representing you as a player, the Player Controller owns your net connection and your Pawn or Character traces its ownership back to this class • Pawn and Character - Every player needs a visible Avatar. How do they work in multiplayer? This lecture has you covered • HUD and Widgets - How are these visual elements handled in multiplayer? Can you replicate them? (spoiler: you can't!) • Static Accessor Functions - Why do we always call these functions, passing in a 0 for the player index when we don't really know what to pass in? Beware of the pitfalls when using these static accessor functions, and the alternatives you can use instead when unsure TRAVEL IN MULTIPLAYER At some point, your game needs to change levels. All connected players in a multiplayer game must be moved to another level. How does this work? You will learn how. • Travel - We discuss the different travel types and how to implement them. • Implementing Seamless Travel - The final challenge to this course, you will implement seamless travel, migrating each client in the game to another map without disconnecting them. By the end of this course, you will fully understand the fundamentals of the Unreal Engine multiplayer framework. You will be able to program your games for multiplayer, no matter the genre. This course will serve you as a reference manual you can refer back to, skipping to lectures specific to each topic for a refresher. I recommend that all of my students take this course before taking any of my more advanced multiplayer courses! This course assumes you already understand the basics of Unreal Engine Blueprints. If you have made at least one Unreal Engine project, or you have completed my Unreal Engine 5 Blueprints - The Ultimate Developer Course, you're ready. Ready to finally understand how multiplayer works in Unreal Engine? It's not difficult! You just have to understand the fundamentals. I'll see you soon, Stephen
Typescript in React: Get started
In this course we will work with a number of examples of react components to work our way logically through some of the most commonly used parts of typescript in React. Along the way, feel free to pause the videos at any point and really play with the code to test things out, hover things and try to see if you can use the tooling to find solutions to the problems we have. By the end of the course you will be able to start working with a Typescript project in a React application.