Skip to content

TutoriaLibre

Home
Courses
Courses
- Programming Languages
  Programming Languages
  - JavaScript
    
    JavaScript
    
    Inline vs External Scripts for Web Pages
    
    Variables declaration in JavaScript
    
    Control flow in JavaScript
    Control flow in JavaScript
    
    If-Else and Switch Statements in JavaScript
    
    Loops in JavaScript
    
    Functions in JavaScript
    
    Objects and Classes in JavaScript
    
    Core objects
    Core objects
    
    Arrays in JavaScript
    
    Associative arrays in JavaScript
    
    Math class in JavaScript
    
    Date class in JavaScript
    
    Maps in JavaScript
    
    Sets in JavaScript
    
    Promises in JavaScript
    
    MinHeap implementation in JavaScript
    
    DOM & Events in JavaScript
    
    DOM & Events in JavaScript
    
    Manipulating DOM elements
    
    Animations in JavaScript
    
    HTML events
    
    Event handling and propagation
    
    Form validation in JavaScript
    
    Modules in JavaScript
    
    Conclusion
  - TypeScript
    
    TypeScript
    
    Module 1 — Why TypeScript Exists
    Module 1 — Why TypeScript Exists
    
    The Problem with Plain JavaScript
    
    Benefits of TypeScript
    
    Installing & Running TypeScript
    
    Hands‑on: Convert a small JS script to TS and observe compiler feedback
    
    Module 2 — TypeScript’s Type System
    Module 2 — TypeScript’s Type System
    
    Primitive Types
    
    Objects & Type Aliases
    
    Functions
    
    Arrays and Tuples
    
    Hands‑on: Type a small utility library
    
    Module 3 — Common TypeScript Usage Patterns
    Module 3 — Common TypeScript Usage Patterns
    
    Typing Common JS Patterns
    
    Working with DOM & Browser APIs
    
    Working with Node.js
    
    Hands‑On: Add TypeScript to a Small Node Project
    
    Module 4 — Narrowing, Guards & Control Flow Analysis
    Module 4 — Narrowing, Guards & Control Flow Analysis
    
    Type Narrowing
    
    Custom Type Guards
    
    Exhaustiveness Checking
    
    Hands‑on: Build a safe parser for external API data
    
    Module 5 — Interfaces, Classes & OOP in TypeScript
    Module 5 — Interfaces, Classes & OOP in TypeScript
    
    Interfaces Deep Dive
    
    Classes with Types
    
    Implementing Interfaces
    
    Hands‑on: Build a typed plugin system using interfaces
    
    Module 6 — Generics
    Module 6 — Generics
    
    Generic Functions
    
    Generic Interfaces & Classes
    
    Utility Types
    
    Hands‑on: Build a Generic Data‑Fetching Wrapper with Typed Responses
    
    Module 7 — Working with Existing JavaScript Codebases
    Module 7 — Working with Existing JavaScript Codebases
    
    Migrating JavaScript to TypeScript
    
    Interoperability
    
    Handling 'any' in Legacy Code
    
    Hands‑on: Migrate a small JS module to TS with minimal friction
    
    Module 8 — Advanced TypeScript
    Module 8 — Advanced TypeScript
    
    Mapped Types
    
    Conditional Types
    
    Template Literal Types
    
    Advanced Inference
    
    Hands‑on: Build a type‑safe router or event emitter
    
    Module 9 — Tooling, Build Systems & Ecosystem
    Module 9 — Tooling, Build Systems & Ecosystem
    
    ts-node, tsx, and Runtime Tools
    
    Bundlers & Frameworks
    
    Linting & Formatting
    
    Module 10 — Testing TypeScript
    Module 10 — Testing TypeScript
    
    Unit Testing
    
    Type Testing
    
    Mocking & Type Safety
  - PowerShell
    
    PowerShell
    
    Module 1 - Foundations of PowerShell
    Module 1 - Foundations of PowerShell
    
    Introduction
    
    Understanding the PowerShell Environment
    
    Commands, Cmdlets, and the Pipeline
    
    Working with Objects
    
    Providers and the PowerShell Drive Model
    
    Module 2 — Scripting Fundamentals
    Module 2 — Scripting Fundamentals
    
    Variables, Types and Operators
    Variables, Types and Operators
    
    Scalar Variables
    
    Arrays
    
    Hash Tables
    
    Type Accelerators
    
    Comparison and Logical Operators
    
    Control Flow
    Control Flow
    
    If and Switch Statements
    
    Loops
    
    Script Blocks and Scoping Rules
    
    Functions and Modular Code
    Functions and Modular Code
    
    How to Define Functions
    
    Parameter Binding
    
    Mandatory Parameters
    
    Pipeline Input
    
    Returning Objects Properly
    
    Error Handling and Debugging
    Error Handling and Debugging
    
    Terminating vs. Non‑Terminating Errors
    
    Try, Catch and Finally
    
    ErrorActionPreference
    
    Debugging Tools in VS Code
    
    Working with Files, Processes, and Services
    Working with Files, Processes, and Services
    
    Managing Files and Directories
    
    Starting and Stopping Processes
    
    Querying and Controlling Windows Services
    
    Module 3 — PowerShell for System Administration
    Module 3 — PowerShell for System Administration
    
    Remote Management
    Remote Management
    
    PowerShell Remoting (WinRM)
    
    Invoke-Command
    
    Sessions and Session Configuration
    
    Security Considerations
    
    Managing Windows Systems
    Managing Windows Systems
    
    Event Logs
    
    Scheduled Tasks
    
    Local Users and Groups
    
    WMI and CIM
    
    Working with APIs and Web Requests
    Working with APIs and Web Requests
    
    REST APIs
    
    Invoke-RestMethod vs. Invoke-WebRequest
    
    Parsing JSON and XML
    
    Working with Active Directory
    Working with Active Directory
    
    Installing RSAT
    
    Querying AD Objects
    
    Creating and Modifying Users, Groups, and Computers
    
    Module 4 — PowerShell Scripting at Scale
    Module 4 — PowerShell Scripting at Scale
    
    Writing Professional Scripts
    Writing Professional Scripts
    
    Script Structure
    
    Comment‑Based Help
    
    Logging Strategies
    
    Input Validation
    
    Modules and Packaging
    Modules and Packaging
    
    Modules
    
    Creating Modules
    
    Publishing Modules
    
    Desired State Configuration (DSC)
    Desired State Configuration (DSC)
    
    The Purpose of DSC
    
    Declarative Configuration
    
    Resources and Configurations
    
    Applying and Monitoring Configurations
    
    Performance Optimization
    Performance Optimization
    
    Measuring Execution Time
    
    Avoiding Unnecessary Pipeline Operations
    
    Using .NET Classes Directly
    
    Parallel Execution
    
    Module 5 — Enterprise‑Grade PowerShell
    Module 5 — Enterprise‑Grade PowerShell
    
    Security and Compliance
    Security and Compliance
    
    Execution Policies
    
    Code Signing
    
    Credential Management
    
    Secure Strings and Secrets
    
    Infrastructure Automation
    Infrastructure Automation
    
    Cloud Resources
    
    Virtual Machines
    
    Containers
    
    Building Tooling and Automation Frameworks
    Building Tooling and Automation Frameworks
    
    Designing Reusable Automation Libraries
    
    Creating Internal Toolkits
    
    Integrating PowerShell with CI/CD Pipelines
- Programming Frameworks
  Programming Frameworks
  - Next.js
    
    Next.js
    
    Module 1 - Getting started
    
    Module 1 - Getting started
    
    Setting up a new Next.js project
    
    Basic layouts
    
    Module 2 - Routing in Next.js
    
    Module 2 - Routing in Next.js
    
    File System Based Routing
    
    Nested Routes and Layouts
    
    Dynamic Routes
    
    Client-Side Navigation with Link
    
    Full Next.js App Integration: Implementing Auth & Dashboard Routes
    
    Module 3 - Styling your Next.js application
    
    Module 3 - Styling your Next.js application
    
    Global CSS in Next.js applications
    
    CSS Modules
    
    Introduction to Tailwind CSS in Next.js
    
    Next.js App Styling Integration: Refinement with Tailwind CSS
    
    Module 4 - Data Fetching & Rendering Strategies
    
    Module 4 - Data Fetching & Rendering Strategies
    
    Client components
    
    Basic State Management in Client Components
    
    Form Basics in React
    
    Module 5 - Data fetching and rendering with SSR and SSG
    
    Module 5 - Data fetching and rendering with SSR and SSG
    
    Secure data fetching and rendering
    
    Next.js App Integration: Mock APIs, Server Fetching & Loading Skeletons
    
    Module 6 - CRUD Operations with Server Actions
    
    Module 6 - CRUD Operations with Server Actions
    
    Introduction to Server Actions
    
    Implementing Next.js Server Actions: CRUD with revalidatePath
    
    Conslusions and Next Steps
  - FastAPI
    
    FastAPI
    
    Module 1 - Foundations of FastAPI
    Module 1 - Foundations of FastAPI
    
    Introduction to FastAPI: Installation, First Steps, and Hello World Example
    
    Basic routing
    Basic routing
    
    Creating Multiple Endpoints and HTTP Methods
    
    Dynamic Routing and Query Parameters
    
    Type Validation and Automatic Documentation
    
    Pydantic Models
    Pydantic Models
    
    Request Models
    
    Response Models
    
    Error Handling
    
    Project: Build a Task Manager API (Part 1)
    
    Module 2 - Intermediate API Design
    Module 2 - Intermediate API Design
    
    App Modulatization
    
    Database integration
    Database integration
    
    Intro to SQLModel
    
    Creating Models and Tables
    
    CRUD Operations with a Real Database
    
    Dependency Injection
    Dependency Injection
    
    FastAPI Depends System
    
    Reusable Components and Services
    
    Project: Build a Task Manager API (Part 2)
    
    Module 3 - Authentication, Authorization and Security
    Module 3 - Authentication, Authorization and Security
    
    OAuth2 and JWT
    OAuth2 and JWT
    
    Signup and Login Endpoints
    
    Password Hashing
    
    JWT Tokens
    
    Role-Based Access Control (RBAC)
    
    API Security Best Practices
    API Security Best Practices
    
    CORS, HTTPS and Rate Limiting Explained
    
    Input Sanitization and HTTP Headers
    
    Building Your First API — Task Manager (Part 3)
    
    Module 4 - Advanced Features and Production Readiness
    Module 4 - Advanced Features and Production Readiness
    
    Background Tasks and Asynchronous Operations
    
    WebSockets and Real-Time Features
    
    Testing FastAPI Applications
    
    Building Your First API — Task Manager (Part 4)
    
    Module 5 - Deployment and Monitoring
    Module 5 - Deployment and Monitoring
    
    Deploy FastAPI with Docker
    
    CI/CD and GitHub Actions
    
    Monitoring and Observability
    
    Final Project: Production-Grade Task Manager API
Blog
Blog
- Categories
  Categories

Explore all TutoriaLibre courses¶

Find your course in the sidebar on the left.