---
# System prepended metadata

title: Week 4 recap

---


<h1>Week 4 Recap: Blockfuse Labs Software Engineering</h1>



Reflecting on the past week at **Blockfuse Labs** felt like being dropped into two different worlds one ruled by silence and precision, the other by conversation and clarity. And somehow, we were expected to thrive in both.

We started off in the land of **Vim** and if you know, you know. Hmmmm, this was another level, telling me I needed to exhibit a lot of patience.

<h3>
    I Won't Lie, Vim has Taught Me Patience
</h3>

If VS Code is like working in a modern studio, **Vim** is like being handed a quill and told, “Figure it out.”
And so we did, one command at a time.

We learned that Vim has modes and switching between them is the first key to survival: You have to have a good sense of reasoning andn knowing fully well that `mode change` is important. Your go-to for mode change is always the `esc` key. By default, when you enter vim, the default mode is always `normal mode` 

* `Normal mode` — where you move around
* `Insert mode` — where you actually type
* `Visual mode` — for selecting text
* `Command mode` — for saving, quitting, and more

The moment it clicked that we had to press `i` to **insert**, and `Esc` to get back to **normal**, something shifted. If you thoguht it was about just typing, then you are wrong, it was actually about thinking differently.

We learned a lot of essential commands that can help beginners like myself get acquainted with the vim environment. Some of those commands include:

* `:w` — to save
* `:q` — to quit
* `:wq` — save and quit
* `dd` — delete a whole line
* `yy` — copy a line
* `p` — paste
* `u` — undo

Suddenly, editing text became something we had control over, not with a mouse again (truth be told, i was used to mouse a lot), but with intention.
It was frustrating at first, but slowly, Vim began to teach us something no modern editor could:

> **Discipline. Awareness. Patience.**


**Then Came Python: The Language That Talks Back**

Just when we were settling into the rhythm of Vim, we were introduced to **Python** and it felt like taking a breath of fresh air.

Python doesn’t ask for too much. It’s high-level, simple, and clean.
Our instructor explained that Python is an **interpreted language**, meaning it reads your code line by line, without the need for compiling. It’s like talking directly to your machine, and it responding immediately.



 **Let’s Talk Variables**

We learned that a **variable** in Python is just a name pointing to a value. So variables are containers that store data. And every programming language has variables as they form an essential part in it.

```python
name = "Ada"
age = 22
height = 5.6
```

No type declarations. No syntax overload. Just assignment.

We even explored **different ways to assign** variables:

```python
x, y, z = 1, 2, 3        # Multiple assignment
a = b = c = 0            # Same value for multiple variables
```

It was neat. It was smart. And most of all, it made sense.

**Type Conversion: Making Data Speak the Right Way**

Sometimes you need to switch things up. Like turning a number into a string, or a string into a float. But what is even the need of that in the first plcae. Now, you have to understand that when the `input` keyword is used in python, which of course is used to collect input from users, its default data type is `string` whci is just plain text `"Sughnen"`, denoted by single or double quotation mark. Now, if such input is going to be a number, there will need to convert it.

Take the example below;
`number = input("Enter the numer")`
By default, the above data type is a string, in as much as we expect the user to type in a number, the program will still accept anything typed in, now to handle that, we have to convert it to either a float or integer.

See example below;
`number = int(input("Enter the number"))`
At this point, the program will only accept numbers and no longer text or special characters.
You can aslo check other ones below.


Python makes that easy with:

```python
int("10")       # 10 as integer
float("3.14")   # 3.14 as float
str(42)         # "42" as string
```

You have to be warned, not everything converts cleanly.
Try `int("hello")` if you do that, pyhton will definitely throw you an error message.

This where it got interesting as far as the learnming is concerned, we learned syntax. Yes, we practiced commands.
But the real lesson was deeper:

* **Vim** taught us to **slow down and think.**
* **Python** taught us to **express ideas clearly.**

We didn’t just learn tools, we learned **how to learn**.
We started writing code not as strangers, but as thinkers.



The truth about the past week was about letting go of old habits, learning the logic behind the tools, and discovering that programming isn’t just about writing code, it’s about how you think.



