Master TypeScript type inference and learn how to configure a fundamental compilation workflow. This tutorial covers implicit types, compiling TypeScript to JavaScript, organizing src vs. dist output folders, and creating custom npm build and clean scripts.

Key Topics Covered:
00:00 – Comparing JavaScript and TypeScript Type Handling
00:20 – Verifying Output with Console Logs
00:44 – Compiling TypeScript via Terminal (tsc)
01:25 – Examining Compiled JavaScript Output in Dist
01:41 – Automating Build Workflows with npm Scripts (Build & Clean)
02:25 – Type Inference & Implicit Variable Types

Resources:
• Subscribe to Beshilo Coding Academy for full-length software engineering courses.
• Source code and project repositories available on GitHub.

#TypeScript #WebDevelopment #JavaScript #BeshiloCodingAcademy #SoftwareEngineering #NodeJS #Programming

Master the fundamental building blocks of TypeScript. This tutorial covers primitive types, type inference, variable declaration, and how TypeScript’s static type system enhances standard JavaScript.

In this lesson:
00:00 – Introduction to TypeScript Fundamentals
00:17 – What are Basic Types?
00:27 – String Type
00:29 – Number Type
00:34 – Boolean Types
00:37 – Null & Undefined
00:43 – BigInt
00:46 – Unique Symbols
00:53 – Practical Examples in VS Code
01:44 – Variable Declarations & Type Assignment
02:07 – Boolean Logic
02:15 – TypeScript vs. JavaScript Comparison

Resources & Links:
• Subscribe to Beshilo Coding Academy for full-length software engineering courses.
• Access project source code on GitHub.

#TypeScript #WebDevelopment #Programming #BeshiloCodingAcademy #SoftwareEngineering

Now that your TypeScript project is configured, it’s time to save it like a pro! In this tutorial, we finalize our compiler settings and walk through the step-by-step process of initializing a Git repository and pushing your code to GitHub. Mastering this workflow is essential for every developer who wants to collaborate or showcase their work.

**In this video, you will learn:**

* Enabling strict compiler checks for unused variables and parameters.
* Initializing a local Git repository (`git init`).
* Configuring a `.gitignore` file for TypeScript projects.
* Creating a new repository on GitHub and linking it to your local project.
* Pushing your TypeScript source code and configurations to the cloud.

—–

### **Chapters with Timestamps**

0:00 – Finalizing Advanced Compiler Checks
0:12 – Handling Unused Variables and Parameters
0:25 – Ensuring Type Safety in Your Project
0:32 – Preparing Your Project for Version Control
0:54 – Initializing Git: The `git init` Command
1:12 – Staging and Committing Your TypeScript Files
1:21 – Creating a New GitHub Repository
1:38 – Linking Local Code to Remote GitHub Repository
2:05 – Executing the First Git Push
2:32 – Verifying Your Project on GitHub

Unlock the full power of the TypeScript Compiler (TSC)! In this tutorial, we move from basic compilation to advanced project configuration. Learn how TypeScript “predicts” your types, how to use Watch Mode for faster development, and what those complex `tsconfig.json` settings actually do for your code quality.

**In this video, you will learn:**

* How Type Prediction works during variable declaration.
* Essential CLI commands: `npx tsc`, `tsc –watch`, and `tsc –init`.
* Understanding the project structure: Root, Source, and Output folders.
* Deep dive into Compiler Options: `sourceMap`, `declaration`, and `strict` checks.
* How to catch bugs automatically with `noUnusedLocals` and `noUnusedParameters`.

—–

### **Chapters with Timestamps**

0:00 – Understanding Type Prediction in TypeScript
0:15 – Testing Type Safety with Variable Changes
0:45 – Running the Project: npx tsc Compilation
1:10 – Converting TS to JS: Checking the Output
1:38 – Essential Commands: Watch Mode & Auto-Recompile
1:56 – tsconfig.json Deep Dive: Root & Source Folders
2:06 – Target Versions & Module Systems
2:15 – Source Maps & Declaration Files (.d.ts)
2:25 – Mastering Strict Type Checking
2:38 – Cleaning Code: Finding Unused Variables & Parameters
2:50 – Advanced Index & Property Access Checks

Take your development workflow to the next level! In this tutorial, we demonstrate how to automate project cleanup using custom scripts and dive into the core of TypeScript: **Type Annotations**. Learn how to define types for variables and function parameters to catch errors before they happen.

**In this video, you will learn:**

* How to create and run an `npm run clean` script to manage your folders.
* The difference between plain JavaScript and type-safe TypeScript.
* Assigning types like `number` and `string` to variables.
* Defining parameter and return types for functions to eliminate “complaints” from the compiler.

—–

### **Chapters with Timestamps**

0:00 – Intro: Managing Your Build Environment
0:15 – Automating Cleanup: Using npm run clean
0:38 – verifying Folder Deletion & Script Execution
1:00 – Transitioning from JavaScript to TypeScript
1:25 – Coding a Basic Function Structure
1:45 – Why the Compiler Complains: Missing Types
2:05 – Applying Type Annotations to Variables
2:18 – Fixing Function Parameters with Type Number
2:35 – Final Comparison: Type-Safe vs. Non-Typed Code

Streamline your TypeScript development by mastering the build and execution workflow. In this tutorial, we dive into the `tsc` compiler, explore how to control output files in the `dist` folder, and set up professional npm scripts in `package.json` to save you time.

**In this video, you will learn:**

* How to use `npx tsc` to transpile your project.
* The difference between development execution and production builds.
* Controlling build artifacts like `.d.ts` and source maps.
* Setting up `build` and `start` scripts for a professional workflow.
* Running your generated JavaScript with Node.js.

—–

### ** Timestamps**

0:00 – Introduction to Build Workflows
0:14 – Understanding File Deletion & Project Cleanup
0:25 – Compiling with npx tsc: Checking the Output
0:38 – Controlling Declaration and Map Files
0:54 – Managing the dist Folder & Build Control
1:10 – Converting TypeScript to JavaScript
1:25 – Verifying the index.js Output
1:40 – Running Compiled Files with Node.js
2:02 – Creating Professional npm Scripts
2:25 – Finalizing Build and Start Commands

Ready to write your very first TypeScript program? In this tutorial, we move beyond configuration and start coding! We’ll show you how to properly set up your `src` folder, create your first `index.ts` file, and use the TypeScript compiler (`tsc`) to transpile your code into working JavaScript.

**In this video, you will learn:**

* How to organize your TypeScript project for scale.
* Writing a simple “Hello World” style program in TypeScript.
* Understanding the relationship between `.ts` and `.js` files.
* Running your project and verifying the output.

—–

### **Timestamps**

0:00 – Introduction: Beyond Configuration
0:18 – Understanding npm vs npx for Binaries
0:32 – How tsc Compiles TypeScript to JavaScript
0:40 – Setting Up the Project Structure (src Folder)
0:52 – Writing Your First TypeScript Code
1:24 – Creating the index.ts Entry Point
1:42 – Running the Transpiler and Checking Output
2:04 – Exploring the Declaration and Map Files
2:32 – Summary & Final Project Run

Master the essentials of TypeScript configuration in this deep dive into the `tsconfig.json` file. Whether you’re setting up a new project or fixing compiler errors, understanding how to structure your source files (`src`) and manage build outputs is critical for every developer.

In this video, we cover:

* Initializing your TypeScript configuration.
* Managing the `src` folder and entry points like `index.ts`.
* Configuring compiler options for better development.
* Using `.gitignore` to keep your project clean.

—–

### **Chapters with Timestamps**

0:00 – Introduction to TypeScript Project Structure
0:22 – Creating the src Folder and index.ts
0:38 – Understanding the tsconfig.json File
0:50 – Setting up .gitignore for TypeScript
1:19 – Detailed Compiler Configuration
1:40 – Customizing Default Configuration Values
2:14 – Advantages of Proper TypeScript Setup
2:32 – Final Summary & NPM Commands

Ever wondered what actually happens behind the scenes when you write TypeScript?

In this video, we break down the core project structure—including node_modules, package.json, and package-lock.json—and dive deep into tsconfig.json (the TypeScript “Rule Book”). You’ll learn how the TypeScript Compiler (TSC) works and how to set up your rootDir and outDir settings for clean, professional builds.

⚡ Key Commands Covered:
• Initialize TS configuration: npx tsc –init
• Run TypeScript compiler: npx tsc

⏱️ Timestamps:
00:00 – The Big Three: node_modules, package.json & package-lock.json
00:32 – What is TSC? (TypeScript Compiler Explained)
01:00 – Organizing Source (/src) vs. Distribution (/dist)
01:34 – Initializing Config (`npx tsc –init`)
02:08 – Demystifying tsconfig.json (The Rule Book)
02:27 – Configuring `rootDir` and `outDir`

—————————————————
🔔 Subscribe to Beshilo Coding Academy for full-stack software development tutorials!
#TypeScript #JavaScript #WebDevelopment #Programming #VSCode #BeshiloCodingAcademy

Ready to build with TypeScript? Setting up your project correctly from day one saves you from hours of debugging down the road.

In this video, we go step-by-step through initializing a Node.js project using `npm init -y`, installing TypeScript as a development dependency (`–save-dev`), and verifying the installation with `npx tsc`.

⚡ Key Commands Covered:
• Verify setup: node -v & npm -v
• Initialize project: npm init -y
• Install TypeScript locally: npm install -D typescript
• Verify TypeScript compiler: npx tsc –version

⏱️ Timestamps:
00:00 – Verifying Node.js & npm Setup
00:58 – Initializing Project (`npm init -y`)
01:16 – `package.json` Explained Simply
01:28 – Installing TypeScript (`npm i -D typescript`)
01:45 – Why Use `–save-dev` (`-D`) for TypeScript?
02:08 – Verifying Installation with `npx tsc`

—————————————————
🔔 Subscribe to Beshilo Coding Academy for full-stack software development tutorials!
#TypeScript #JavaScript #WebDevelopment #Programming #VSCode #BeshiloCodingAcademy