mahdi

What is `Box` and how is it different from `String` in Rust?

Thu, 16 Jun 2022 01:00:00 +0100

Today I and a friend went down a rabbit hole about Rust and how it manages the heap when we use Box, or String, or Vec, and while we were at it, I found out there is such a thing as Box<str>, which might look a bit strange to an untrained eye, since most of the time the str primitive type is passed around as &str.

TL;DR:

Box<str> is a primitive str allocated on the heap, whereas String is actually a Vec<u8>, also allocated on the heap, which allows for efficient removals and appends. Box<str> (16 bytes) uses less memory than String (24 bytes).

I will be using rust-lldb throughout this post to understand what is going on in the rust programs we write and run. The source code for this blog post is available on mdibaiee/rust-memory-playground.

git clone https://git.mahdi.blog/mahdi/rust-memory-playground
cd rust-memory-playground

The Stack

Most of the primitive data types used throughout a program, and the information about the program itself are usually allocated on the stack. Consider this simple program:

fn add_ten(a: u8) -> u8 {
    let b = 10;
    a + b
}


fn main() {
    println!("{}", add_ten(9));
}

Let’s examine the stack when we are running a + b by setting a breakpoint on that line:

$ cargo build && rust-lldb target/debug/stack-program

(lldb) breakpoint set -f main.rs -l 3
Breakpoint 1: where = stack-program`stack_program::add_ten::h42edbf0bdcb04851 + 24 at main.rs:3:5, address = 0x0000000100001354

(lldb) run
Process 65188 launched: '/Users/mahdi/workshop/rust-memory-playground/target/debug/stack-program' (arm64)
Process 65188 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x0000000100001354 stack-program`stack_program::add_ten::h42edbf0bdcb04851(a=5) at main.rs:3:5
   1    fn add_ten(a: u8) -> u8 {
   2        let b = 10;
-> 3        a + b
   4    }
   5
   6
   7    fn main() {
   
(lldb) frame var -L -f X
0x000000016fdfed7e: (unsigned char) a = 0x09
0x000000016fdfed7f: (unsigned char) b = 0x0A

Our program allocates two variables on the stack directly here. Notice that they are allocated right next to each other, their address only one bit apart. Most primitive types are allocated on the stack, and are copied when being passed around because they are small enough, so that copying them around is more reasonable than allocating them in the heap and passing around a pointer to them. In this case, u8 can be allocated in a single byte, it would not make sense for us to allocate a pointer (which can vary in size, but are usually larger than 8 bytes). Every time you call a function, a copy of the values passed to it, along with the values defined in the function itself constitute the stack of that function.

The stack of a whole program includes more information though, such as the backtrace, which allows the program to know how to navigate: once I am done with this function, where should I return to? that information is available in the stack as well. Note the first couple of lines here, indicating that we are currently in stack_program::add_then, and we came here from stack_program::main, and so once we are finished with add_then, we will go back to main:

(lldb) thread backtrace
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
  * frame #0: 0x0000000100001350 stack-program`stack_program::add_ten::hf7dc9cccae290c37(a='\t') at main.rs:3:5
    frame #1: 0x00000001000013a8 stack-program`stack_program::main::he22b9cf577b52c34 at main.rs:8:20
    frame #2: 0x00000001000015a4 stack-program`core::ops::function::FnOnce::call_once::hd6bac0cd3fcb8c07((null)=(stack-program`stack_program::main::he22b9cf577b52c34 at main.rs:7), (null)=<unavailable>) at function.rs:227:5
    frame #3: 0x00000001000014c4 stack-program`std::sys_common::backtrace::__rust_begin_short_backtrace::hc4df46810f9a7139(f=(stack-program`stack_program::main::he22b9cf577b52c34 at main.rs:7)) at backtrace.rs:122:18
    frame #4: 0x0000000100001178 stack-program`std::rt::lang_start::_$u7b$$u7b$closure$u7d$$u7d$::hbec5b809d627978a at rt.rs:145:18
    frame #5: 0x000000010001440c stack-program`std::rt::lang_start_internal::hc453db0ee48af82e [inlined] core::ops::function::impls::_$LT$impl$u20$core..ops..function..FnOnce$LT$A$GT$$u20$for$u20$$RF$F$GT$::call_once::h485d4c2966ec30a8 at function.rs:259:13 [opt]
    frame #6: 0x0000000100014400 stack-program`std::rt::lang_start_internal::hc453db0ee48af82e [inlined] std::panicking::try::do_call::h375a887be0bea938 at panicking.rs:492:40 [opt]
    frame #7: 0x0000000100014400 stack-program`std::rt::lang_start_internal::hc453db0ee48af82e [inlined] std::panicking::try::hecad40482ef3be15 at panicking.rs:456:19 [opt]
    frame #8: 0x0000000100014400 stack-program`std::rt::lang_start_internal::hc453db0ee48af82e [inlined] std::panic::catch_unwind::haf1f664eb41a88eb at panic.rs:137:14 [opt]
    frame #9: 0x0000000100014400 stack-program`std::rt::lang_start_internal::hc453db0ee48af82e [inlined] std::rt::lang_start_internal::_$u7b$$u7b$closure$u7d$$u7d$::h976eba434e9ff4cf at rt.rs:128:48 [opt]
    frame #10: 0x0000000100014400 stack-program`std::rt::lang_start_internal::hc453db0ee48af82e [inlined] std::panicking::try::do_call::h8f2501ab92e340b0 at panicking.rs:492:40 [opt]
    frame #11: 0x0000000100014400 stack-program`std::rt::lang_start_internal::hc453db0ee48af82e [inlined] std::panicking::try::hbeb9f8df83454d42 at panicking.rs:456:19 [opt]
    frame #12: 0x0000000100014400 stack-program`std::rt::lang_start_internal::hc453db0ee48af82e [inlined] std::panic::catch_unwind::h0a9390b2202af6e9 at panic.rs:137:14 [opt]
    frame #13: 0x0000000100014400 stack-program`std::rt::lang_start_internal::hc453db0ee48af82e at rt.rs:128:20 [opt]
    frame #14: 0x0000000100001140 stack-program`std::rt::lang_start::h69bdd2191bba2dab(main=(stack-program`stack_program::main::he22b9cf577b52c34 at main.rs:7), argc=1, argv=0x000000016fdff168) at rt.rs:144:17
    frame #15: 0x0000000100001434 stack-program`main + 32
    frame #16: 0x00000001000750f4 dyld`start + 520

Box, String and Vec: Pointers to Heap

There are times when we are working with data types large enough that we would really like to avoid copying them when we are passing them around. Let’s say you have just copied a file that is 1,000,000 bytes (1Mb) in size. In this case it is much more memory and compute efficient to have a pointer to this value (8 bytes) rather than copying all the 1,000,000 bytes.

This is where types such as Box, String and Vec come into play: these types allow you to allocate something on heap, which is a chunk of memory separate from the stack that you can allocate on, and later reference those values using a pointer available on the stack.

Let’s start with Box, the most generic one, which allows you to allocate some data on the heap, consider this example:

fn main() {
    let a = Box::new(5_u8);
    let b = 10_u8;
    println!("{}, {}", a, b);
}

We again use lldb to check out what is happening:

$ cargo build && rust-lldb target/debug/stack-and-heap-program

(lldb) breakpoint set -f main.rs -l 4
Breakpoint 1: where = stack-and-heap-program`stack_and_heap_program::main::ha895783273646dc7 + 100 at main.rs:4:5, address = 0x0000000100005264

(lldb) run
Process 67451 launched: '/Users/mahdi/workshop/rust-memory-playground/target/debug/stack-and-heap-program' (arm64)
Process 67451 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x0000000100005264 stack-and-heap-program`stack_and_heap_program::main::ha895783273646dc7 at main.rs:4:5
   1    fn main() {
   2        let a = Box::new(5_u8);
   3        let b = 10_u8;
-> 4        println!("{}, {}", a, b);
   5    }
   
(lldb) frame var -L -f X
0x000000016fdfed48: (unsigned char *) a = 0x0000600000008010 "\U00000005"
0x000000016fdfed57: (unsigned char) b = 0x0A

(lldb) memory read -count 1 -f X 0x0000600000008010
0x600000008010: 0x05

Note that here, instead of a having the value 5, has the value 0x0000600000008010, which is a pointer to a location in memory! lldb is recognises that this is a pointer (note the * sign beside the variable type) and shows us what the memory location contains, but we can also directly read that memory location, and of course we find 5 there. The address of the heap-allocated 5 is far from the stack-allocated 10, since stack and heap are separate parts of memory.

Using Box for an unsigned 8-bit value does not really make sense, the value itself is smaller than the pointer created by Box, however allocating on heap is useful when we have data that we need be able to pass around the program without copying it.

Turns out, String and Vec cover two of the most common cases where we may want to allocate something on heap! Let’s look at what goes on behind allocating a variable of type String:

fn main() {
    let s = String::from("hello");
    println!("{}", s);
}

And here we go again:

(lldb) breakpoint set -f main.rs -l 3
Breakpoint 1: where = string-program`string_program::main::h64ca96ee87b0ceaf + 44 at main.rs:3:5, address = 0x000000010000476c

(lldb) run
Process 68317 launched: '/Users/mahdi/workshop/rust-memory-playground/target/debug/string-program' (arm64)
Process 68317 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x000000010000476c string-program`string_program::main::h64ca96ee87b0ceaf at main.rs:3:5
   1    fn main() {
   2        let s = String::from("hello");
-> 3        println!("{}", s);
   4    }
   
(lldb) frame var -L -T
0x000000016fdfed78: (alloc::string::String) s = "hello" {
0x000000016fdfed78:   (alloc::vec::Vec<unsigned char, alloc::alloc::Global>) vec = size=5 {
0x0000600000004010:     (unsigned char) [0] = 'h'
0x0000600000004011:     (unsigned char) [1] = 'e'
0x0000600000004012:     (unsigned char) [2] = 'l'
0x0000600000004013:     (unsigned char) [3] = 'l'
0x0000600000004014:     (unsigned char) [4] = 'o'
  }
}

This is a formatted output from lldb, and here you can see that the String type is basically a Vec<unsigned char, alloc::Global> (note that unsigned char is represented using u8 in Rust, so in Rust terminology the type is Vec<u8>), let’s now look at the same command but this time raw and unformatted (-R):

(lldb) frame var -L -T -R
0x000000016fdfed78: (alloc::string::String) s = {
0x000000016fdfed78:   (alloc::vec::Vec<unsigned char, alloc::alloc::Global>) vec = {
0x000000016fdfed78:     (alloc::raw_vec::RawVec<unsigned char, alloc::alloc::Global>) buf = {
0x000000016fdfed78:       (core::ptr::unique::Unique<unsigned char>) ptr = {
0x000000016fdfed78:         (unsigned char *) pointer = 0x0000600000004010
0x000000016fdfed78:         (core::marker::PhantomData<unsigned char>) _marker = {}
      }
0x000000016fdfed80:       (unsigned long) cap = 6
0x000000016fdfed78:       (alloc::alloc::Global) alloc = {}
    }
0x000000016fdfed88:     (unsigned long) len = 6
  }
}

Ah! I see the ptr field of RawVec with a value of 0x0000600000004010, that is the memory address of the beginning of our string (namely the h of our hello)! There is also cap and len, which respectively stand for capacity and length, with the value 6, indicating that our string is of capacity and length 6; the difference between the two being that you can have a Vec with a capacity of 10 while it has zero items, this would allow you to append 10 items to the Vec without having a new allocation for each append, making the process more efficient, and also a Vec is not automatically shrunk down in size when items are removed from it to avoid unnecessary deallocations, hence the length might be smaller than the capacity. So in a nutshell, our String is basically something like this (inspired by std::vec::Vec):

Stack:
--------------------------------
| String                       |
|     \-> Vec                  |
|          \-> (ptr, cap, len) |
|                |             |
-----------------|--------------
Heap:            v
-----------------------------
| ('h', 'e', 'l', 'l', 'o') |
-----------------------------

Okay, so far so good. We have String, which uses a Vec under the hood, which is represented by a pointer, capacity and length triplet.

If String is already heap-allocated, why would anyone want Box<str>!? Let’s look at how Box<str> would be represented in memory:

fn main() {
    let boxed_str: Box<str> = "hello".into();

    println!("boxed_str: {}", boxed_str);
}

And lldb tells us:

0x000000016fdfed80: (alloc::boxed::Box<>) boxed_str = {
0x000000016fdfed80:   data_ptr = 0x0000600000004010 "hello"
0x000000016fdfed88:   length = 5
}

Okay, so a Box<str> is much simpler than a String: there is no Vec, and no capacity, and the underlying data is a primitive str that does not allow efficient appending or removing. It is a smaller representation as well, due to the missing capacity field, comparing their memory size on stack using std::mem::size_of_val:

let boxed_str: Box<str> = "hello".into();
println!("size of boxed_str on stack: {}", std::mem::size_of_val(&boxed_str));

let s = String::from("hello");
println!("size of string on stack: {}", std::mem::size_of_val(&s));

Results in:

size of boxed_str on stack: 16
size of string on stack: 24

Note that their size on heap is the same, because they are both storing the bytes for hello on the heap (the measurements below show all of the heap allocations of the program, and not only the string. What matters here is that these two programs have exact same heap size in total):

$ cargo run --bin string-dhat
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/string-dhat`
hello
dhat: Total:     1,029 bytes in 2 blocks
dhat: At t-gmax: 1,029 bytes in 2 blocks
dhat: At t-end:  1,024 bytes in 1 blocks
dhat: The data has been saved to dhat-heap.json, and is viewable with dhat/dh_view.html

$ cargo run --bin box-str-dhat
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/box-str-dhat`
boxed_str: hello
dhat: Total:     1,029 bytes in 2 blocks
dhat: At t-gmax: 1,029 bytes in 2 blocks
dhat: At t-end:  1,024 bytes in 1 blocks
dhat: The data has been saved to dhat-heap.json, and is viewable with dhat/dh_view.html

There is also Box<[T]> which is the fixed size counterpart to Vec<T>.

Should I use `Box<str>` or `String`?

The only use case for Box<str> over String that I can think of, is optimising for memory usage when the string is fixed and you do not intend to append or remove from it. I looked for examples of Box<str> being used, and I found a few examples:

Hyper uses it in a part to reduce memory usage, since the string they have is read-only: hyper#2727
Rust-analyzer uses it to store some strings in their snippets data structre: rust-lang/rust-analyzer/crates/ide-completion/src/snippet.rs
It is also used in some parts in the compiler itself, probably with the same aim of optimising memory usage: rust-lang/rust/src/libsyntax/symbol.rs

On Inherent Subjectivity of Some Things

Sat, 30 Oct 2021 13:57:46 +0100

As a computer scientist and someone who loves mathematics and abstractions, I was obsessed with the idea of rationality, that is, an objective and absolute rationality, however I ended up in a philosophy course that showed me the opposite.

I somehow stumbled upon Eliezer Yudkowsky’s Rationality: From AI to Zombies about 4 years ago, and it took me two years to go through it all but I was absolutely fascinated by this book. I knew how to be rational now, and I could prove it using mathematics, what else could I ask for!

The book basically looks at the world as a probabilistic system, and everything that happens can be assigned probabilities, and using mathematical theorems such as Bayes Theorem, we can predict outcomes of certain actions and then decide between them. There is a lot of focus on cognitive biases as well. I was particularly very interested about these biases, and so I set out to learn more about them, and that’s how I found my current course: Cognitive Science at University College Dublin.

So I enter this course with this mindset: we can objectively analyse the world around us using probability and statistics (mathematics), but we are limited by our cognitive biases, so I want to learn about these cognitive biases: where do they come from, how can they be resisted to allow us to act more rationally and so on. These questions would mainly fall under the umbrella of psychology…

However… I found myself to be more and more interested in the philosophy side of this course than the psychology side, hell I even started to not like the psychology side anymore, but fall in love with the philosophy. This is where I found the opposite of what I had come for: an alternative definition of objectivity, and an inherent subjectivity of some things. This is mainly inspired by Thomas Nagel’s What Is It Like To Be A Bat (Nagel, 1974).

What is Objectivity Anyway?

This is probably the main question here. What is objectivity? I don’t think dictionary definitions are particularly authoritative when it comes to philosophy discussions, but I found this dictionary definition interesting to open the topic with:

the quality or character of being objective : lack of favoritism toward one side or another : freedom from bias. (Merriam-Webster, 2021)

This definition itself has ambiguous phrases such as “freedom from bias”, what does that mean? When can we say that we are free from bias? Let’s look at how bias is defined in the same dictionary:

an inclination of temperament or outlook (Merriam-Webster, 2021)

But… is it really possible to have no inclination at all in our temperament and outlook? Let’s look at the definition of subjective, that will help us here:

relating to the way a person experiences things in his or her own mind (Merriam-Webster, 2021)

Is it possible for us to have a view of something without it being part of our experience? It seems not. All that we do, all our views and expressions and our interactions are part of our experience as a person, and it relates to us on an intimate level, which means that everything that we do as individuals is subjective. In that sense, it seems impossible for any individual to be objective, since they will always have some form of inclination about everything.

What does this leave us with then when we ask what is objectivity? A better definition of objectivity in my opinion is one given by Thomas Nagel:

It may be more accurate to think of objectivity as a direction in which the understanding can travel. […] The process of reduction is a move in the direction of greater objectivity, toward a more accurate view of the real nature of things. This is accomplished by reducing our dependence on individual or species-specific points of view toward the object of investigation. We describe it not in terms of the impressions it makes on our senses, but in terms of its more general effects and of properties detectable by means other than the human senses. (Nagel, 1974)

In this sense, there is no black-and-white distinction between subjectivity and objectivity, but rather it is a spectrum, a line on which we can walk from subjectivity towards objectivity.

We start with our individual perceptions as the most objective view and description, we then move towards descriptions that allow us to agree with other (human) beings, and finally we move towards descriptions that can be verified and agreed upon by other apparatus, although it is important to understand that even the apparatus that we may use to describe things are not necessarily free from bias, since they are created by biased individuals and groups. By now you may notice that if a measuring device is made to be agreeable between a large group of people, it is already more objective than a device made by a single individual! However, absolute objectivity, which we may call “a view from nowhere” may not be attainable by us, because we will always be viewing things from our own perspectives, even if it is a large, collective perspective that we agree on, it is not a view from nowhere.

Inherently Subjective Things

With our definition of objectivity in place, now let’s see: is there something that we cannot move towards objectivity about? Yes. That is our personal experiences.

See, if there is an attempt to give a more objective description of my personal experience, there will need to be either an agreement among a group of beings about this description of my personal experience, or there should be an apparatus that we can agree on that measures my personal experience. However, my personal experience is personal exactly because it is completely dependent and originated from my perspective alone, and no one else’s; and as soon as you try to move towards objectivity by trying to describe this experience in a way that moves away from my person-specific and species-specific standpoint, towards a more agreeable and general description that even non-human beings or apparatus can agree with, you lose the initial personal experience in the process, so you end up with a non-personal description of the experience which misses the point of the actual subjective experience I have.

So, you can come up with some description of my experience, but you can’t actually describe the subjective experience of being me as it really is. The walk towards objectivity requires you to drop the subjectivity of my experience, and hence, some inherently subjective things such as our personal experiences can’t be objectified.

This is how Nagel puts it (I think this may be a bit hard to read without reading the whole paper):

Experience itself, however, does not seem to fit the pattern. The idea of moving from appearance to reality seems to make no sense here. What is the analogue in this case to pursuing a more objective understanding of the same phenomena by abandoning the initial subjective viewpoint toward them in favor of another that is more objective but concerns the same thing? Certainly it appears unlikely that we will get closer to the real nature of human experience by leaving behind the particularity of our human point of view and striving for a description in terms accessible to beings that could not imagine what it was like to be us. If the subjective character of experience is fully comprehensible only from one point of view, then any shift to greater objectivity that is, less attachment to a specific viewpoint does not take us nearer to the real nature of the phenomenon: it takes us farther away from it. (Nagel, 1974)

So What? (Or: Why is This Important?)

This realisation means that objectifying people’s subjective experiences is not possible, we will never be able to decipher someone’s subjective experience of something. This does not mean we should not try to understand people, rather, it means we should always consider that our understanding of someone’s subjective experience will never be objective, it will always be merely our perspective of it. When it comes to people’s personal experiences, we can’t be sure that we are right, the way we are confident we are right after measuring a distance using our agreed-upon metric ruler; when it comes to subjective experiences it’s always only a crude approximation. “In the end one experiences only oneself.” (Nietzsche, 2008)

This video was sent to me by a friend today, and it is great timing, because it is very relevant:

References

Nagel, T. (1974). What is it like to be a bat. Readings in Philosophy of Psychology, 1, 159–168.
Merriam-Webster. (2021). Objectivity. In Merriam-Webster.com dictionary. https://www.merriam-webster.com/dictionary/objectivity
Merriam-Webster. (2021). Bias. In Merriam-Webster.com dictionary. https://www.merriam-webster.com/dictionary/bias
Merriam-Webster. (2021). Subjective. In Merriam-Webster.com dictionary. https://www.merriam-webster.com/dictionary/subjective
Nietzsche, F. (2008). Thus spoke Zarathustra: A book for everyone and nobody. Oxford University Press.

Iran Sanctions: A Story of Discrimination and Isolation

Sat, 27 Jul 2019 18:13:46 +0100

Let me take you through a story on what it feels like to be isolated from the world, not by choice, but rather, by force. This is a story of discrimination, of monopoly, of people shrugging to these issues and of utterances that affect lives of millions.

Living in Iran, or any sanctioned country for that matter, you learn to read “anyone, anywhere” with an appendix of “except you”. You soon learn “worldwide shipping” excludes you, that’s when you start wondering, are you not living in “the world”? Where is this “world” they talk about?

Here is an example of a beautiful, hopeful message from Khan Academy:

“We’re a nonprofit with the mission to provide a free, world-class education for anyone, anywhere.”

No one probably realizes that this is not true, but yes, Khan Academy is not available to Iranians, Cubans, Syrians, people of Crimea, and some others. That’s because they run on Google Cloud, an infrastructure provider that completely blocks all sanctioned countries from accessing any application hosted on it. Who else hosts their service there? Take a look at 342 notable customers of Google Cloud, but remember, there are thousands more customers of Google Cloud and similar American infrastructure providers.

But the story doesn’t end here, of course. Let’s go through the effects of sanctions on everyday lives of people, who have nothing to do with the politics of the country they are living in, and who are being discriminated only because they were born in geographical coordinates that lie in a certain boundary defined by people they don’t even know.

The Internet

The internet, the tool of the global society for communicating across the planet, the tool for sharing knowledge with the human population across the world.

As if the Iranian government’s blockage and censorship of the internet wasn’t enough, we now have to deal with external sanctions blocking our access as well. Here’s a gallery of blocked access messages we see on a daily basis:

Various websites and their respective webpages seen only by sanctioned countries

These websites include GitHub, Slack, Kaggle, Docker, GitLab, Amazon AWS, Twitter, Bluemix, Khan Academy and more. Here is a longer, developer-oriented (but definitely not exhaustive) list of hosts blocking our access: freedomofdevelopers/domains.

The websites that blocked our access mostly did it without prior notice, they just disabled our accounts, took our data from us, and did not let us even backup or export our data afterwards, in other words, lost messages, lost files and credentials.

This, in part, is caused by the global monopoly of American companies such as Google, Amazon, GitHub and alike in their respective fields. This means if The United States decides to pressure a specific target, the target population is likely to be left without much of an alternative or option, since a great proportion of the land is covered by American companies.

Iranian users rely heavily on use of VPN services and proxy servers to bypass censorship, but now with most Cloud Providers blocking access of Iranians, we are left with limited, usually more expensive options for setting up these servers.

This is a clear discrimination based on nationality and a breach of Internet Freedom. These websites do not block us because we acted in a wrong way, or even, at cases, because we live in Iran, but because we were born in Iran. Now, you may say this is because of the law and they have no choice. That’s true in some cases, though most of the time the implementation of these laws seem to go further than what the laws actually require. The companies seem to go the easy way by blocking access as much as they can to avoid holes in their system.

Drugs, Medicine, and Medical Devices

There are various sources and articles on how the U.S. sanctions have affected Iranian patients by limiting exports of drugs, medical devices or by indirectly disrupting the pharmaceutical industry by cutting exports of raw material used by these companies to produce medical drugs. Almost every person living in Iran can consciously feel the shortage of drugs and their growing price, but I will refer to an article on NCBI as a proof.

Quoting from NCBI: Addressing the impact of economic sanctions on Iranian drug shortages in the joint comprehensive plan of action: promoting access to medicines and health diplomacy:

Although the revised and current Iranian sanctions regime does not specifically prohibit the export of humanitarian goods and pharmaceuticals, many of the administrative and regulatory processes have made it difficult to export life-saving medicines to Iran. This includes the need to navigate a complex export control regulatory process, the inability of Iranian banks to do business with the international banking system and U.S. corporations, currency shortages, and the inability to secure terms of shipping, insurance and other services needed to facilitate medicines trade [4]. As a result, millions of Iranians that suffer from life-threatening diseases have experienced “exorbitant prices”, stock outs of medicines, and are often forced to purchase drugs from the black market. [...] Severe medication shortages in Iran are diverse and span several therapeutic classes and disease states. This includes drug shortages for other critical areas of healthcare delivery, including organ transplant drugs, and even vaccine shortages.

And on the topic of weakening of the pharmaceutical companies:

Inaccessibility of vital medications and their raw ingredients combined with Iran’s weakening domestic pharmaceutical industry has also resulted in an influx of counterfeit, fraudulent, and substandard medicines into Iran’s health care system. An unregulated black market has developed as a byproduct of drug shortages, introducing medications whose origins and authenticity are often unknown, and has led to expired medications’ distribution and sale, even at potentially very high prices [8]. Hence, the global counterfeit medicines trade, recognized as a serious public health concern, is one that is currently being enabled as a consequence of drug shortages and ongoing Iranian economic sanctions

Foreign Policy also writes U.S. Sanctions Are Killing Cancer Patients in Iran:

Washington claims that maximum pressure won’t stop the supply of medicine and other humanitarian necessities, but banking sanctions are driving up import prices, blocking supply chains, and creating deadly drug shortages.

Although U.S. sanctions are engineered in a way that may appear not to target humanitarian access to food and medicine, in practice U.S. sanctions function as a tool of economic war.

Health is a fundamental human right, but the embargo clearly goes against giving people access to life-saving medicine. It brings tears to my eyes to think about people losing a loved one over inability to access a drug or medical device that’s no longer available in Iran.

Currency Fluctuations: An Unpredictable Life

I’m pretty sure most of the people reading this blog post, unless they are Iranians, will not find this section familiar. It’s [fortunately] not a common experience across the planet, but let me tell you about living a life of zero predictability.

Imagine this: You sell your car today, and you start a hunt for a new car to buy as a replacement. For the sake of the example, you are looking for a second-hand car. I will use a dummy currency unit here to simplify the example. You sold your car for 1000 units, and during the week you are looking for a new car, you start to see the car you just sold and every other car on the market, is gaining price exponentially. After a week, the same car that you sold is priced at 1800 units of currency and it’s growing. It’s like putting a car on neutral in a downward slope and seeing it go up the hill! Now you are left with 1000 units of currency, and you are only able to buy the same car if you put in your extra 800 savings, otherwise you are going to ride a car with significantly less quality or no car at all. More on Iran’s inflation as a result of tighter sanctions.

I am pretty sure no matter how much I try to help you visualize this, you can not comprehend what it means to live in such a situation. I always use the metaphor of being a circus actor trying to balance on a moving cylinder to describe what it means to survive the fluctuations of our currency, which in turn affects all your expenses, but not your income.

This is also an effect of the sanctions on the economy that we people feel with our every inch and are pressured by. This in turn causes a rippling effect on every other part of the society. Quoting Explainer: the collapse of the Iranian rial

Has the US decision made things worse? Yes. Mr Trump’s decision to exit the US-Iran nuclear agreement signed in 2015 has dented Iran’s economic outlook and set in motion a cascade of damaging effects. It has deterred global companies from doing business with Iran, leading to a liquidity crunch and a lack of foreign exchange in the country. US measures also put pressure on a banking system already strained by the previous sanctions regime before the adoption of the JCPOA in January 2016. A re-imposition of sanctions is expected to cause a drop in Iranian oil exports, with severe repercussions. Iran is home to the world’s largest reserves of gas and is the Middle East’s third-largest oil producer. In May, BMI downgraded its GDP growth forecast for Iran to 3.1 per cent in 2018 and 0.8 per cent in 2019, from 4.3 per cent and 4.5 per cent previously. “Iran is likely to experience depreciatory pressures on the rial and rising inflation as a result of lower foreign currency inflows that will constrain domestic investment and consumption,” BMI said.

Unpredictability is only part of the story, in general a high inflation rate means a degradation of life quality over time, and a lower quality of life includes a lack of access to even the most basic needs. It means having to put your children in less qualified schools, it means avoiding doctor appointments by any means necessary, it means cutting corners in every section of your life, it means a less balanced environment to live in, an environment where people get angry more easily since they are under a constant pressure as a cause of their degrading lives. No matter how hard you try, your life quality only goes downhill, never up.

A Weak Economy’s Rippling Effect

You have probably heard of Maslow’s Hierarchy of Needs. This is what it looks like:

At the bottom, there are physiological needs, like health, food, water, sleep, shelter and sex. Only once these needs are fulfilled properly, you get motivated to even think about the next level. That means, if your physiological needs are not properly safisfied, you will not even think about safety, love and belonging, self-esteem or self-actualization.

Now, what all these physiological needs have in common is that they are fulfilled when there is a stable economic backbone in the country you live in. Once the economic backbone is broken, you begin losing access to these physiological needs. Slowly, but surely, you lose your motivation for self-actualization, for self-esteem, for love and belonging and for safety and you hunt for your physiological needs. Once this happens for a whole population in a country, you are left with people with only one goal in their lives: to survive by any means.

With no motivation for building strong friendships and relationships, no motivation for security and safety, for feeling of accomplishment and for creative acts, the population transitions towards becoming one unsafe, cold, threatening, untrustable environment with no sense of joy or creativity.

I’m driving from my friend’s house back to mine, it’s roughly 10pm and streets are a little crowded. I’m going through streets of Azadi District, when I see two children who are probably between 15 and 17, punching each other in the face and kicking each other’s stomach over a large trash container at the side of the street. They are fighting, as if for their lives, with a ferocity you can hardly imagine to find in a child of their age. These children do not look anything like your children, their hands are black from their fingertips to their elbows from collecting trash all day long; their clothes are not new, they do not change their clothes or take showers daily, and their backs are arched for hauling a large bag of trash for a whole day over their shoulder and back. They are fighting to win a trash container. This is what happens when you put pressure on the economy of a country. This is what the media is not telling you about the effects of sanctions. This is what needs to stop about these sanctions. This is what needs action from every person knowledgable to do something to stop it. Abuse, rape and misuse of children and adults alike is a significant, visible effect of sanctions that’s often overlooked.

It’s sad that I can not find any content regarding this matter in the media by searching. I think more content on these topics is necessary to help people be aware of the unethical and inhumane effects of sanctions on lives of innocent people.

A teenage collecting trash in the streets of Tehran.

The rippling effects of a weakening economy are far worse and far-reaching than what the sanctions are supposed to do. I think it’s too optimistic to think sanctions to weaken an economy will prevent a country from spending money on something they want to spend on. What ends up happening, or at least has happened in case of Iran, is that the money is drained from places where it affects peoples lives, but I doubt anything has changed at the actual target.

Of Rolling Eyes and Shrugs

Often when similar stories of this kind are shared, I am ready to see comments of people shrugging to the issue with responses like “they have to comply because it’s the law” or “that’s how you respond to a country that wants to build nuclear weapons” or similar. They just roll their eyes and shrug it off like this is how it’s supposed to be.

Sometimes, that’s true that it’s the law and the companies have to comply (though most of the time the application of the law goes way beyond necessity). What these responses get wrong is that there is no involvement by us, the people, in the decisions and policies of our country. Solely because I live my daily life in a geographical location that resides in the boundaries of a place on Earth known as “Iran” doesn’t mean I agree with the politics of this country, or that I should be isolated from the rest of the world because some people in my country make certain decisions.

What these replies get wrong is that in democratic countries, laws can change based on what people demand. Instead of shrugging these humanitarian issues off, please hear us out, and help echo our voice. You may not realize, but we, the people of Iran, do not have a say in what what politics our government follows or how it interacts with other countries, but you do have a say in yours. The only thing we can do is to spread the word.

What we feel when we see these responses is: “They are terrorists so let them be”, but we are not. We are normal people like you, with less privileges, solely because of our living region.

It seems like the Iranian people are now the common enemy of all sides of a global conflict. The ever-increasing pressure we feel is not from a single source, but rather, from all sides. We have internet censorship from the inside and restricted access from the outside. We have economic pressure from the inside, with a direct influence from the outside, and the same applies to every part of this conflict.

Final Message

Racism is defined as “prejudice, discrimination, or antagonism directed towards other people because they are of a different race or ethnicity”. Sanctions, likewise, are a clear case of prejudice, discrimination and antagonism directed towards people because they are born in a certain country, or reside in a certain part of the planet.

If a person is jailed, or killed because of the color of their skin, you feel furious and protest against the act to show that racism has no place in your country. Sanctions are a case of jailing a whole country, killing the people inside by cutting their lifelines and causing lifetime distress for innocent people who didn’t do anything wrong. It’s discrimination on the scale of a whole population of millions. Although the people who are being effected by these sanctions are far away from your home, their misery is caused by your country’s policies and actions, and you have the right to stand up against these discriminations.

Ron Paul, former congressman touches on topic in an interview:

I think sanctions are really really bad, because it brings people in to think that “well I’m not quite as violent as other people who would use a drone”, well, hopefully it is a little bit less violent, but it’s every bit as dangerous, it’s still attacking personal liberties and it’s undermining the principle of trying to get along with people with free trade.

The Universal Declaration of Human Rights, Article 2, states:

Everyone is entitled to all the rights and freedoms set forth in this Declaration, without distinction of any kind, such as race, colour, sex, language, religion, political or other opinion, national or social origin, property, birth or other status. Furthermore, no distinction shall be made on the basis of the political, jurisdictional or international status of the country or territory to which a person belongs, whether it be independent, trust, non-self-governing or under any other limitation of sovereignty.

That doesn’t sound like what’s happening now by enforcement of sanctions. Silence on this massive case of discrimination against people around the world must be broken, it must be recognized that discrimination, in any form, is not to be tolerated by humans.

Going Self-Hosted: Moving away from Google and others

Mon, 11 Feb 2019 00:00:00 +0000

Since 3 years ago, I have always been eager to move away from Google and other privacy-invading companies. I have had my successes and failures in doing so, here I’m going to put out my stack of tools for moving away from Google and going self-hosted.

I first tried to move away from Google 3 years ago, and at the time, I did not have enough resources to self-host much. I started by creating my own email server, but I couldn’t afford a cloud storage. I also did not know about the alternatives available to Google Calendar, Google Keep, and other tools I was using at the time, so it was pretty hard keeping up that way.

After a year and a half, after my phone was stolen, I decided I will stick with Google apps with the coming of my new phone. I kept using Google services for less than a year, but I was frustrated. I had given up my privacy and control over my data for convenience, but that’s not what I wanted. So I decided I’m going to switch away again, and I will self-host the tools necessary.

A lot has changed since the first time I switched away, I will sketch below the tools that I have replaced and how.

microG

If you want to avoid using Google Services on your Android phone, there is microG for that. I flashed my phone with an AEX ROM which supports microG, so it was not particularly hard to set-up on my phone, but I’ve heard it can be hard to set it up since it’s doing some trickery to replace Google’s services on your phone.

This also means you have to flash a custom ROM and root your device in order to do this, so maybe this option is not for everyone, but I think with Google Services active in your phone, you can’t really be sure what’s going on behind the curtains.

Email

One of the most common means of communication for us in the digital world, we exchange a lot of information through email, including personal and work-related information. As such, I deem email an important piece of privacy-sensitive information.

My solution for email is a self-hosted Postfix + Dovecot + SpamAssassin on my server. It is not the most straightforward thing to set up, by this DigitalOcean tutorial makes it all the easier.

I have also heard of Mail-in-a-Box which is supposed to make setting up your own mail server a breeze! I didn’t know about this at the time I set up my server, but it could be a better choice, so perhaps give it a try and let me know.

Cloud Storage

A cloud storage is necessary for syncng your data among your devices and keeping your information safe from physical loss. I chose Nextcloud and I couldn’t be more satisfied. It has clients for every major operating system, and I use it to back up my files, synchronize my calendar and contacts between my Linux and my Android devices.

The installation and activation is fairly straightforward, and again, I followed a DigitalOcean tutorial to set up the service and have been using it since.

I also bought a DigitalOcean Space for $5/month, with a capacity of 250G, which is a fairly good price and worth its value. See this discussion about attaching a DigitalOcean space to Nextcloud.

Contacts and Calendar

I learned about DAVx and ICSx, which are tools for syncing your contacts and calendar, with support for Google Calendar as well. This means that I can still have access to my workplace calendar which is on Google, and have my own personal calendars synchronized using Nextcloud.

These tools integrate with whatever Calendar and Contacts application you are using on your phone, so you are free to choose whatever calendar and contacts application you like.

Notes

For note-taking, I use a simple Markdown/todo.txt editor called Markor while Nextcloud handles the synchronization so I have access to my notes both on my computer and my phone. I use vimwiki to organize and edit my notes on my computer. Nextcloud also provides extra applications for editing Markdown files on the web interface, which is great if you like doing everything in your browser.

Application Store

For downloading applications, I default to searching through F-Droid, and in case I don’t find the tool I’m looking for (which I mostly do!), or I’m looking for a properietary application, such as Slack, I use Aurora Store or Yalp Store, which lets you search through all Google Play applications and install applications without a fuss.

Of course, you can install the official Google Play store as well if you would like to, but I personally am cautious about using any of Google’s applications.

Two-factor Authentication

I use andOTP instead of Google Authenticator. One feature I love about andOTP is the ability to take an encrypted backup of your OTP keys, so you do not have to re-set all your two-factor authentications across all services if you ever want to switch your phone.

Password Manager

I switched from LastPass, with its ugly, broken and distorted user experience to BitWarden, and I couldn’t ask for more! The user experience is far superior compared to LastPass, the extension doesn’t kill my browser’s performance and the Android application is great, too!

Firefox Containers

Lastly, it’s natural that we can’t completely avoid using Google’s tools, we can just try to limit Google’s access to our data and avoid being tracked as much as possible. For this purpose, I started using Firefox Containers, and God, this is a killer feature!

So now, I have a few containers set up:

Personal: This one includes my personal accounts on websites other than Google that I want to stay logged-in on.
Work: I’m logged into services that I use for work here, and it includes Google as well, but only for work.
Google: This one, I use for accessing a personal Google Account I keep for YouTube and other services, but I’m not a serious user.
Temporary Containers: Any websites that I have not explicitly chosen to be opened in one of the above containers, opens up in a new, temporary container, which means it doesn’t have access to any cookies or information from the other containers. I may sometimes choose to open Google or other services in Temporary Containers as well if I don’t see the necessity to be logged in.

This means Google will not be able to track me using my account when I’m logged in to other services since they live in a different container, even though other methods such as device fingerprinting are still possible. With Firefox’s Tracking Protection and uBlock always turned on, I am less concerned about tracking.

Not the easiet thing

I have to admit, it’s not the easiest thing to move your digital life away from the giants, their products are built for maximum convenience, so you can’t expect to have that maximum convenience if you stop using those products, and I think it’s a far-fetched ideal to expect the same level of convenience using free applications and tools, but I personally think it’s worth it.

Mathematical Induction for proving tiling methods

Thu, 19 Oct 2017 00:00:00 +0100

On my way towards self-taught data science, I’ve stumbled upon the need to be proficient with mathematical proofs, so I picked up the amazing How To Prove It: A Structured Approach by Daniel J. Velleman; and I’ve been fascinated by mathematical proofs since then.

One of the uses for Mathematical Induction which I’ve found to be pretty cool is proving methods for tiling shapes.

Here is an example:

Suppose $n$ is a positive integer. An equilateral triangle is cut into $4^n$ congruent equilateral triangles, and one corner is removed. Show that the remaining area can be covered by trapezoidal tiles like this:

An example of n = 2. The dark tile is removed.

Just to be clear, by cover we mean covering without any overlaps, so you can’t have two overlapping trapezoidal tiles.

As with any mathematical induction solution, we start with the base case, which is $n = 1$, in that case the triangle looks like this:

In this case, it’s obvious that we can cover the leftover area using trapezoidal tiles consisting of three equilateral triangles (the second row), so:

Base case: $n = 1$ then the triangle has $4^1 = 4$ tiles, and by removing the top-most tile, the second row can be covered using a single trapezoidal tile.

Now for the induction step, we have to somehow show that after adding 1 to $n$, that is, by multiplying the tiles by $4$, we can still cover the triangle by trapezoidal tiles. To show this, we start by assuming we have a triangle with $4^n$ tiles, which we know can be covered by trapezoidal tiles, then we add the new tiles and show that they, too, can be covered by trapezoidal tiles.

Induction Step: Suppose we have a triangle split into $4^n$ tiles, and we know by induction hypothesis that it can be covered by trapezoidal tiles.

Now suppose we have another triangle with $4^{n+1}$ tiles, that means, $4$ times as many triangles as our original triangle. We can then group the new bigger triangle into 4 congruent triangles, one of which we know can be split into trapezoidal tiles by removing one of it’s tiles.

For the three left triangles, we can find a neighbouring corner and assume the tile on that corner to be removed, and then cover the rest by trapezoidal tiles. Afterwards, since we had three such corners, and they are neighbouring corners, we can cover these three corners with one trapezoidal tile, thus completing the triangle.

Now that’s a mouthful, in simpler terms, we are following these steps (for $n = 2$):

First, we split the whole triangle into 4 smaller groups:

Then, we know that one of the triangles can be covered by trapezoidal tiles if we remove one of it’s tiles, that’s the induction hypothesis (the case for $4^n$ which is proved in the base case):

Leaving the top triangle behind, we now find neighbouring corners among the three left triangles, and we assume the tiles in those corners to be removed (they are not actually removed as we are constrained to remove only one tile):

Now we can cover the rest of these triangles by a single trapezoidal tile, similar to the case of $n = 1$.

Afterwards, we see that the three neighbouring tiles form a trapezoidal tile, therefore we can now put the last piece there to complete the tiles.

This procedure can be applied recursively on larger values of $n$ as well, so this concludes a proof of tiling an equilateral triangle divided into $4^n$ equilateral triangles using trapezoidal tiles after removing a single piece.

Typoclassopedia: Exercise solutions

Wed, 27 Sep 2017 00:00:00 +0100

I wanted to get proficient in Haskell so I decided to follow An [Essential] Haskell Reading List. There I stumbled upon Typoclassopedia, while the material is great, I couldn’t find solutions for the exercises to check against, so I decided I would write my own and hopefully the solutions would get fixed in case I have gone wrong by others. So if you think a solution is wrong, let me know in the comments!

In each section below, I left some reference material for the exercises and then the solutions.

Note: The post will be updated as I progress in Typoclassopedia myself

Functor

Instances

instance Functor [] where
  fmap :: (a -> b) -> [a] -> [b]
  fmap _ []     = []
  fmap g (x:xs) = g x : fmap g xs
  -- or we could just say fmap = map
 
instance Functor Maybe where
  fmap :: (a -> b) -> Maybe a -> Maybe b
  fmap _ Nothing  = Nothing
  fmap g (Just a) = Just (g a)

((,) e) represents a container which holds an “annotation” of type e along with the actual value it holds. It might be clearer to write it as (e,), by analogy with an operator section like (1+), but that syntax is not allowed in types (although it is allowed in expressions with the TupleSections extension enabled). However, you can certainly think of it as (e,).

((->) e) (which can be thought of as (e ->); see above), the type of functions which take a value of type e as a parameter, is a Functor. As a container, (e -> a) represents a (possibly infinite) set of values of a, indexed by values of e. Alternatively, and more usefully, ((->) e) can be thought of as a context in which a value of type e is available to be consulted in a read-only fashion. This is also why ((->) e) is sometimes referred to as the reader monad; more on this later.

Exercises

Implement Functor instances for Either e and ((->) e).

Solution:

instance Functor (Either e) where
  fmap _ (Left e) = Left e
  fmap g (Right a) = Right (g a)
      
instance Functor ((->) e) where
  fmap g f = g . f

Implement Functor instances for ((,) e) and for Pair, defined as below. Explain their similarities and differences.

Solution:
```
instance Functor ((,) e) where
  fmap g (a, b) = (a, g b) 
      
      
data Pair a = Pair a a
instance Functor Pair where
  fmap g (Pair a b) = Pair (g a) (g b)
```
Their similarity is in the fact that they both represent types of two values. Their difference is that ((,) e) (tuples of two) can have values of different types (kind of (,) is * -> *) while both values of Pair have the same type a, so Pair has kind *.

Implement a Functor instance for the type ITree, defined as

 data ITree a = Leaf (Int -> a)
             | Node [ITree a]

Solution:

 instance Functor ITree where
   fmap g (Leaf f) = Leaf (g . f)
   fmap g (Node xs) = Node (fmap (fmap g) xs)

To test this instance, I defined a function to apply the tree to an Int:

 applyTree :: ITree a -> Int -> [a]
 applyTree (Leaf g) i = [g i]
 applyTree (Node []) _ = []
 applyTree (Node (x:xs)) i = applyTree x i ++ applyTree (Node xs) i

This is not a standard tree traversing algorithm, I just wanted it to be simple for testing.

Now test the instance:

 λ: let t = Node [Node [Leaf (+5), Leaf (+1)], Leaf (*2)]
 λ: applyTree t 1
 [6,2,2]
 λ: applyTree (fmap id t) 1
 [6,2,2]
 λ: applyTree (fmap (+10) t) 1
 [16, 12, 12]

Give an example of a type of kind * -> * which cannot be made an instance of Functor (without using undefined).

I don’t know the answer to this one yet!
Is this statement true or false?

The composition of two Functors is also a Functor.

If false, give a counterexample; if true, prove it by exhibiting some appropriate Haskell code.

Solution:

It’s true, and can be proved by the following function:
```
 ffmap :: (Functor f, Functor j) => (a -> b) -> f (j a) -> f (j b)
 ffmap g = fmap (fmap g)
```
You can test this on arbitrary compositions of Functors:
```
 main = do
   let result :: Maybe (Either String Int) = ffmap (+ 2) (Just . Right $ 5)
   print result -- (Just (Right 7))
```

Functor Laws

fmap id = id
fmap (g . h) = (fmap g) . (fmap h)

Exercises

Although it is not possible for a Functor instance to satisfy the first Functor law but not the second (excluding undefined), the reverse is possible. Give an example of a (bogus) Functor instance which satisfies the second law but not the first.

Solution:

This is easy, consider this instance:
```
 instance Functor [] where
   fmap _ [] = [1]
   fmap g (x:xs) = g x: fmap g xs
```
Then, you can test the first and second laws:
```
 λ: fmap id [] -- [1], breaks the first law
 λ: fmap ((+1) . (+2)) [1,2] -- [4, 5], second law holds
 λ: fmap (+1) . fmap (+2) $ [1,2] -- [4, 5]
```
Which laws are violated by the evil Functor instance for list shown above: both laws, or the first law alone? Give specific counterexamples.
```
 -- Evil Functor instance
 instance Functor [] where
   fmap :: (a -> b) -> [a] -> [b]
   fmap _ [] = []
   fmap g (x:xs) = g x : g x : fmap g xs
```
Solution:

The instance defined breaks the first law (fmap id [1] -- [1,1]), but holds for the second law.

Category Theory

The Functor section links to Category Theory, so here I’m going to cover the exercises of that page, too.

Introduction to categories

Category laws:

The compositions of morphisms need to be associative:

$f \circ (g \circ h) = (f \circ g) \circ h$
The category needs to be closed under the composition operator. So if $f : B \to C$ and $g: A \to B$, then there must be some $h: A \to C$ in the category such that $h = f \circ g$.
Every object $A$ in a category must have an identity morphism, $id_A : A \to A$ that is an identity of composition with other morphisms. So for every morphism $g: A \to B$: $g \circ id_A = id_B \circ g = g$.

Exercises

As was mentioned, any partial order $(P, \leq)$ is a category with objects as the elements of P and a morphism between elements a and b iff $a \leq b$. Which of the above laws guarantees the transitivity of $\leq$?

Solution:

The second law, which states that the category needs to be closed under the composition operator guarantess that because we have a morphism $a \leq b$, and another morphism $b \leq c$, there must also be some other morphism such that $a \leq c$.
If we add another morphism to the above example, as illustrated below, it fails to be a category. Why? Hint: think about associativity of the composition operation.

Solution:

The first law does not hold:

$f \circ (g \circ h) = (f \circ g) \circ h$

To see that, we can evaluate each side to get an inequality:

$g \circ h = id_B$

$f \circ g = id_A$

$f \circ (g \circ h) = f \circ id_B = f$

$(f \circ g) \circ h = id_A \circ h = h$

$f \neq h$

Functors

Functor laws:

Given an identity morphism $id_A$ on an object $A$, $F(id_A)$ must be the identity morphism on $F(A)$, so: $F(id_A) = id_{F(A)}$
Functors must distribute over morphism composition: $F(f \circ g) = F(f) \circ F(g)$

Exercises

Check the functor laws for the diagram below.

Solution:

The first law is obvious as it’s directly written, the pale blue dotted arrows from $id_C$ to $F(id_C) = id_{F(C)}$ and $id_A$ and $id_B$ to $F(id_A) = F(id_B) = id_{F(A)} = id_{F(B)}$ show this.

The second law also holds, the only compositions in category $C$ are between $f$ and identities, and $g$ and identities, there is no composition between $f$ and $g$.

(Note: The second law always hold as long as the first one does, as was seen in Typoclassopedia)

Check the laws for the Maybe and List functors.

Solution:

 instance Functor [] where
   fmap :: (a -> b) -> [a] -> [b]
   fmap _ []     = []
   fmap g (x:xs) = g x : fmap g xs
    
 -- check the first law for each part:
 fmap id [] = []
 fmap id (x:xs) = id x : fmap id xs = x : fmap id xs -- the first law holds recursively
    
 -- check the second law for each part:
 fmap (f . g) [] = []
 fmap (f . g) (x:xs) = (f . g) x : fmap (f . g) xs = f (g x) : fmap (f . g) xs
 fmap f (fmap g (x:xs)) = fmap f (g x : fmap g xs) = f (g x) : fmap (f . g) xs

 instance Functor Maybe where
   fmap :: (a -> b) -> Maybe a -> Maybe b
   fmap _ Nothing  = Nothing
   fmap g (Just a) = Just (g a)
    
 -- check the first law for each part:
 fmap id Nothing = Nothing
 fmap id (Just a) = Just (id a) = Just a
    
 -- check the second law for each part:
 fmap (f . g) Nothing = Nothing
 fmap (f . g) (Just x) = Just ((f . g) x) = Just (f (g x))
 fmap f (fmap g (Just x)) = Just (f (g x)) = Just ((f . g) x)

Applicative

Laws

The identity law:
```
 pure id <*> v = v
```
Homomorphism:
```
 pure f <*> pure x = pure (f x)
```
Intuitively, applying a non-effectful function to a non-effectful argument in an effectful context is the same as just applying the function to the argument and then injecting the result into the context with pure.
Interchange:
```
 u <*> pure y = pure ($ y) <*> u
```
Intuitively, this says that when evaluating the application of an effectful function to a pure argument, the order in which we evaluate the function and its argument doesn’t matter.
Composition:
```
 u <*> (v <*> w) = pure (.) <*> u <*> v <*> w
```
This one is the trickiest law to gain intuition for. In some sense it is expressing a sort of associativity property of (<*>). The reader may wish to simply convince themselves that this law is type-correct.

Exercises

(Tricky) One might imagine a variant of the interchange law that says something about applying a pure function to an effectful argument. Using the above laws, prove that

pure f <*> x = pure (flip ($)) <*> x <*> pure f

Solution:

pure (flip ($)) <*> x <*> pure f
  = (pure (flip ($)) <*> x) <*> pure f -- <*> is left-associative
  = pure ($ f) <*> (pure (flip ($)) <*> x) -- interchange
  = pure (.) <*> pure ($ f) <*> pure (flip ($)) <*> x -- composition
  = pure (($ f) . (flip ($))) <*> x -- homomorphism
  = pure ((flip ($) f) . (flip ($))) <*> x -- identical
  = pure f <*> x

Explanation of the last transformation:

flip ($) has type a -> (a -> c) -> c, intuitively, it first takes an argument of type a, then a function that accepts that argument, and in the end it calls the function with the first argument. So (flip ($) 5) takes as argument a function which gets called with 5 as it’s argument. If we pass (+ 2) to (flip ($) 5), we get (flip ($) 5) (+2) which is equivalent to the expression (+2) $ 5, evaluating to 7.

flip ($) f is equivalent to \x -> x $ f, that means, it takes as input a function and calls it with the function f as argument.

The composition of these functions works like this: First flip ($) takes x as it’s first argument, and returns a function (flip ($) x), this function is awaiting a function as it’s last argument, which will be called with x as it’s argument. Now this function (flip ($) x) is passed to flip ($) f, or to write it’s equivalent (\x -> x $ f) (flip ($) x), this results in the expression (flip ($) x) f, which is equivalent to f $ x.

You can check the type of (flip ($) f) . (flip ($)) is something like this (depending on your function f):

λ: let f = sqrt
λ: :t (flip ($) f) . (flip ($))
(flip ($) f) . (flip ($)) :: Floating c => c -> c

Also see this question on Stack Overflow which includes alternative proofs.

Instances

Applicative instance of lists as a collection of values:

newtype ZipList a = ZipList { getZipList :: [a] }
 
instance Applicative ZipList where
  pure :: a -> ZipList a
  pure = undefined   -- exercise
 
  (<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b
  (ZipList gs) <*> (ZipList xs) = ZipList (zipWith ($) gs xs)

Applicative instance of lists as a non-deterministic computation context:

instance Applicative [] where
  pure :: a -> [a]
  pure x = [x]
 
  (<*>) :: [a -> b] -> [a] -> [b]
  gs <*> xs = [ g x | g <- gs, x <- xs ]

Exercises

Implement an instance of Applicative for Maybe.

Solution:

 instance Applicative (Maybe a) where
   pure :: a -> Maybe a
   pure x = Just x
      
   (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b
   _ <*> Nothing = Nothing
   Nothing <*> _ = Nothing
   (Just f) <*> (Just x) = Just (f x)

Determine the correct definition of pure for the ZipList instance of Applicative—there is only one implementation that satisfies the law relating pure and (<*>).

Solution:

 newtype ZipList a = ZipList { getZipList :: [a] }
    
 instance Functor ZipList where
   fmap f (ZipList list) = ZipList { getZipList = fmap f list }
    
 instance Applicative ZipList where
   pure = ZipList . pure
    
   (ZipList gs) <*> (ZipList xs) = ZipList (zipWith ($) gs xs)

You can check the Applicative laws for this implementation.

Utility functions

Exercises

Implement a function sequenceAL :: Applicative f => [f a] -> f [a] There is a generalized version of this, sequenceA, which works for any Traversable (see the later section on Traversable), but implementing this version specialized to lists is a good exercise.

Solution:
```
 createList = replicate 1

 sequenceAL :: Applicative f => [f a] -> f [a]
 sequenceAL = foldr (\x b -> ((++) . createList <$> x) <*> b) (pure [])
```
Explanation:

First, createList is a simple function for creating a list of a single element, e.g. createList 2 == [2].

Now let’s take sequenceAL apart, first, it does a fold over the list [f a], and b is initialized to pure [], which results in f [a] as required by the function’s output.

Inside the function, createList <$> x applies createList to the value inside f a, resulting in f [a], and then (++) is applied to the value again, so it becomes f ((++) [a]), now we can apply the function (++) [a] to b by ((++) . createList <$> x) <*> b, which results in f ([a] ++ b).

Alternative formulation

Definition

class Functor f => Monoidal f where
  unit :: f ()
  (**) :: f a -> f b -> f (a,b)

Laws:

Left identity
```
 unit ** v ≅ v
```
Right identity
```
 u ** unit ≅ u
```
Associativity
```
 u ** (v ** w) ≅ (u ** v) ** w
```

Neutrality

 fmap (g *** h) (u ** v) = fmap g u ** fmap h v

Isomorphism

In the laws above, ≅ refers to isomorphism rather than equality. In particular we consider:

(x,()) ≅ x ≅ ((),x)
((x,y),z) ≅ (x,(y,z))

Exercises

Implement pure and <*> in terms of unit and **, and vice versa.

 unit :: f ()
 unit = pure ()
    
 (**) :: f a -> f b -> f (a, b)
 a ** b = fmap (,) a <*> b
    
 pure :: a -> f a
 pure x = unit ** x
    
 (<*>) :: f (a -> b) -> f a -> f b
 f <*> a = fmap (uncurry ($)) (f ** a) = fmap (\(f, a) -> f a) (f ** a)

Are there any Applicative instances for which there are also functions f () -> () and f (a,b) -> (f a, f b), satisfying some “reasonable” laws?

The Arrow type class seems to satisfy these criteria.
```
   first unit = ()
      
   (id *** f) (a, b) = (f a, f b)
```

(Tricky) Prove that given your implementations from the first exercise, the usual Applicative laws and the Monoidal laws stated above are equivalent.

Identity Law

 pure id <*> v
   = fmap (uncurry ($)) ((unit ** id) ** v)
   = fmap (uncurry ($)) (id ** v)
   = fmap id v
   = v

Homomorphism

 pure f <*> pure x
   = (unit ** f) <*> (unit ** x)
   = fmap (\(f, a) -> f a) (unit ** f) (unit ** x)
   = fmap (\(f, a) -> f a) (f ** x)
   = fmap f x
   = pure (f x)

Interchange

 u <*> pure y
   = fmap (uncurry ($)) (u ** (unit ** y))
   = fmap (uncurry ($)) (u ** y)
   = fmap (u $) y
   = fmap ($ y) u
   = pure ($ y) <*> u

Composition

 u <*> (v <*> w)
   = fmap (uncurry ($)) (u ** (fmap (uncurry ($)) (v ** w)))
   = fmap (uncurry ($)) (u ** (fmap v w))
   = fmap u (fmap v w)
   = fmap (u . v) w
   = pure (.) <*> u <*> v <*> w =

Monad

Definition

class Applicative m => Monad m where
  return :: a -> m a
  (>>=)  :: m a -> (a -> m b) -> m b
  (>>)   :: m a -> m b -> m b
  m >> n = m >>= \_ -> n
 
  fail   :: String -> m a

Instances

instance Monad Maybe where
  return :: a -> Maybe a
  return = Just
 
  (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
  (Just x) >>= g = g x
  Nothing  >>= _ = Nothing

Exercises

Implement a Monad instance for the list constructor, []. Follow the types!

Solution:

 instance Monad [] where
   return a = [a]
      
   [] >> _ = []
   (x:xs) >>= f = f x : xs >>= f

Implement a Monad instance for ((->) e).

Solution:

 instance Monad ((->) e) where
   return x = const x
      
   g >>= f = f . g

Implement Functor and Monad instance for Free f, defined as:

 data Free f a = Var a
               | Node (f (Free f a))

You may assume that f has a Functor instance. This is known as the free monad built from the functor f.

Solution:

 instance Functor (Free f) where
   fmap f (Var a) = Var (f a)
   fmap f (Node x) = Node (f x)
      
 instance Monad (Free f) where
   return x = Var x
      
   (Var x) >>= f = Var (f x)
   (Node x) >>= f = Node (fmap f x)

Intuition

Exercises

Implement (>>=) in terms of fmap (or liftM) and join.

Solution:
```
 a >>= f = join (fmap f a)
```

Now implement join and fmap (liftM) in terms of (>>=) and return.

Solution:

 fmap f a = a >>= (return . f)
 join m = m >>= id

Laws

Standard:

return a >>= k  =  k a
m >>= return    =  m
m >>= (\x -> k x >>= h)  =  (m >>= k) >>= h

In terms of >=>:

return >=> g  =  g
g >=> return  =  g
(g >=> h) >=> k  =  g >=> (h >=> k)

Exercises

Given the definition g >=> h = \x -> g x >>= h, prove the equivalence of the above laws and the standard monad laws.

Solution:

 return >=> g
   = \x -> return x >>= g
   = \x -> g x
   = g
      
 g >=> return
   = \x -> g x >>= return
   = \x -> g x
   = g
    
 g >=> (h >=> k)
   = \y -> g y >>= (\x -> h x >>= k)
   = \y -> (g y >>= h) >>= k
   = \y -> (\x -> g x >>= h) y >>= k
   = (\x -> g x >>= h) >=> k
   = (g >=> h) >=> k

Monad Transformers

Definition and laws

class MonadTrans t where
  lift :: Monad m => m a -> t m a

Exercises

What is the kind of t in the declaration of MonadTrans?

Solution:

t is of the kind (* -> *) -> * -> *, as we see in (t m) a, t accepts a Monad first, which is of type * -> *, and then another argument of kind *.

Composing Monads

Exercises

Implement join :: M (N (M (N a))) -> M (N a) given distrib :: N (M a) -> M (N a) and assuming M and N are instances of Monad.

 join :: M (N (M (N a))) -> M (N a)
 join m = distrib ((distrib m) >>= join) >>= join
    
 -- one by one
 let m :: M (N (M (N a)))
     a = distrib m  :: N (M (M (N a)))
     b = a >>= join :: N (M (N a))
     c = distrib b  :: M (N (N a))
 in c >>= join      :: M (N a)

MonadFix

Examples and intuition

maybeFix :: (a -> Maybe a) -> Maybe a
maybeFix f = ma
  where ma = f (fromJust ma)

Exercises

Implement a MonadFix instance for [].

Solution:

 listFix :: (a -> [a]) -> [a]
 listFix f = la
   where la = f (head la)

Foldable

Definition

class Foldable t where
  fold    :: Monoid m => t m -> m
  foldMap :: Monoid m => (a -> m) -> t a -> m
  foldr   :: (a -> b -> b) -> b -> t a -> b
  foldr'  :: (a -> b -> b) -> b -> t a -> b
  foldl   :: (b -> a -> b) -> b -> t a -> b
  foldl'  :: (b -> a -> b) -> b -> t a -> b
  foldr1  :: (a -> a -> a) -> t a -> a
  foldl1  :: (a -> a -> a) -> t a -> a
  toList  :: t a -> [a]
  null    :: t a -> Bool
  length  :: t a -> Int
  elem    :: Eq a => a -> t a -> Bool
  maximum :: Ord a => t a -> a
  minimum :: Ord a => t a -> a
  sum     :: Num a => t a -> a
  product :: Num a => t a -> a

Instances and examples

Exercises

Implement fold in terms of foldMap.

Solution:
```
 fold = foldMap id
```
What would you need in order to implement foldMap in terms of fold?

Solution:

A map function should exist for the instance, so we can apply the function (a -> m) to the container first.
```
 foldMap f = fold . map f
```

Implement foldMap in terms of foldr.

Solution:

 foldMap f = foldr (\a b -> mappend (f a) b) mempty

Implement foldr in terms of foldMap (hint: use the Endo monoid).

Solution:
```
 foldr f b c = foldMap (Endo . f) c `appEndo` b
```

What is the type of foldMap . foldMap? Or foldMap . foldMap . foldMap, etc.? What do they do?

Solution:

Each composition makes foldMap operate on a deeper level, so:

 foldMap :: Monoid m => (a -> m) -> t a -> m
 foldMap . foldMap :: Monoid m => (a -> m) -> t (t a) -> m
 foldMap . foldMap . foldMap :: Monoid m => (a -> m) -> t (t (t a)) -> m
    
 foldMap id [1,2,3] :: Sum Int -- 6
 (foldMap . foldMap) id [[1,2,3]] :: Sum Int -- 6
 (foldMap . foldMap . foldMap) id [[[1,2,3]]] :: Sum Int -- 6

Derived folds

Exercises

Implement toList :: Foldable f => f a -> [a] in terms of either foldr or foldMap.

Solution:
```
 toList = foldMap (replicate 1)
```
Show how one could implement the generic version of foldr in terms of toList, assuming we had only the list-specific foldr :: (a -> b -> b) -> b -> [a] -> b.

Solution:
```
 foldr f b c = foldr f b (toList c)
```

Pick some of the following functions to implement: concat, concatMap, and, or, any, all, sum, product, maximum(By), minimum(By), elem, notElem, and find. Figure out how they generalize to Foldable and come up with elegant implementations using fold or foldMap along with appropriate Monoid instances.

Solution:

 concat :: Foldable t => t [a] -> [a]
 concat = foldMap id
    
 concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
 concatMap f = foldMap (foldMap (replicate 1 . f))
    
 and :: Foldable t => t Bool -> Bool
 and = getAll . foldMap All
    
 or :: Foldable t => t Bool -> Bool
 or = getAny . foldMap Any
      
 any :: Foldable t => (a -> Bool) -> t a -> Bool
 any f = getAny . foldMap (Any . f)
    
 all :: Foldable t => (a -> Bool) t a -> Bool
 all f = getAll . foldMap (All . f)
    
 sum :: (Num a, Foldable t) => t a -> a
 sum = getSum . foldMap Sum
    
 product :: (Num a, Foldable t) => t a -> a
 product = getProduct . foldMap Product
    
 -- I think there are more elegant implementations for maximumBy, leave a comment
 -- if you have a suggestion
 maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
 maximumBy f c = head $ foldMap (\a -> [a | cmp a]) c
   where
     cmp a = all (/= LT) (map (f a) lst)
     lst = toList c
    
 elem :: (Eq a, Foldable t) => a -> t a -> Bool
 elem x c = any (==x) c
    
 find :: Foldable t => (a -> Bool) -> t a -> Maybe a 
 find f c = listToMaybe $ foldMap (\a -> [a | f a]) c 

Utility functions

sequenceA_ :: (Applicative f, Foldable t) => t (f a) -> f () takes a container full of computations and runs them in sequence, discarding the results (that is, they are used only for their effects). Since the results are discarded, the container only needs to be Foldable. (Compare with sequenceA :: (Applicative f, Traversable t) => t (f a) -> f (t a), which requires a stronger Traversable constraint in order to be able to reconstruct a container of results having the same shape as the original container.)
traverse_ :: (Applicative f, Foldable t) => (a -> f b) -> t a -> f () applies the given function to each element in a foldable container and sequences the effects (but discards the results).

Exercises

Implement traverse_ in terms of sequenceA_ and vice versa. One of these will need an extra constraint. What is it?

Solution:

 sequenceA_ :: (Applicative f, Foldable t) => t (f a) -> f ()
 sequenceA_ = traverse_ id
    
 traverse_ :: (Applicative f, Foldable t, Functor t) => (a -> f b) -> t a -> f ()
 traverse_ f c = sequenceA_ (fmap f c)

The additional constraint for implementing traverse_ in terms of sequenceA_ is the requirement of the Foldable instance t to be a Functor as well.

Traversable

Intuition

traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
sequenceA :: Applicative f => t (f a) -> f (t a)

Exercises

There are at least two natural ways to turn a tree of lists into a list of trees. What are they, and why?

Note: I’m not really sure whether my solution is natural, I think the question is rather ambiguous in the sense that it’s not clear whether the trees in the final list of trees can have lists as their values, i.e. Tree [Int] -> [Tree [Int]] is valid or only Tree [Int] -> [Tree Int] is, but let me know if you think otherwise.

Solution:

One way is to put each Node, Leaf or Empty in a list in-order, this way the structure of the tree can be recovered from the list, here is a quick sketch ([] is an arbitrary list):
```
 let tree = Node (Node (Leaf []) Empty) [] (Leaf [])
 let list = [Node Empty [] Empty, Node Empty [] Empty, Leaf [], Empty, Leaf []]
```
Give a natural way to turn a list of trees into a tree of lists.

Solution:

To recover the original tree from the list of trees, whenever we encounter a Node in the list, we catch the next three values as left, value, and right nodes of the original node.
What is the type of traverse . traverse? What does it do?

Solution:
```
 (traverse . traverse) :: Applicative f => (a -> f b) -> t (t2 a) -> f (t (t2 b))
```
It traverses on a deeper level, retaining the structure of the first level.

Implement traverse in terms of sequenceA, and vice versa.

Solution:

 sequenceA = traverse id
    
 traverseA f c = sequenceA (fmap f c)

Instances and examples

Exercises

Implement fmap and foldMap using only the Traversable methods. (Note that the Traversable module provides these implementations as fmapDefault and foldMapDefault.)

Solution:

 newtype Id a = Id { getId :: a }
    
 instance Functor Id where
   fmap f (Id x) = Id (f x)
    
 instance Applicative Id where
   pure x = Id x
   (Id f) <*> (Id x) = Id (f x)
    
 fmapDefault :: Traversable t => (a -> b) -> t a -> t b
 fmapDefault f = getId . traverse (Id . f)
    
 foldMapDefault :: (Monoid m, Traversable t) => (a -> m) -> t a -> m
 foldMapDefault f = getConst . traverse (Const . f)

See the Const Functor’s definition for intuition.

Implement Traversable instances for [], Maybe, ((,) a), and Either a.

Solution:

 instance Traversable [] where
   traverse :: Applicative f => (a -> f b) -> [a] -> f [b]
   traverse _ [] = pure []
   traverse f (x:xs) = (:) <$> f x <*> Main.traverse f xs
      
 instance Traversable Maybe where
   traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b)
      
   traverse _ Nothing = pure Nothing
   traverse f (Just x) = Just <$> f x
      
 instance Traversable ((,) c) where
   traverse :: Applicative f => (a -> f b) -> (c, a) -> f (c, b)
      
   traverse f (c, a) = (,) c <$> f a
      
 instance Traversable (Either c) where
   traverse :: Applicative f => (a -> f b) -> Either c a -> f (Either c b)
      
   traverse _ (Left c) = pure (Left c)
   traverse f (Right a) = Right <$> f a

Explain why Set is Foldable but not Traversable.

Solution:

First, in terms of laws, Set is not a Functor, thus it cannot be made into a Traversable instance, since Traversable instances require Functor superclasses.

Second, on an intuitive level: In Foldable, the goal is not to keep the shape/structure of the original container, we are trying to reduce the container into some value, and the shape of the final result doesn’t matter, but in Traversable, we ought to keep the structure of the final result, but we can’t guarantee this while using Sets, because we can define some transformation f :: Set a -> Set a which reduces the length of the Set.

See Foldable vs. Traversable and Sets, Functors and Eq confusion. and Foldable and Traversable for more details.

Show that Traversable functors compose: that is, implement an instance for Traversable (Compose f g) given Traversable instances for f and g.

Solution:

 instance (Traversable f, Traversable g) => Traversable (Compose f g) where
   traverse :: (Applicative f) => (a -> f b) -> Compose g h a -> f (Compose g h b)
   traverse f (Compose t) = Compose <$> traverse (traverse f) t

DIY Cardboard Kindle Stand (for bed)

Sun, 24 Sep 2017 00:00:00 +0100

I’ve had a Kindle for more than a year now, but I’ve only recently started to read books on it frequently, I used to read paperworks before that, and I still do sometimes prefer paperbooks if available. Anyways, my Kindle has helped me to fall asleep without struggling with all my thoughts, all I have to do is read until I fall asleep, so in a way, it has also been a remedy for my insomnia.

Now to read the Kindle in bed, you would have to hold it using your hands or buy a stand or make one, motivated by The Pursuit of Laziness I set to create mine, but I didn’t use a piece of steel, instead I used a single box of cardboard I had in home to create one in minutes. :D

It’s too easy to need much of an instruction, a few pictures and some explanation will do:

So this part shows a simple piece of cardboard cut using scissors on the front, with the sides taped to the bottom (actually if your piece of cardboard is a box, it might already be taped in that way, mine was).

On the back, there is another piece of cardboard (I took the opening of it which already had a notch line, and the size fit perfectly). I used a stapler to to attach the two sides toghether, and that’s it!

I tried it last night to make sure it’s convenient before posting here, and I tell you, it is totally comfortable and much better than holding with a hand.

Difference between Travis CI tests: PR and Push

Sat, 09 Sep 2017 00:00:00 +0100

I just want to leave this here as I often tend to look it up myself and the first time it was not as easy to figure out.

When using Travis CI along with GitHub (or other git integrations), Travis runs two tests: pr and push.

Most of the time you see both tests passing and you do not have to even wonder how they are different, but it has happened to me that one of the tests fails while the other passes and I started to wonder why.

pr

The pr test is a test run on the result of a merge between the pull-request branch and the main branch. As an example, let’s say your pull-request’s branch is called fix-user-auth and your main branch is master, in this case, pr merges fix-user-auth into master and then runs the tests on the result of the merge.

push

On the other hand, push is run on the pull-request branch itself, without merging. So in our example above, Travis would checkout to fix-user-auth and run the tests.

A case of difference

A case in which this difference might be more apparent is when your pull-request is based on a branch other than master, and some changes that your pull-request depends on are missing from master, in this case the push test may pass, but the pr test will fail.

Primitive Living Lessons Learned, Episode 0

Thu, 07 Sep 2017 00:00:00 +0100

So I just went on my first primitive living practice trip in the woods, alone, with only a pocket knife.

I decided I’m going to share the lessons I’ve learned in each trip as they are certainly going to be useful if you want to practice primitive living, I would find these useful if I could find them anywhere. I spend a lot of time reading and watching primitive living guides and experience reports, but they are never exhaustive, and this series is not meant to be exhaustive either.

Here we go:

What I did know

I spent a lot of time studying about edible wild plants, how to butcher and cook different kinds of animals and insects. I also had practiced fire by friction and read a lot and watched videos about theory of making cordages, making a bow-drill and so on. I also knew and had already built shelters for the night. So you can assume I had a basic, broad understanding of the necessary skills, but experience? Not so much.

Setup

I had a pocket knife, a Garmin GPS and a pocket first aid kid, I would expect something to go wrong along the way, so I thought I want to be safe, but not comfortable, that’s why I brought emergency necessities, but not any comfort tools and materials. I also had a canned tuna for my first breakfast, but nothing more.

Now for what is worth, I’m going in around summer’s end, September 5th, in a forest in northern Iran, Mazandaran Province. The forest starts from foothills, covering a few mounts from both sides, so it’s pretty large but also mountaneous, so I it’s hard to move in the forest.

Arrival: First Night

So I arrived at the entrace of the forest at night, it was already dark and I couldn’t build a shelter or do much, I just slept on the open ground, it was my first night in the woods alone. I was quite scared at first, lots of cracks and movements in bushes by unknown creatures, but after a few hours I figured out all these creatures are small ones that can’t be harmful to me. A few hours before dawn it got bitter cold, and I woke up, unable to go back to sleep. The first night was not the best, but could be worse.

First Day

I woke early at dawn and started moving into the forest, looking for a place to build my shelter in. I decided I’m going to follow these steps:

Build a shelter
Find water source
Build a fire
Find food

But as was expected, it didn’t go according to the plan.

Shelter

I found a nice place to stay which had a stream passing by, the stream was running and from what I knew about the area, the water was safe to drink, so water was no longer an issue. I started building my shelter, got the base wooden structure down first, but there was a catch: I couldn’t find any dry debris to put on top or inside. Last time I had built the same shelter it was autumn’s end/early spring, so there were lots of dry, fallen leaves on the ground; But this time it’s in the summer and there very few, scattered dry leaves on the ground, uncollectable.

I decided I’m going with leaves of a small tree I had found nearby which seemed to be abundant around the area and the branches had lots of close leaves on them, looked like a good choice, but it was green. I didn’t find out what I was doing wrong until I tried to sleep at night. The green leaves attracted lots of flies and insects and all sorts of annoying disturbances, and the smell wasn’t helping either. I had to endure the insects throughout the night, because sleeping outside the shelter was a no-go, the dirt beneath was too cold. I hadn’t put as much leaves on the ground, and the leaves were green (which also means they take more heat away), but still, it was much better than sleeping directly on the ground.

What I learned was, do not use green leaves for covering your shelter. This rule applies to small shelters in which you are close to the covering, as well as the leaves you use as bedding. I’ve seen people using green leaves for covering big shelters which have a high ceiling, though I don’t have any experience with those myself.

Friction Fire

The most important part of primitive living is fire, without fire you can’t cook, you can’t stay warm and you can’t defy nocturnal predators. You also can’t repel insects. You can’t make a torch, so there goes an infinite list of fire applications that you will miss.

I knew the theory of friction fire in and out, how and why it works, but what I had missed was, you are going to be in real trouble if you can’t find softwood. To my surprise, searching portions of the forest, I couldn’t find any softwood tree. Oaks were everywhere, as well as quite some other species of trees, but all of them were hardwood.

I tried different combinations of the softer woods I could find, but none of them resulted in an ember, I got smoke with one combination, but that was it. After about 5-6 hours of trying, I got real tired and gave up. By the way, I tried hand-drills, I couldn’t succeed with bow-drills as I couldn’t find suitable cordage, I tried with a promising bark that was pretty strong, but it would break as soon as I put some pressure on it, It’s also possible that I might’ve gone wrong in making the bow itself, so it would cause the breakage.

So the lesson was make sure the material you are going to practice with is available in your practice area, had I known there were no softwood in that particular forest, I would change my destination and probably succeed somewhere else. Sure, a professional survivalist must be able to start a fire in almost all situations, but this is practice and you have to start with easier steps.

I ended up shaking for 2 hours before the dawn, not a pleasant experience at all. :D

Food

The difficulties didn’t end there, without a fire, my only hope for food was specific edible plants which can be eaten raw, or fruits. Unlucky as I was, I couldn’t find a single fruit-bearing tree in the forest (I found quite a few fruit-bearing trees along the roads and paths to the forest, but not inside the forest itself), and I also couldn’t find any of the other edible plants (I was mostly looking for the onion family) that I knew of.

One of the greatest complications when starting primitive living practice anywhere other than the U.S. is that almost all guides and materials on the topic are from, and for Northern America. The Falcon Guide to Edible Wild Plants that I read is all about northern american plants. I knew it, but it’s also the case that the Northern Hemisphere of the Earth have more common of an ecology, so most of the plants found in Northern America can also be found in places like Iran, but they have their differences. Most of the tips and tricks provided in different resources are for Northern American forests, which do not always work in other places.

So all in all, I ended up not eating anything for the next 24 hours, until I got out of the forest.

Psychology

Apart from all the physical failures that I faced, which in turn caused frustration, I also had strong feelings of loneliness, boredom, and fear upon me. It was after failing to start a fire that I really felt the psychological burden on me. I had read about similar experiences, but believe me, the experience is hardly transmittable by words. A local rancher passing by the forest telling me about the leopard in the forest didn’t make things any easier.

The psychological pressure was above all other difficulties, at some point I was bursting into tears, but I couldn’t associate it with any one specific feeling, it was a mix of anger, loneliness and fear.

Anger and frustration because I couldn’t succeed in what I was trying to do. I also cut my finger at some point while carving the woods, so there was that.

Loneliness because I was all by myself and I had no company to talk to. You can really actually go insane, as seen in Cast Away, after prolonged sessions of loneliness in situations like that. Mine wasn’t long, it was only two days, but I still experienced the thought-fog, I couldn’t think straight.

Fear because I felt weak compared to the power of nature, my fear was doubled by the fact that I was alone. I felt like being in a place where everything seems to know what it is doing, but I don’t; I felt lost, not knowing what to do after my basic plans had failed.

Now I don’t know if there is much you can do about the psychological part of it, I think experience is the remedy, at least I felt how different it was between the nights, the first night, even though I wasn’t even inside the forest much, I was almost at the border of it, it was much more creepy because it was my first time, but the second night, I was in the forest and now I had a leopard in my mind pouncing on me, but I felt less fear and was more comfortable.

But in the end, what helped me was that I knew I was going to face a huge mental challenge along the way, so I was more prepared. I think it’s utterly important to be prepared for such psychological situations, knowing the reason behind your psychological challenges can help you overcome it to some extend.

Second Night

The second and last night was not all that much interesting, but it was damn sure cold and hard. At first I had to deal with the insects biting me everywhere and my feet scratching while trying to sleep in the shelter that I had wrongly built. After getting over that one and sleeping for what seemed to be ~2 hours, I woke up and felt the air temperature decreasing. I still got to sleep in intervals of 30 minutes until I woke up at around ~4 AM and my whole body was shaking. I couldn’t do much, all I did was gather the leaves underneath a little closer and more dense, and crunch my body into a ball so I felt just a little warmer, but still shaking. It took ages for the last two and a half hours to pass until dawn. At dawn I got up quickly and walked around a little to warm myself up, and then waited until I could barely see my surroundings, then I started walking out of the forest.

Initially I had decided to stay for longer, but the weather forecast had predicted a heavy rain and storm for the next night, there was no way I could withstand that. :D

Bottom Line

It was a hard trip, I lost about 2kg (4lb) weight, but all in all the experience was a good one, I certainly learned a lot and I’m not going to make the same mistakes again. I should definitly practice more and keep working on my skills.

If you are looking forward to practicing primitive living, please make sure you are safe and start small.

Success is going from failure to failure without losing your enthusiasm. —Winston Churchill

Don't chase: Become the good one

Sat, 04 Feb 2017 00:00:00 +0000

When it comes to relationships, most (unsuccessful) people are chasing the good ones. They spend time trying to find their dream partner, the perfect match, but hey, do you qualify as the dream partner of your dream partner? You fantasize about your dream partner, but have you ever thought what kind of partner does he/she dream of?

I want an angel with…

It seems to be pretty acceptable in the society to start looking for a good partner once you reach a certain age (depending on the country), and that’s when people start defining for themselves what a good partner means. What do they want out of a relationship? Well, most beginners just want sex, that’s one thing, but I’m talking about real, intimate relationships. The definition usually goes like this:

I want him/her to have

Money
Body
Sense of Humor
Empathy
…

Alright fine, that’s a good and necessary step while thinking about a relationship.

Now there are two groups of people after this step, let’s call them Group A and Group B.

Group A’s next step is to start looking for partners, which usually follows by installing Tinder, OkCupid and a bunch of other dating apps, spending more time in the bar, etc. Well it makes sense to start looking for a partner at first glance, but people in Group A are missing an important point here, they defined what a good partner means in their dictionary of life, but they haven’t really looked into their good partner’s dictionary to see what he/she wants out of a relationship, because if you don’t qualify her requirements, it’s not a deal.

Now there is a sub-group of Group A, too, and it includes the people who faced with the question “am I what she dreams of?”, they try to cheat and modify their definition of a good partner, adding a line that goes “Loves me however I am”, sorry buddy, but what if I tell you she could add the same line to her dictionary? That’s not a deal, you want a good partner as you defined it, you have to be a good partner as she defines it.

On the other hand, Group B doesn’t follow the same path as Group A. Group B starts by trying to predict what his dream partner would want out of a relationship. Empathy? Loyalty? Knowledge? Body? They take a pen and a paper out and write a list of what they think their dream partner would want them to have, what would she want them to be, and they start working on those, and I bet it’s not going to be easy, knowledge doesn’t pop up after a good night’s sleep, you have to spend years reading books and learning to get it. A good body doesn’t poof out if you wish it to, you have to spend years being committed to exercise and eating well, and that’s not easy. After all, what you define as a good partner ain’t easy either, is it?

Now do you want your dream partner to fall for you the way you fall for her, without having to chase her with a net? Write down a list of qualifications you expect your dream partner to look for, and start working your ass off reaching them, and I tell you, you will have a much easier next step after this. You won’t have to chase girls hoping the 34th one doesn’t reject you because “she likes you however you are”.

If I know one thing about life, it’s the fact that you have to work your ass off in order to reach your dreams, dreams aren’t easy, and a deep, intimate relationship really is a dream.

mahdi

What is `Box` and how is it different from `String` in Rust?

The Stack

Box, String and Vec: Pointers to Heap

Should I use Box<str> or String?

On Inherent Subjectivity of Some Things

What is Objectivity Anyway?

Inherently Subjective Things

So What? (Or: Why is This Important?)

References

Iran Sanctions: A Story of Discrimination and Isolation

The Internet

Drugs, Medicine, and Medical Devices

Currency Fluctuations: An Unpredictable Life

A Weak Economy’s Rippling Effect

Of Rolling Eyes and Shrugs

Final Message

Links

Going Self-Hosted: Moving away from Google and others

microG

Email

Cloud Storage

Contacts and Calendar

Notes

Application Store

Two-factor Authentication

Password Manager

Firefox Containers

Not the easiet thing

Mathematical Induction for proving tiling methods

Typoclassopedia: Exercise solutions

Functor

Instances

Exercises

Functor Laws

Exercises

Category Theory

Introduction to categories

Category laws:

Exercises

Functors

Functor laws:

Exercises

Applicative

Laws

Exercises

Instances

Exercises

Utility functions

Exercises

Alternative formulation

Definition

Laws:

Isomorphism

Exercises

Monad

Definition

Instances

Exercises

Intuition

Exercises

Laws

Exercises

Monad Transformers

Definition and laws

Exercises

Composing Monads

Exercises

MonadFix

Examples and intuition

Exercises

Foldable

Definition

Instances and examples

Exercises

Derived folds

Exercises

Utility functions

Exercises

Traversable

Should I use `Box<str>` or `String`?