V lang: comparativa con Go

V Lang es un lenguaje de programación que ha tomado lo mejor de los lenguajes C y C++, se inspira principalmente en Go, pero también toma elementos de Rust, Swift, Kotlin, Oberon y Python.

Es un lenguaje de tipado fuerte. Además podemos distinguir de las variables tipo mutable o inmutable.

Por su parte, Go es un lenguaje de programación diseñado para ser rápido, eficiente, concurrente y fácil de aprender. Compilado y con tipado estático, destaca en el desarrollo backend, sistemas en la nube y redes gracias a su gestión automática de memoria y alto rendimiento.

Observemos está tabla comparativa:

Comparativa Go y V Lang

Aspecto	Go	V Lang
Creador	Ken Thompson, Robert Pike y Robert Griesemer	Alexander Medvednikov
Objetivo	Lenguaje eficiente, concurrente y fácil de usar para sistemas distribuidos y servidores	Lenguaje simple, seguro, con compilación ultrarrápida y binarios pequeños
Paradigma	Imperativo y concurrente; goroutines y canales	Imperativo y funcional ligero; inmutabilidad por defecto
Compilación	Compilación rápida pero binarios más grandes (~7 MB para un servidor web)	Muy rápida, sin dependencias externas; binarios pequeños (~600 KB para un servidor web)
Tipado	Estático, explícito	Estático, con inferencia de tipos
Concurrencia	Goroutines y canales maduros y ampliamente probados	Inspirada en Go, pero aún en desarrollo
Interoperabilidad	Interop limitado con C mediante cgo	Interop directo con C (zero-cost)
Ecosistema	Amplio ecosistema, soporte empresarial, librerías maduras	En crecimiento, aún limitado; librerías básicas y comunidad pequeña
Rendimiento	Rendimiento consistente y optimizado; probado en producción a gran escala	Promete velocidad comparable a C, pero en benchmarks suele ser más lento que Go en tareas intensivas
Seguridad	Seguridad básica, pero más flexible; depende del programador	Inmutabilidad por defecto, sin null, sum types, chequeos estrictos
Ideal para	Backend, sistemas distribuidos, microservicios, herramientas de infraestructura	Proyectos pequeños, prototipos, aplicaciones donde la simplicidad y binarios pequeños son clave

V Lang esta fuertemente influenciado por Go, Oberon, Swift y Rust.

Surge de la frustración de usar lenguajes como C, C++, Java o Python, entre otros. Tomando lo mejor de ellos y optando por descartar lo peor.

Se usó en un principio para el desarrollo de un cliente de mensajería de escritorio llamado Volt.

Comparativa: Go y V Lang

1. El clásico programa del "Hola, mundo".

En Go:

holamundo.go

package main

import "fmt"

func main() {
  fmt.Println("Hola, mundo")
}

Construcción y ejecución:

$ go build holamundo.go
$ .\holamundo.exe

Salida:

Hola, mundo

En V Lang:

holamundo.v

fn main() {
    println('Hola, mundo')
}

Construcción y ejecución:

$ v run holamundo.v

Salida:

Hola, mundo

Ejemplo 2. Sencillo programa que nos muestre el uso de banderas. Una bandera puede cambiar entre los estados: true y false.

En Go:

bandera.go

package main

import "fmt"

var bandera = true

func main() {
    if bandera {
        iniciarProceso()
    }
}

func iniciarProceso() {
    fmt.Println("Se inicia el proceso de lectura...")
    bandera = false
    fmt.Println("Termina el proceso de lectura.")
}

Construcción y ejecución:

$ go build bandera.go
$ .\bandera.exe

Salida:

Se inicia el proceso de lectura...
Termina el proceso de lectura.

En V Lang:

bandera.v

module main

fn main() {
    mut bandera := true
    if bandera {
        bandera = iniciar_proceso(bandera)
    }
}

fn iniciar_proceso(bandera bool) bool {
    println("Se inicia el proceso de lectura...")
    println("Termina el proceso de lectura.")
    return false
}

Construcción y ejecución:

$ v run holamundo.v

Salida:

Se inicia el proceso de lectura...
Termina el proceso de lectura.

Ejemplo 3. Ejemplo del uso de punteros.

En lenguajes como C se introduce el concepto de punteros, el cual es una variable que hace referencia a la dirección de memoria de una variable definida. Veamos un ejemplo en C:

puntero.c

#include <stdio.h>

int main() {
    int x = 10;
    int *p = &x;   

    *p = 20;       

    printf("Valor de x: %d\n", x);
    return 0;
}

En Go:

puntero.go

package main

import "fmt"

func main() {
	x := 10
	p := &x

	*p = 20

	fmt.Println("Valor de x:", x)
}

Construcción y ejecución:

$ go build holamundo.go
$ .\holamundo.exe

Salida:

Valor de x: 20

En V Lang:

puntero.v

fn main() {
    mut x := 10
    unsafe {
        mut p := &x
        *p = 20
    }
    println('Valor de x: $x')
}

Construcción y ejecución:

$ v run puntero.v

Salida:

Valor de x: 20

Podemos concluir que:

Go es más confiable para proyectos grandes y críticos gracias a su ecosistema maduro y rendimiento probado.

V Lang es atractivo para quienes buscan compilación ultrarrápida, binarios ligeros y mayor seguridad por defecto, pero aún está en evolución y puede carecer de optimización en escenarios de alto rendimiento.

Continuaremos en próximas entregas.

Enlaces:

https://alquimistadecodigo.blogspot.com/2026/02/vlang-un-lenguaje-de-programacion-para.html
https://alquimistadecodigo.blogspot.com/2024/12/v-lang-un-lenguaje-simple-rapido-y.html
https://en.wikipedia.org/wiki/V_(programming_language)