Gently, V: A Simple Beginner's Guide

[kleeedolinux]

By Júlia Klee

Hiiii! It’s me, Júlia. Sometimes, when I’m programming, I feel like I’m trying to build a beautiful sandcastle while the tide is coming in. I’ll get a wall just right, and then WHOOSH, a wave of memory leaks or a grumpy, slow compiler washes it all away. I spend more time fighting the ocean than building my masterpiece.

And for a while, I thought that’s just how it was! You either get the wild, free-for-all fun of a language like Lua, where you can sculpt anything from thin air (but it might melt in the sun!), or you get the incredible, battleship-grade power of Rust, where a very wise (and very strict!) robot sensei checks every single grain of sand you place.

But what if you just want to build a really, really nice sandcastle, fast, and have it not fall over?

What if you just wanted a friend?

      //
     (o>
</////)
 ` ` `

This is Vee-Bot. Say hi, Vee-Bot! He’s here to show us around V. He’s made of pure speed and helpfulness. And he brought us a gift. The first gift of any new programming adventure.

Let’s open it! Create a file, call it first_wave.v. Put this inside.

fn main() {
	println('Hello from my new castle!')
}

Okay, what’s this?? fn main() is like the big, friendly front gate to our sandcastle. It’s where everything starts. And println() is you, standing on the tallest tower, shouting to the world!

Now, open up your little talking-to-the-computer window (some people call it a terminal!) and just say the magic words:

v run first_wave.v

...zip!

It just prints. Right away. There’s no waiting for the tide. No long, boring ceremony. It’s like you thought about building the castle and it just appeared. This is the first piece of V magic: it’s fast. So fast it feels like a pleasant dream.

---

So what are we building with? Let's get some magic buckets and shovels. In V, we make a new bucket for our sand (or numbers, or words) with a little colon-equals :=. It’s like a magic wand. Poof! A bucket.

fn main() {
    message := 'This is a secret note in a bottle.'
    bottles_found := 1
    is_a_treasure := true

    println(message)
    println(bottles_found)
}

See? := looks at what you’re putting in the bucket and says, “Aha! This is a sentence, so this is a string bucket! Aha! This is a number, so this is an int bucket!” It figures it out for you. It’s smart, but not in a scary way. In a helpful, "let me get that for you" way.

What if you want to change what’s in the bucket later? You just have to ask nicely by telling V it's a "mutable" bucket.

mut bottles_found := 1
println('I found ${bottles_found} bottle!') // <-- A fun way to put stuff in strings!
bottles_found = bottles_found + 1
println('Oh wow! Now I have ${bottles_found} bottles!')

The mut keyword is like a little permission slip that says, "It's okay, I might change my mind about this later." And V says, "Okay, sounds good to me!"

---

Now, every good castle builder has a set of blueprints. In programming, we call these functions. A function is just a recipe for doing something.

Let’s write a recipe for greeting all the friendly crabs on the beach.

fn greet_crab(name string) {
    println('Hello there, little ${name} crab!')
}

fn main() {
    greet_crab('Pinchy')
    greet_crab('Scuttle')
}

This is so lovely! We made a recipe called greet_crab. It needs one ingredient: a name which must be a string. Then it follows the instruction. We can use our recipe over and over! This is how we build big, amazing things from small, simple pieces.

But what if a function is supposed to give you something back? Like a treasure map?

fn find_treasure_map(location string) ?string {
    if location == 'under the big rock' {
        return 'A map to the Glimmering Caves!'
    }
    return none // Oh no! No map here!
}

fn main() {
    map := find_treasure_map('in the seaweed') or {
        println('Curses, no map here. I guess I will build a sand-dog.')
        return // We stop looking
    }

    println('I found it! ${map}')
}

WHOA. Okay, let’s look. See that little ?string? That’s V’s way of saying, “I will try to give you a string, but I might not find one!” It’s honest. I love that.

This is V’s answer to Rust’s powerful but sometimes complicated Result. Instead of a big match statement, V gives us a little or {} block. It’s a little lifeboat. If the function returns none (the treasure map wasn’t there!), we hop in the lifeboat and do something else. It’s safe, like Rust, but it feels light and breezy, like Lua. It’s just... pleasant. No more nil errors surprising you out of nowhere! The compiler makes sure you have a lifeboat for every treasure hunt.

---

~<3~

Okay, last big secret. Sometimes you need to do a million things at once. You need to watch for pirates, dig the moat, and pat your sand-dog all at the same time.

In other languages, this can be a huge headache. A big, tangled mess of yarn.

In V, you just say "go."

fn watch_for_pirates() {
    // ... look at the horizon for a while ...
    println('Pirate watch is done! All clear!')
}

fn dig_moat() {
    // ... move a lot of sand ...
    println('Moat has been dug!')
}

fn main() {
    go watch_for_pirates() // <-- THE MAGIC WORD!
    dig_moat()
    // some way to wait for the go routine to finish would be needed in a real app
    // but let's just enjoy the idea for now! :)
}

That little go keyword is like tapping your friend on the shoulder and saying, “Hey, can you go watch for pirates for me? I’m gonna dig this moat.” And your friend just does it! At the same time! It’s that simple to start. It’s like the language was built for teamwork from the very beginning.

So why Vlang everyday?

Because it feels like a friend is helping you. It’s blazingly fast, so you never lose your flow. It’s safe, so your sandcastle doesn’t fall over unexpectedly. It lets you write simple recipes and build them into grand towers. It’s honest about things that might go wrong.

---

P.S. How to Invite Vee-Bot to Your Computer!

"Júlia, Júlia!" you might be shouting. "This is all wonderful, but Vee-Bot isn't on my computer! How do I get him here?"

Oh, that's the best part! It's super easy. A friend and I made a tiny little helper program to handle it all for you. We call it vvm, the V Version Manager. It's like a special teleportation pad for Vee-Bot.

A little note for my friends using Windows! This whole adventure will be much smoother and more secure if you use a magic window called WSL (Windows Subsystem for Linux). It gives you a little Linux playground right inside Windows where everything just works. If you have it, open it up now!

Okay, ready? To get my little helper, vvm, you first need to grab its schematics from a place called GitHub. It's like a giant library of code spells! Just type this into your terminal:

git clone https://github.com/kleeedolinux/vversionmanager

This copies the blueprints into a new folder. Now, step inside that folder:

cd vversionmanager

You're standing right next to the helper program! To give it its powers and make it available everywhere, you just run this command. It's like asking your computer for a super-powered permission slip.

sudo ./vvm install-self

This tucks vvm away in a place where you can call it from anywhere! Now, for the real magic.

To invite V to your computer for the very first time, just tell your little helper:

vvm install

This little command is so smart. It runs around and finds all the right tools for V, downloads V's latest source code, builds it into the shiny Vee-Bot you know and love, and puts a little shortcut in /usr/local/bin so you can just type v whenever you want to talk to him.

Is there a new version of V with even more cool tricks? Just tell your helper to get the update!

vvm update

And if you need V to pack his bags for a little while, the helper can do that too, cleaning everything up neatly.

vvm uninstall

If you ever forget these magic words, just ask the helper! It will always remind you.

vvm help

Okay, now you're ready. You have the tools. You have the friend.

Go build something wonderful.

v run your_dream.v

...zip!

<3, Júlia