The V Programming Language

Learn to write a simple program in v using the v interpreter, save in main.v, and run v dot run, noting the interpreter is experimental.

Explore choosing the right tools for the V language, covering Sublime Text, VSCode, Kate, Code Lite, and IntelliJ Idea, and setting up the V package in your editor.

Learn to install Kate editor from the official site, configure it for V language files, and tailor the interface with ru mirage theme, Fira Code font, and 1.3 line height.

Install and set up the IntelliJ IDEA community edition from JetBrains, download for Linux, skip the paid Ultimate edition, and note its use for Java, Kotlin, and the V language.

Learn to install and configure IntelliJ IDEA for the V language, install the V plugin, set up a dummy project, adjust font and appearance, and run V programs.

Learn to compile and run V programs by using v main.v -o app to build an executable, then run ./app, or use v run main.v to execute directly.

explain the basic structure of a v program and show how to set up projects with v new, v create, vlp, and run a hello world example.

Introduce variables in the V language, covering declaration, initialization, and assignment with examples like name and age. Explain mutable versus immutable variables and primitive data types.

Explore the v language data types, including booleans, strings, rune, floating point numbers, and various integer sizes with casting and binding concepts.

The lecture explains how to comment in the V programming language, shows single-line and multi-line comments, and reviews primitive data types such as boolean, string, integer, u32, f32, and any.

Learn how to test variables without output in V by using assert to verify values, avoid unused-variable warnings, and build a binary without running the program.

Learn how the V programming language uses if and else conditional statements to execute code blocks based on true or false conditions, with variable checks and printed outputs.

Explore how conditional statements work in the V programming language: define if, else if, and else blocks, show proper ordering, and build an age-based example with multiple branches.

Explore V's if expression, compare it to C/C++'s ternary operator, and learn to assign values with if expressions by checking age to classify adults or teenagers.

Explore how to declare and initialize numbers in V, differentiate mutable and immutable variables, test with asserts, and understand integer and floating point data types and casting.

Explore the numeric ranges of i8, u8, i16, and u16 in the V language, from -128 to 127 and 0 to 255, and learn overflow behavior with practical calculations.

Examine how integers work in the V language, from i8 and i16 to int and i64, including signed and unsigned bounds like u32, readability with underscores, and operator precedence.

Explore strings in the v language, including string length, indexing to get a u8 byte, slicing to extract substrings, escapes with \x and unicode/utf-8, and mutable vs immutable string literals.

Learn string interpolation and placeholders in the V language by inserting variables into strings, formatting numbers, and repeating text with the R keyword and print lines, including binary and decimals.

Explore string operators in the V language by converting strings to bytes and back, chaining string methods, and using camel to snake, capitalize, clone, lower, length, compare, and contains.

Learn practical string operations in V, including contains, slicing and counting, end with and end width, length, is upper, and converting to uppercase, demonstrated through mutable variables and method chaining.

Explore rune in the V programming language by adding rune icons, copying and pasting code, and printing base runes to understand their simple, interchangeable role.

Learn the basics of arrays in the V language: define, print, access elements, and append values; compare immutable and mutable arrays, and explore length and cap.

Explore how the V language handles arrays, including mutable and immutable builds, length and capacity, and automatic doubling of capacity as elements are added.

Explore multidimensional arrays in the V language, building 2D and 3D arrays as arrays of arrays, with inner arrays of ints and other types, and use dump for debugging.

Learn to manipulate arrays in the V language using repeat to extend single and multi-dimensional arrays and insert to add values at a specific index, with mutability considerations.

explains and demonstrates array methods in v, including prepend, delete, delete many, first, last, pop, clone, reverse, sort, and contains, showing how each manipulates and queries arrays.

Explore array slicing in the V language, showing how slices share memory with their source, compare length and capacity, and reveal how unsafe blocks and mutable edits affect allocation.

Explore array slices in the V programming language, part 2, focusing on positive and negative indexing, capacity doubling, and cloning for independent copies of mutable arrays.

Practice array method chaining in the v programming language by filtering a student array, using map to transform values, and converting file names to uppercase.

Learn how fixed size arrays work: create a three fruits array, make it mutable to add elements, but you cannot increment or shrink; it remains stack-stored and efficient for data.

Create and manipulate maps in the V programming language: define key value pairs, access by key, delete entries, use short syntax, nest maps, and update with arrays and stores.

Demonstrate the match statement as a shorter alternative to if-else in v, illustrate condition checks with age values, and include variants and backticks for printing results.

Explore loops in the V programming language, focusing on for and for-while constructs to control repetition and iterate over data.

Explore more on loops in the V programming language, broadening your understanding of looping concepts within the course.

Learn how to define and call functions in V by wrapping code in functions, declaring function names and parameters, and calling them to run actions like greeting and adding numbers.

Explore defining functions with parameters, returning values, and multiple returns in the V programming language. Learn to pass two integers, perform addition and multiplication, and print results with string interpolation.

Demonstrate returning multiple values of different types in the V language, including int and string, and handling length, uppercase, and camel to snakecase in function outputs.

Learn the advantages of functions, including reusability and reduced redundancy. See how modular code and abstraction enable passing arrays and reusing a single function across contexts.

Learn how v treats functions as immutable by default and how to declare mutable variables and mutable arrays to modify data inside functions, including multiplying even numbers.

Delve into mutable functions in the V programming language, learning to print arrays with proper line handling, manage index-based output, and track array length and capacity.

Explore variable number of arguments in the V language by defining a variadic function with three dots to accept multiple values and explode arrays into arguments.

Explore creating anonymous functions in the V programming language, doubling values, and using arrays to store and invoke functions like square root.

Explore anonymous and higher order functions in the v language, including passing functions as parameters, creating square root and cube functions, and using map for modular, reusable code.

Master closures in the V programming language by creating anonymous functions that inherit variables from their scope, with live code examples using a map, square root and cube calculations.

Explore parameter evaluation order in the v programming language by testing a, b, c in a display_all function and dumping results, showing the order follows argument layout across versions.

Define a custom data type with a struct, declare fields like name, age, and gender, and access them using dot notation in the V language.

Learn how V language uses default field values in structs, showing immutability, mutability, and updating fields like name within a default or empty struct.

Explore how to change access modifiers and use if struct in the V language to store structs on the heap, compare heap and stack storage, and set default parameters.

Enforce initialization of struct fields in the V programming language by using the required keyword on properties like age or gender, ensuring code compiles only when these fields are present.

demonstrate short syntax literals in the v programming language by constructing structs with fields, show how removing fields affects compilation, and introduce struct update literals.

Explore struct update syntax in the V programming language by spreading old data with three-dot, using struct literals to set fields like name and gender, and testing updates with printouts.

This lecture demonstrates creating and testing struct literals in the V programming language, using trailing struct literal arguments and a train_session function that accepts a player and returns training.

Explore V's access modifiers, including private immutable, private mutable, public immutable, public mutable, and global, plus the default behavior and the use of double underscores.

Explore anonymous structs in the V programming language, defining address components like street, city, state, and zip code, updating structures, and using access modifiers to print results.

Explore static type methods in the v language, showing how struct functions define static methods to group related behavior, with examples like animal.new for constructing and validating a name.

Explore noinit structs in the V programming language by creating a public Bitcoin struct with a string address, experimenting with initialization, methods, and printing the wallet address.

Learn how to define and call methods in v using fn, name a variable like btc, define a function, and access it with dot notation such as s.send.

Explore structs and embedding in the V programming language by modeling a field with length and width, using the calculate field method, and accessing embedded methods from a club.

Explore embedding structs in the V programming language by adding and passing field values, using short syntax, and calling embedded struct methods to display data, while contrasting with anonymous structs.

Learn how to create and use modules in v by aliasing imports with the as keyword, renaming modules, and troubleshooting import errors in input and display workflows.

Learn to use built-in modules in V, import OS, and split functionalities into a reusable module with a public function to validate and display a username.

Explore selective imports by pulling only needed functions like input, validate, and display from a module, improving clarity and avoiding name conflicts.

Explore aliasing imported models and submodules in V using the as keyword, and apply it to a validate submodule and its display function, noting aliasing works with submodules.

Initialize and clean up code using module init and cleanup functions that run automatically when a module is imported or the program ends.