diff --git a/pythonetc/README.md b/pythonetc/README.md
index 173ba9b..5de5fd4 100644
--- a/pythonetc/README.md
+++ b/pythonetc/README.md
@@ -42,6 +42,10 @@ More:
 1. ./zen.md
 1. ./nan.md
 1. ./snippets/itertools.md
+1. ./format.md
+1. ./object-type.md
+1. ./objects.md
+1. ./sys-modules.md
 1. ./numbers.md
 1. ./simplenamespace.md
 1. ./snippets/to-str.md
diff --git a/pythonetc/format.md b/pythonetc/format.md
new file mode 100644
index 0000000..8804fdb
--- /dev/null
+++ b/pythonetc/format.md
@@ -0,0 +1,14 @@
+There is built-in function `format` that basically just calls `__format__` method of the passed argument type with passed spec. It is used in `str.format` as well.
+
+
+```python
+class A:
+    def __format__(self, spec):
+        return spec
+
+format(A(), 'oh hi mark')
+# 'oh hi mark'
+
+'{:oh hi mark}'.format(A())
+# 'oh hi mark'
+```
diff --git a/pythonetc/object-type.md b/pythonetc/object-type.md
new file mode 100644
index 0000000..4d504c9
--- /dev/null
+++ b/pythonetc/object-type.md
@@ -0,0 +1,23 @@
+Every class is an instance of it's metaclass. The default metaclass is `type`. You can use this knowledge to check if something is a class or is an instance:
+
+```python
+class A: pass
+isinstance(A, type)   # True
+isinstance(A(), type) # False
+```
+
+However, class and instance are both an instance of `object`!
+
+```python
+isinstance(A(), object) # True
+isinstance(A, object)   # True
+```
+
+This is because `type` an instance of `object` and subclass of `object` at the same time, and `object` is instance of `type` and no parent classes.
+
+```python
+type(type)      # type
+type(object)    # type
+type.__mro__    # (type, object)
+object.__mro__  # (object,)
+```
diff --git a/pythonetc/objects.md b/pythonetc/objects.md
new file mode 100644
index 0000000..3caeead
--- /dev/null
+++ b/pythonetc/objects.md
@@ -0,0 +1,31 @@
+Everything is an object, including functions, lambdas, and generators:
+
+```python
+g = (i for i in [])
+def f(): pass
+
+type(g).__mro__  # (generator, object)
+type(f).__mro__  # (function, object)
+type(lambda:0).__mro__  # (function, object)
+```
+
+Generators have no `__dict__` but functions do!
+
+```python
+def count(f):
+    def w():
+        w.calls += 1
+        return f()
+    # let's store an attribute in the function!
+    w.calls = 0
+    return w
+
+@count
+def f():
+    return 'hello'
+
+f()
+f()
+f.calls
+# 2
+```
diff --git a/pythonetc/sys-modules.md b/pythonetc/sys-modules.md
new file mode 100644
index 0000000..629b052
--- /dev/null
+++ b/pythonetc/sys-modules.md
@@ -0,0 +1,24 @@
+Python caches every imported module is `sys.modules`:
+
+```python
+import sys
+import typing
+
+sys.modules['typing']
+# 
+
+len(sys.modules)
+# 637
+```
+
+You can reload any module with `importlib.reload` to force it to be executed again. Be careful, though, since every object from the module will be recreated, you can break all `isinstance` checks and have hard times with debugging it.
+
+```python
+old_list = typing.List
+old_list is typing.List
+# True
+
+importlib.reload(typing)
+old_list is typing.List
+# False
+```