diff --git a/pythonetc/README.md b/pythonetc/README.md
index 4fb0d5b..03d66e0 100644
--- a/pythonetc/README.md
+++ b/pythonetc/README.md
@@ -12,6 +12,16 @@ Reasons to read posts from the cannel rather than here:
You don't need telegram to read the channel using the link above. If neither of it stops you, sure, go ahead, read it here.
+## To publish
+
++ atexit
++ faulthandler
++ faulthandler2
++ future-annotations
++ union
++ lookup-error
++ is
+
## To write
These are ideas for future posts. Let me know if you want to write a guest post on any of these topics.
@@ -33,12 +43,20 @@ These are ideas for future posts. Let me know if you want to write a guest post
+ Import hooks
+ TypeVar
+ Bare except
-+ Lookup error
+ Make your own exceptions
-+ When to use is
+ In uses hash, not eq
+ super()
+ gc
+ trace
+ del
+ destructor
++ iterator vs iterable
++ next()
++ `__length_hint__`
++ generators
++ yield from
++ yield+return
++ yield+return with a value
++ generator.throw()
++ generator.close
++ re.scanner
diff --git a/pythonetc/is.md b/pythonetc/is.md
new file mode 100644
index 0000000..558309a
--- /dev/null
+++ b/pythonetc/is.md
@@ -0,0 +1,39 @@
+# is
+
+The operator `is` checks if the two given objects are the same object in the memory:
+
+```python
+{} is {} # False
+d = {}
+d is d # True
+```
+
+Since types are also objects, you can use it to compare types:
+
+```python
+type(1) is int # True
+type(1) is float # False
+type(1) is not float # True
+```
+
+And you can also use `==` for comparing types:
+
+```python
+type(1) == int # True
+```
+
+So, when to use `is` and when to use `==`? There are some best practices:
+
++ Use `is` to compare with `None`: `var is None`.
+
++ Use `is` to compare with `True` and `False`. However, don't explicitly check for `True` and `False` in conditions, prefer just `if user.admin` instead of `if user.admin is True`. However, the latter can be useful in tests: `assert actual is True`.
+
++ Use `isinstance` to compare types: `if isinstance(user, LoggedInUser)`. The big difference is that it allows subclasses. So if you have a class `Admin` which is subclass of `LoggedInUser`, it will pass this check.
+
++ Use `is` in some rare cases when you explicitly want to allow only the given type without subclasses: `type(user) is Admin`. Keep in mind, that `mypy` will refine the type only for `isinstance` but not for `type is`.
+
++ Use `is` to compare [enum](https://docs.python.org/3/library/enum.html) members: `color is Color.RED`.
+
++ Use `==` in ORMs and query builders like [sqlalchemy](https://www.sqlalchemy.org/): `session.query(User).filter(User.admin == True)`. The reason is that `is` behavior cannot be redefined using magic methods but `==` can (using `__eq__`).
+
++ Use `==` in all other cases. In particular, always use `==` to compare values: `answer == 42`.
diff --git a/pythonetc/lookup-error.md b/pythonetc/lookup-error.md
new file mode 100644
index 0000000..bb61838
--- /dev/null
+++ b/pythonetc/lookup-error.md
@@ -0,0 +1,19 @@
+# LookupError
+
+`LookupError` is a base class for `IndexError` and `KeyError`:
+
+```python
+KeyError.mro()
+# [KeyError, LookupError, Exception, BaseException, object]
+IndexError.mro()
+# [IndexError, LookupError, Exception, BaseException, object]
+```
+
+The main purpose of this intermediate exception is to simplify a bit lookup for deeply nested structures when any of these two exceptions may occur:
+
+```python
+try:
+ username = resp['posts'][-1]['authors'][0]['name']
+except LookupError:
+ username = None
+```