diff --git a/pythonetc/final.md b/pythonetc/final.md
new file mode 100644
index 0000000..b21045b
--- /dev/null
+++ b/pythonetc/final.md
@@ -0,0 +1,21 @@
+
+Some languages, like Java, allow you to mark a class as `final` that means you can't inherit from it. There is how it can be implemented in a few lines (thanks to [Nikita Sobolev](https://github.com/sobolevn) for the implementation!):
+
+```python
+def _init_subclass(cls, *args, **kwargs) -> None:
+ raise TypeError('no subclassing!')
+
+def final(cls):
+ setattr(cls, '__init_subclass__', classmethod(_init_subclass))
+ return cls
+
+@final
+class A:
+ pass
+
+class B(A):
+ pass
+# TypeError: no subclassing!
+```
+
+In python 3.8, [PEP-591](https://www.python.org/dev/peps/pep-0591/) introduced [typing.final](https://docs.python.org/3/library/typing.html#typing.final). It doesn't make a runtime check but is processed by mypy at static type checking instead.
diff --git a/pythonetc/fnmatch.md b/pythonetc/fnmatch.md
new file mode 100644
index 0000000..5addc6a
--- /dev/null
+++ b/pythonetc/fnmatch.md
@@ -0,0 +1,13 @@
+Module [fnmatch](https://docs.python.org/3/library/fnmatch.html) provides a few functions to work with Unix-like patterns:
+
+```python
+from fnmatch import fnmatch
+
+fnmatch('example.py', '*.py')
+# True
+
+fnmatch('example.py', '*.cpp')
+# False
+```
+
+Internally, it parses the given pattern and compiles it into a regular expression. So, don't expect it to be faster than [re](https://docs.python.org/3/library/re.html#module-re). Also, if you want to match actual files in the filesystem, use [pathlib.Path.glob](https://docs.python.org/3/library/pathlib.html#pathlib.Path.glob) instead.
diff --git a/pythonetc/hamming.md b/pythonetc/hamming.md
new file mode 100644
index 0000000..7ff28e6
--- /dev/null
+++ b/pythonetc/hamming.md
@@ -0,0 +1,17 @@
+[Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance) is the number of positions at which the corresponding symbols are different. It's the simplest measure of difference between 2 strings and can be implemented in a few lines:
+
+```python
+from itertools import zip_longest
+
+def hamming(left, right):
+ return sum([sl != sr for sl, sr in zip_longest(left, right)])
+
+hamming('hello', 'hello')
+# 0
+
+hamming('hello', 'hallo')
+# 1
+
+hamming('hello', 'helol')
+# 2
+```
diff --git a/pythonetc/itertools.md b/pythonetc/itertools.md
new file mode 100644
index 0000000..fcefa75
--- /dev/null
+++ b/pythonetc/itertools.md
@@ -0,0 +1,23 @@
+Some functional languages, like Elixir, have in the standard library a huge collection of function to work with lazy enumerables (in Python, we name them [iterators](https://articles.orsinium.dev/python/iterators/)). In Python, this role is on [itertools](https://docs.python.org/3/library/itertools.html)/ However, `itertools` is a relatively small collection of such functions, it contains only most important and basic ones (maybe, a bit of junk, but so). The documentation has [Itertools Recipes](https://docs.python.org/3/library/itertools.html#itertools-recipes) with some useful functions. A few of examples:
+
+```python
+def take(n, iterable):
+ "Return first n items of the iterable as a list"
+ return list(islice(iterable, n))
+
+def prepend(value, iterator):
+ "Prepend a single value in front of an iterator"
+ # prepend(1, [2, 3, 4]) -> 1 2 3 4
+ return chain([value], iterator)
+
+def tail(n, iterable):
+ "Return an iterator over the last n items"
+ # tail(3, 'ABCDEFG') --> E F G
+ return iter(collections.deque(iterable, maxlen=n))
+
+def nth(iterable, n, default=None):
+ "Returns the nth item or a default value"
+ return next(islice(iterable, n, None), default)
+```
+
+All these examples and much more can be imported from [more-itertools](https://github.com/more-itertools/more-itertools) third-party library.