<img src="https://s3.us-east-1.amazonaws.com/resource.mixa.site/valhallaresearch/Media/DALL%C2%B7E%202023-11-06%2013.43.08%20-%20crab%20in%209%20different%20art%20styles%20across%209%20equally%20sized%20tiles,%20colorful,%20realistic,%20eye-catching.png" priority="1"> 
Vectors are very similar to arrays in any other language with a couple of Rust specialties thrown in. I'll be cribbing some information, as well as the example code, from the <a href="https://doc.rust-lang.org/rust-by-example/std/vec.html">Rust By Example docs</a>so you can follow along there if you'd like.
Since Rust is a low level language, you do, in fact, have to worry about memory. In C, variable length arrays are strictly a no-no and require some fancy workarounds (or C++) to achieve. In Rust, each vector has a length and a capacity, and when the length (or the number of slots that are actively being used to store data) exceeds the capacity (functionally the memory that is allocated to store data with) then there is a reallocation that takes place. This, I would guess, will lead to a performance hit, but that's a guess more than anything, and is sort of beside the point.
Vectors use the <code>push</code> and <code>pop</code> verbiage to append to them, which I love, and can be accessed via index just like any other array. You can instantiate a vector with or without an initial capacity. I would imagine instantiating it with a largest-likely capacity is probably good for performance reasons, but, again, a guess.
<pre><code>fn main() {
	// Creates an unsized vector
 let mut implicit_size : Vec&#x3C;i32> = vec![];
 // Pushes 5 and 6 to said vector
 implicit_size.push(5);
 implicit_size.push(6);
 print!("implicit_size: {:?}\n", implicit_size);
 // Creates a vector of size 5 and initializes all values to 1
 let mut explicit_size : Vec&#x3C;i32> = vec![1; 5];
 print!("explicit_size: {:?}\n", explicit_size)
}
Output:
implicit_size: [5, 6]
explicit_size: [1, 1, 1, 1, 1]
</code></pre>
You can also iterate over vectors by using the <code>.iter()</code> function.
<pre><code>fn main() {
 
 let ex = vec![1,5,7,2,4,1,3];
 for item in ex.iter(){
 print!("Item {}\n",item);
 }
}
Output:
Item 1
Item 5
Item 7
Item 2
Item 4
Item 1
Item 3
</code></pre>
In true Rust fashion, the items you're iterating over are immutable by default, so if you want to mutate the array, you have to use <code>iter_mut()</code> on a mutable vector, like so:
<pre><code>fn main() {
 
 let mut ex = vec![1,5,7,2,4,1,3];
 for item in ex.iter_mut(){
 print!("Item {}\n",item);
 *item *= 2;
 }
 print!("ex: {:?}\n",ex)
}

</code></pre>
I truly love that Rust makes mutability explicit in every interaction you have with the language. A lot of people may view it as an unnecessary speedbump but making the developer understand "this structure is mutable, this one is read only" is incredibly important in my opinion.

Vectors in Rust are fairly similar to arrays in just about every other language.

Rust Vectors

Making My Way Through the Rust Book

Rust's poem_api makes REST API development easy and swagger documentation even easier

Backend API's with Rust's poem_openapi

Creating a DigitalOcean Droplet with Golang

Delaying GrabbrApp's Launch

Full-Stackism and Being a Well-Rounded Developer

Golang Microservices - How to Make a Golang Lambda Function

Pushing the Pico - D3d_Dr0p and Hyperlocal E-Graffiti

There are a lot of languages to pick from. Here is why I think you should pick a couple, and be open to experiment with more

Should you learn multiple programming languages?

Terraform - The Basics

The Gin Framework - REST API's with Golang

Writing is Dead and Meetings are Killing It

CODE MOC

Go Routines - Wicked Fast Concurrency in Golang

Atomic Habits

01_BOOK NOTES MOC

WIP Antifragile - Nassim Taleb

WIP Revolt - Nadav Eyal

Digital Gardens

Junior Developer's Resume

We'd love to believe that we're logical thinkers, but I think there's danger in it

Logical vs. Critical Thinking

Disruption Isn't Just Moving Money Around

Personal Knowledge Management (PKM)

On making a move away from research blogging and toward just research

The Obsidian Switch

The Tightening Belt

Zettelkasten Method

01_NONTECH MOC

WIP - The Qakbot Takedown

Detection engineering isn't just stopping badness. Unfortunately, false positives and false negatives, as well as mis-detections, make it much more complex

Detection Engineering: False Positives, False Negatives and Mis-Detections

1 November 2023 GrabbrApp Update

Rewrite-It-In-Rust seems like it's become a meme, but I started to see the light pretty quickly

Goodbye Golang Microservices, and Hello Rust Monoservice

26 September - Poking around with the Go compiler

22 September - Initial Irritation

16 October - Awesome SANS talk on Golang RE

WIP - Reverse Engineering GoLang Binaries

01_SECURITY_MOC

01_Research MOC

02_DATA_MOC

29 August 2023 - Check Point Shares Analysis of Qakbot Malware Group - Check Point

13 July 2023 - Avast - Go Malware on the Rise

30 August 2023 - Qakbot Malware Takedown and Defending Forward - John Hammond via Huntress

29 September 2021 - Reversing in action - Golang malware used in the SolarWinds attack

29 August 2023 - Qakbot Malware Disrupted in International Cyber Takedown - US FBI