diff --git a/pythonetc/README.md b/pythonetc/README.md
index 97478e0..a89d67d 100644
--- a/pythonetc/README.md
+++ b/pythonetc/README.md
@@ -87,6 +87,8 @@ More:
 1. ./typed-dict.md
 1. ./getattr-annotation.md
 1. ./eval-strategy.md
+1. ./deepcopy.md
+1. ./eval-order.md
 
 Out of order:
 
@@ -122,5 +124,4 @@ Make your own exceptions
 When to use is
 Key error message
 In uses hash, not eq
-Power order in python `**`
 sre_parse
diff --git a/pythonetc/deepcopy.md b/pythonetc/deepcopy.md
new file mode 100644
index 0000000..c9cd099
--- /dev/null
+++ b/pythonetc/deepcopy.md
@@ -0,0 +1,57 @@
+What if we want to modify a collection inside a function but don't want these modifications affect the caller code? Then we should explicitly copy the value.
+
+For this purpose, all built-in collections provide method `.copy`:
+
+```python
+def f(v2):
+  v2 = v2.copy()
+  v2.append(2)
+  print(f'{v2=}')
+  # v2=[1, 2]
+v1 = [1]
+f(v1)
+print(f'{v1=}')
+# v1=[1]
+```
+
+Custom objects (and built-in collections too) can be copied using [copy.copy](https://docs.python.org/3/library/copy.html):
+
+```python
+import copy
+
+class C:
+    pass
+
+def f(v2: C):
+  v2 = copy.copy(v2)
+  v2.p = 2
+  print(f'{v2.p=}')
+  # v2.p=2
+
+v1 = C()
+v1.p = 1
+f(v1)
+print(f'{v1.p=}')
+# v1.p=1
+```
+
+However, `copy.copy` copies only the object itself but not underlying objects:
+
+```python
+v1 = [[1]]
+v2 = copy.copy(v1)
+v2.append(2)
+v2[0].append(3)
+print(f'{v1=}, {v2=}')
+# v1=[[1, 3]], v2=[[1, 3], 2]
+```
+
+So, if you need to copy all subobjects recursively, use, `copy.deepcopy`:
+
+```python
+v1 = [[1]]
+v2 = copy.deepcopy(v1)
+v2[0].append(2)
+print(f'{v1=}, {v2=}')
+# v1=[[1]], v2=[[1, 2]]
+```
diff --git a/pythonetc/eval-order.md b/pythonetc/eval-order.md
new file mode 100644
index 0000000..1625d22
--- /dev/null
+++ b/pythonetc/eval-order.md
@@ -0,0 +1,30 @@
+Python uses [eager evaluation](https://en.wikipedia.org/wiki/Eager_evaluation). When a function is called, all it's arguments are evaluated from left to right and only then their results are passed into the function:
+
+```python
+print(print(1) or 2, print(3) or 4)
+# 1
+# 3
+# 2 4
+```
+
+Operators `and` and `or` are lazy, the right value is evaluated only if needed (for `or` if the left value is falsy, and for `and` if the left value is truely):
+
+```python
+print(1) or print(2) and print(3)
+# 1
+# 2
+```
+
+For mathematical operators, the precedence is how it is in math:
+
+```python
+1 + 2 * 3
+# 7
+```
+
+The most interesting case is operator `**` (power) which is (supposedly, the only thing in Python which is) evaluated from right to left:
+
+```python
+2 ** 3 ** 4 == 2 ** (3 ** 4)
+# True
+```