I think it's no surprise to anybody close to me that my favorite programming language is currently V. It has been my go-to language for scripts, apps, GUI programs and anything in between. But it is still a well-unknown language, mainly because it is very new (first released circa 2019) and some of its features are not yet stable (More on that below.)
I'm assuming most of you are programmers. So I will take the liberty of diving into more technical aspects of V's architecture.
V's syntax is especially easy to read and write. This is particularly beneficial in a language where you are able to dive into low-level programming. That's mainly because it imitates a lot of what Python and Go do in terms of syntax, and prevents the kind of complexity seen in languages like Rust and Java (Sorry Rustaceans.)
// This is a simple V app from their example section.
// Print file lines that start with "DEBUG:"
import os
// `read_file` returns an optional (`?string`), it must be checked
text := os.read_file('app.log') or {
// `err` is a special variable that contains the error
// in `or {}` blocks
eprintln('failed to read the file: ${err}')
return
}
lines := text.split_into_lines()
for line in lines {
if line.starts_with('DEBUG:') {
println(line)
}
}
V prioritizes safety with features that prevent common programming errors. This includes immutability by default, which means variables and structs can't be changed after they're created unless explicitly marked as mutable. It also has mandatory error checking and no null pointers, helping to eliminate a whole class of bugs. That comes as a surprise in this regard, especially since V uses C as a backend.
V offers a variety of memory management options.
This is a hot take, but in most cases, you don't need a complex memory management strategy. If your app is designed to run occasionally and not stay open for too long, not using GC actually speeds it up a lot. Then, after using it, the kernel takes care of reclaiming the rest of the memory. If not, you may use the options above or handle it manually like a champ.
V has seamless interoperability with C. This means you can directly use existing C libraries without any FFI overhead, much like Rust does.
No language is perfect, and V, despite its many advantages, has its share of caveats. It is not yet 100% stable (I have ran into some problems before. They usually happens when you try to mess with stuff that makes C think your code is valid, but it panics on runtime.). Also, V does not have some libraries you might want. Even though you can call them for C, if you find a library that is missing on V, and you don't want to code a wrapper for it, it's best to go to another language for now.
TLDR: Yes. V is amazing. Apart for some stuff that might go wrong if you mess with stuff you shouldn't, it's fast, stable, compatible and very easy to code and to maintain. Right now, I am coding a feature complete package manager on it, and the experience is amazing. Updates on that soon. Thanks for reading.