Getting Started with V Programming: An end-to-end guide to adopting the V language from basic variables and modules to advanced concurrency

Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Section 1: Introduction to the V Programming Language
Chapter 1: Introduction to V Programming
The past, present, and future of V
V is a statically typed and compiled programming language
Simple and maintainable syntax
Backward compatibility, stability, and easy to upgrade to future versions
Features of V programming
Performance
Speed
No null values
No global variables
No undefined values
Error handling
Powerful concurrency
Easy cross-compilation
V to JavaScript conversion
Profiling
V as a framework
Memory management using the autofree engine
Inbuilt ORM
Built-in web server
Native cross-platform GUI library
Vinix – an OS kernel written in V
Operating systems V supports
Summary
Chapter 2: Installing V Programming
Technical requirements
Installing V on the Windows OS
Approach 1 – installing V from portable binaries on the Windows OS
Approach 2 – installing V from source on the Windows OS
Adding V to the environment variables in the Windows OS
Accessing V programming using a REPL
Installing V on the Linux OS (Ubuntu)
Using Symlink V to make V accessible globally in Ubuntu
Summary
Section 2: Basics of V Programming
Chapter 3: Variables, Constants, and Code Comments
Technical requirements
Understanding variables in V
The variable naming convention
Variable assignment
Features of variables in V
The limitations of variables in V
Working with constants in V
Naming conventions for constants
Defining constants
Defining complex constants
Best practices when working with constants
Variables versus constants
Adding code comments in V
Single-line comments
Multiline comments
Summary
Chapter 4: Primitive Data Types
Technical requirements
Introducing primitive data types
The Boolean data type
Logical operators
Relational operators
Numeric data types
Signed and unsigned integers
Floating-point types
Promoting numeric types
Operations on numeric data types
Arithmetic operators
Bitwise operators
Shift operators
The string data type
Working with the string data type
The rune data type
Operations on the string data type
String interpolation
String manipulation techniques
Summary
Chapter 5: Arrays and Maps
Technical references
Arrays
Different methods to declare arrays
Working with the len and cap array properties
Accessing array elements using the index
Accessing array elements using slices
Operators used with arrays
Fixed-size arrays
Multidimensional arrays
Performing various operations on an array
Maps
The explicit initialization of a map
The short syntax initialization of a map
The count of key-value pairs in a map
Retrieving a value given the key of a map
Accessing a non-existent key from a map
Handling the retrieval of missing keys in a map
Updating the value of the key in a map
Deleting a key-value pair from a map
Summary
Chapter 6: Conditionals and Iterative Statements
Technical requirements
Conditional blocks
The if statement
match
Iterative statements
A for loop on maps
A for loop on arrays
A for loop without an index on the array
A traditional C-style for loop
A reverse for loop
A for loop on a range
A bare for loop or an infinite for loop
Using break in a for loop
Using continue in a for loop
Using the continue and break statements with labels
Summary
Chapter 7: Functions
Technical requirements
Introducing functions
Understanding function types
The main function
Basic functions
Anonymous functions
Higher-order functions
Understanding function features
Functions can return values or simply perform operations
Functions can take zero or more input arguments
Functions can return multiple values
Ignoring return values from functions
Functions can call other accessible functions
Functions allow only arrays, interfaces, maps, pointers, and structs as mutable arguments
Function declarations in script mode should come before all script statements
Functions do not allow access to module variables or global variables
Functions do not allow default or optional arguments
Functions can have optional return types
Functions are private by default and can be exposed to other modules using the pub access modifier keyword
Functions allow you to defer the execution flow using the defer block
Functions can be represented as elements of an array or a map
Summary
Chapter 8: Structs
Technical requirements
Introducing structs
Defining a struct
Initializing a struct
Accessing the fields of a struct
Understanding heap structs
Updating the fields of a struct
Approaches to defining struct fields
Adding multiple mutable fields to a struct
Grouping fields in a struct using access modifiers
Defining required fields in a struct
Defining struct fields with default values
Defining methods for a struct
Adding a struct as a field inside another struct
Modifying the fields of struct type inside another struct
Structs as trailing literal arguments to a function
Summary
Chapter 9: Modules
Technical requirements
Introducing modules
The syntax to define a module
The syntax to import a module
Working with modules
Creating a simple V project
Creating a module
Importing a module
Accessing members of a module
Working with multiple files in a module
Member scope in the module
Implications of cyclic imports
The init function for a module
Accessing the constants of a module
Accessing structs and embedded structs of a module
Summary
Section 3: Advanced Concepts in V Programming
Chapter 10: Concurrency
Technical requirements
Introducing concurrency
Understanding parallelism
Learning the basic terminology
Getting started with concurrency
Understanding the time module
Understanding the thread type
Implementing concurrency in V
The go keyword syntax
Spawning a void function to run concurrently
Waiting on a concurrent thread
Implementing a real-life concurrency scenario programmatically
Running multiple tasks in a sequence
Spawning multiple tasks to run concurrently
Comparing sequential and concurrent program runtimes
Learning different approaches to implement concurrent programs
Spawning functions with return values to run concurrently
Spawning anonymous functions to run concurrently
Sharing data between the main thread and concurrent tasks
Summary
Chapter 11: Channels – An Advanced Concurrency Pattern
Technical requirements
Syntax to define a channel
Unbuffered channel
Buffered channel
Channel operations
Arrow operator <-
Push operation
Pop operation
Channel properties
Understanding channel properties using examples
Channel methods
Using try_push() on unbuffered channels
Using try_push() on buffered channels
try_pop()
close()
Working with unbuffered channels
Understanding the blocking nature of unbuffered channels
Dealing with the blocking behavior of unbuffered channels
Synchronizing data between coroutines that communicate via an unbuffered channel
Working with buffered channels
Understanding the behavior of a buffered channel
Establishing buffered communication channel between coroutines
Synchronizing data between coroutines that communicate through a buffered channel
Channel select
Summary
Chapter 12: Testing
Technical requirements
Introduction to tests in V
The assert keyword
Writing a simple test
Running tests
Understanding testsuite functions
Demonstrating the usage of testsuite functions
The AAA pattern of writing tests
Writing tests for functions with optional return types
Approaches to writing and running tests
Writing tests for a simple program
Running tests contained in _test.v file
Writing tests for a project with modules
Running tests contained in a module
Writing tests for members of a sub-module from the main module
Running all the tests contained in a project
Running tests with stats
Summary
Chapter 13: Introduction to JSON and ORM
Technical requirements
Getting started with JSON
Decoding a JSON object
Encoding an object into JSON data
Learning ORM
Understanding ORM attributes
Creating a struct for ORM
Working with the ORM library
Briefly understanding database operations using V's ORM
Performing DDL operations using V's ORM
Performing DML operations using V's ORM
Summary
Chapter 14: Building a Microservice
Technical requirements
Introducing vweb
Creating a project and organizing files
Setting up the vweb web server
Setting up utility functions and constants for the microservice
Implementing RESTful endpoints
The list of RESTful endpoints in our microservice
Defining the Note struct
Implementing an endpoint to create a note using HTTP verb POST
Defining the route to create a note
Processing requests and handling custom responses for the create endpoint
Inserting a record using the ORM query
Building a response body for the create endpoint
Implementing an endpoint to retrieve a note by id using HTTP verb GET
Defining a route to retrieve a note by id
Selecting a record given its id using the ORM query
Handling a custom response for the read a note endpoint
Building a response body for the read endpoint
Implementing an endpoint to retrieve all notes using HTTP verb GET
Defining a route to retrieve all notes
Selecting all the records from a table using the ORM query
Building a response body for the read all notes endpoint
Implementing an endpoint to update a note using HTTP verb PUT
Defining a route to update a note by id
Processing requests and handling custom responses for the update endpoint
Verifying a record exits given its id using the ORM query
Verifying the uniqueness of the message field of note
Updating the record using the ORM query
Building a response for the update endpoint
Implementing an endpoint to delete a note using the HTTP verb DELETE
Defining the route to delete a note by id
Deleting a record given its id using the ORM query
Building a response for the delete endpoint
Running the microservice
Querying REST endpoints using Postman
Using Postman to create a note with the POST HTTP verb
Using Postman to retrieve a note by id with the GET HTTP verb
Using Postman to retrieve a collection of notes with the GET HTTP verb
Using Postman to update a note with the PUT HTTP verb
Using Postman to delete a note with the DELETE HTTP verb
Summary
Other Books You May Enjoy
Index