Building a Blog

Mon, 05 Jul 2021 21:44:36 -0700

Creating a blog is easy enough if you want to use something like Weebly or Wix, but I’m the kind of person who wants such granular control over everything that I would rather create a blog programmatically than have something else do it for me. On the plus side, I get to flex my programming skills while having something to show off that isn’t professionally related.

As a site generator, Hugo is actually quite nice. It’s versatile, but it doesn’t get in your way. In some sense, it’s actually the perfect site generator. The only real holdup is how difficult it seems to be to make your own theme from scratch, but that’s why the community has made so many themes. You can then just overwrite whatever bits you want and Hugo does the rest.

The name is a little eh *hand waves*, in my opinion. Not a huge fan of it, if only because Hugo’s never been a name to fully appeal to me.

If your name is Hugo, don’t take that as an offence. Just means I won’t name my own kid Hugo.

Rust, Part One

Thu, 04 Mar 2021 20:39:45 -0800

What is Rust?

In short, a programming language focused on memory safety. Compiled like C/C++. Has a lot of neat features. Let’s talk about that.

Why Rust?

Among other things, Rust is built to be modern. It has its own dependency manager (cargo) which allows you to easily get the modules and components you need.

I used to thoroughly dislike Rust, but that was because I wasn’t approaching it the right way. You see, Rust’s whole philosophy is built around making safe code from the get-go. Evidently, the C++ code I was writing wasn’t safe, at least from Rust’s perspective. So I suppose I ought to explain Rust’s whole approach to memory management.

Suppose you have two variables, each initialized with the same value.

let x = 2;
let y = 2;

Both x and y now own their own respective values of 2. Now, say we do this:

let y = x;

At this point, x may as well have gone out of scope. Rust has a particularly fickle way of dealing with memory, and insists that when you use a variable somewhere, unless you ‘borrow’ it, that variable is no longer of use outside of where it got used. This confused and frustrated me greatly; C and C++ don’t have this problem, because memory isn’t constantly treated like a resource that needs to be tracked (unless you’re doing things with threads, in which case if you’re not using mutexes or semaphores, I would highly recommend looking into how that works).

So, if you wish to give a variable another variable’s value without moving said value, you must explicitly declare so:

let x = 2;
let y = &x;

As a programmer coming from C++ to Rust, this convention is not immediately clear.

Classes

Rust doesn’t have object-oriented support in the ‘typical’ sense (typical meaning having tokens such as class). Much like C, ‘classes’ are simply structs. Coming from a C++ perspective, the inability to define proper classes becomes jarring, but realistically, Rust’s structs are effectively the same thing.

Defining a struct in Rust is somewhat similar to JavaScript, except that instead of defining values when you define the struct, you define the types:

struct computer {
ram: i8,
cpu: String,
gpu: String
};

Then, when initializing an instance (object) of said struct, you can then define the values:

let p = computer {
ram: 16,
cpu: String::from("some cpu"),
gpu: String::from("some gpu")
};

Here’s where we run into another fun (frustrating) aspect of Rust: types.

Types

C++ and like languages don’t usually care how you deal with types because, for the most part, everything’s the same. Numbers can be interchangably compared with other numbers of different types, and strings are not considered different types (unless you’re using C-style strings, but maybe that will be for the next post). The developers of Rust, in their infinite wisdom and endless pedantry, decided that the strings "this" and "this" are not the same if the former is of type &str (a string slice), and the latter of type String (a string object). The difference here comes down to how each is allocated in memory. A string slice, much like a C-style string, is a fixed size allocated on the stack and cannot be expanded or shrunk, only altered in its original size. A string object, on the other hand is allocated on the heap, meaning that you can expand or shrink it as you please, messing around with it without fear of messing around with other memory. This has the practial upshot of ???.

I haven’t even gotten into the different integer types in Rust. There are separate bit sizes for each amount of memory you could want to allocate to a given integer variable. I presume this is a memory-saving measure, since sometimes you don’t need to use 16 bits just for one number. However, this has the effect of making my life harder because I just want to type int when specifying a struct data member’s type. Wah.

Comparing data between variables of different types is only a slight hassle, if only because you have to explicitly cast one variable to the other’s type. Most other languages make some base assumptions about comparing types, but as Rust wants to be safe and not cause bugs that can occur in these situations, it forces explicit casting.