Ok ok, I'll start


Day 2, let's go!

This morning I was reading this post on how to [create a text editor in Rust](https://www.philippflenker.com/hecto), and at [some point](https://www.philippflenker.com/hecto-chapter-2) it said that Rust supports variable shadowing, and not only that, it was referred to as "immensely useful".

🤔

That got me curious! I work with TypeScript mostly, for React Native projects, and variable shadowing is a "bad" thing in JS and friends, here's the [eslint rule](https://eslint.org/docs/rules/no-shadow) for it too. Normally it's something to be avoided in JS, since it can have weird unexpected side-effects. See this code below:

```ts
const name = "alice"
if (true) {
	const name = "bette"
	if (true) {
		console.log(name)
	}
}
console.log(name)
```

(You can play with the code above [here](https://www.typescriptlang.org/play?#code/MYewdgzgLgBGCGBbApjAvDARPANgS2GUwCg8AzGACigCcBXZAShgG9iBIUSWBFdLAEbIoUIh3JVaDZm3adwEEDmQA6HCADmlXkw4BfYga6LlazdqTIgA).)

In this code, first of all, notice that typescript complains about the shadowing. Even with that complaint, it will let you run, so hit `Run` on top, and if you open your browser console you will see the following printed:

```
bette
alice
```

Variables are declared in scopes and accessed that way. The nested `console.log` will look for a `name` in the inner `if` scope. There is none, so it will go one up, and find the `name` with the value `"bette"` and print that out. The bottom `console.log` will look in its scope, which is the global, outermost scope. It will find the `name` with value `"alice"`, and print that one out.

Let's check what Rust does:

```rust
let name = "alice";
if true {
	let name = "bette";
	if true {
		println!("{}", name);
	}
}
println!("{}", name);
```
(You can play with this code [here](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=132fd25d73a6b8971836c510e4eaf4b2).)

If we run this, we will see that it does.. exactly the same?! Hm. So why the same exact code a "bad" thing in JS and an "immensely useful" thing in Rust?

After reading a bit more about the usage of shadowing in Rust, it seems that it is mostly used for doing some processing on an immutable variable without having to make it mutable. Let's check!

```rust
let name = "chloe";
let name = name.to_string().to_uppercase();
// name = "dana"; // => this would produce error[E0384]: cannot assign twice to immutable variable `name`.
// let name = "dana"; // => this would work.
println!("{}", name);
```
(Available [here](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=5720a2aa93c46a7feb557c7c3fc7e443).)

We can see here that we declare `name`, assign `"chloe"` to it, and then we shadow it and make the value uppercase. This code will print out `CHLOE`, **and** it will complain if we try to assign anything else to `name`, unless we explicitly shadow it again.

Let's try the same in TS 😬.

```ts
// const name = "chloe"
// const name = name.toUpperCase() // We can't do that!

let name = "chloe"
name = name.toUpperCase()
name = "dana"; // => this will work, so our `name` is not immutable!
console.log(name)
```
(Available [here](https://www.typescriptlang.org/play?#code/PTAEGMHsDsGcBdTQIYFsCmoC8oBE4ALAG0nVwCgQIYEk1McUMA6eSAVQAdP0AnAYWSx0ACgCU5ckXSImDPIRJlyc7HRZsuPAUNETVOXABNkKXAG5QVLAD5Q8AgEtYoAO6OiRN5F4BrADSgsJCgkACuvKAABnJRoM5IkIiOqKhh8MgARtIAhORQcJDSzCQA5iJyEkA).)

We can't do it! The only way we can make this work is by making `name` mutable, but then it stays mutable. Forever mutable. Forever easy to break! Ok, a bit dramatic, but you get what I mean. We lose immutability on `name`.

Under that new light, it does make sense that Rust *wants* and *likes* to have variable shadowing. It takes something that could result to funkiness and uses it for good!

If we wanted to do the same in TS, it would be a bit roundabout, using something like the following, which works, but uses extra variables.

```ts
let namePreparation = "chloe"
namePreparation = namePreparation.toUpperCase()
const name = namePreparation
// name = "dana" // => this would produce a TS error
console.log(name)
```
([Here](https://www.typescriptlang.org/play?#code/DYUwLgBAdghgtiACgJxABxsmYCWB7KCAXggCIBjAC2DxFIChYEV1Nt9CSmlUMtcCAOjB4AqmjQhkAYRgBnEAAoAlPXIE5kbsWjwerfh3oB6Y7oQ7SAExixSEU8QB8EMJRxyIAdzwBXYFYQaMh4Vr7kIBAwEAAqAMoQUiHIahp4oII0AOaK3MpAA).)

I'm sure it could be done in an inline function to avoid the extra variable. Let's try.

```ts
const name = (() => {
    let namePreparation = "chloe"
    return namePreparation.toUpperCase()
})()
```
([Here](https://www.typescriptlang.org/play?ssl=4&ssc=5&pln=1&pc=1#code/MYewdgzgLgBGCGBbApjAvDAFJglOgfDAN4BQM5MANsrAigAoBOyADvI-FAJbjowBEwABaUQyfmQrMoAV0Zg4SZE1btOPMADooIAKosWyRgGF4EZLhIBfHJYD0dxSj78AJvAT8YDgjChCuCBgAdxAZSlcYFkYQVxlgVHgYABUAZRgjGMYSUEgQak1RAHNMOmQcIA).)

That's cool that we can do it, but it is obvious that the simplicity of Rust's code is nice to look at.

```rust
let name = "chloe";
let name = name.to_string().to_uppercase();
```

Wow, this turned out to be a way longer post than I thought. Cool.


Rust likes variable shadowing?


I just read [this blog post](https://critter.blog/2020/12/24/just-start-a-dang-blog-already) and all its links, and yes. I agree, and I will do it. I'll try to do one post a day. Or let's aim for 5 a week, and leave weekends out, just in case I need so skip a day or two.

I really liked another post, called "[Intense intervention or acceptance. Pick one.](https://critter.blog/2020/11/24/intense-intervention-or-acceptance-pick-one)". Good title, and a good way to look at things. I've been postponing this for no reason other than it's not my first priority.

After trying this out for a week or two, I will be able to definitely say that I want to spend time doing this, or I still don't care for it enough. Either way it will help me get it out of my head. Done it? Cool, let's schedule it and keep doing it. Not done it? All good, and from now on if the thought "I should start a blog" comes, I can tell it to gtfo because I did try it and it didn't seem good enough to keep it up.

See you soon, I guess.



In the beginning of September I was in Poland for the React Native EU conference. It's the biggest european conference focused on React Native, which is the technology we use to build our NiceDay app for both iOS and Android. There are a bunch of them all over the world, some for React Native and some for React (which is a similar technology to build a website). Each of the conferences invites people to become speakers, and this year for this conference I got invited to give a talk on the topic of upgrading React Native apps.

For context, a lot of developers that use React Native have trouble upgrading their apps when a new version comes out. I always had a specific way to upgrade that was working well for me and a few other devs that I had talked to. I took a script that helped me and modified it to work with all the versions of RN. It would generate some files that could be used by devs. It made upgrading easier by making the differences between version more understandable and clear. Then I made a simple website that could display these files. After this got a few users, and even some contributors, I was invited to talk in that conference, in order to show it to everyone that was interested. Some of the people attending the conference were using my "upgrade flow", but a lot of them were not, so the idea was that I will present it, explain it, and hopefully help RN devs when they googled how to upgrade easily.

I've never done another talk before, not in any conference or any meetup, so it was a new thing for me, but I immediately said yes to the invitation. I had been in conferences before, but being there as one of the speakers was such a different and awesome experience. I got the chance to meet and talk to all the other speakers in the speakers dinner the day before the conference, as well as in the hotel in the morning and going out in the evening. I've seen other talks from some of them, I've talked and work with some of them, but always online. It was so great to finally meet all of them in person, and even better to hear that they were impressed with what I had done, that they look forward to seeing my talk and to see that some of them even recognized me!

The talks in the conference were great, many of them very interesting and informative. It seemed that many people enjoyed seeing the talks and I think everyone got something out of them. In the coffee/launch breaks I talked with a lot of people there, speakers and attendees, from small companies and startups all over Europe, to Microsoft and Facebook from the US offices. I enjoyed exchanging our experiences working with RN, both using it to make an app and improving it or building a tool for it in and sharing it with open source community.

In my talk I basically explained how this script that generates the change files works, how the website for it was built, I showed the flow of upgrading a RN app using these tools, and the reasons why it's good to use it. Before my talk I had people come up to me saying they look forward to my talk, and after it I had people come up to me saying that they really enjoyed it and they want to try it out. I really hope it helped a lot of RN devs, experienced and not.

In general, this was a great experience, I enjoyed it a lot and I hope I get invited for another one again!

[Link to conference](https://react-native.eu)

[Link to videos](https://www.youtube.com/channel/UCbvLih553T7f5OAGTfbsJkQ/videos)

[Link to photos](https://www.facebook.com/pg/reactnativeeu/photos/?tab=album&album_id=658228464664869)
