Delete obsolete docs

Author: msimacek

docs/contributor/IMPLEMENTATION_DETAILS.md

@@ -1,70 +1,5 @@
 # Implementation Details
 
-## Abstract Operations on Python Objects
-
-Many generic operations on Python objects in CPython are defined in the header
-files `object.h` and `abstract.h`. These operations are widely used and their
-interplay and intricacies are the cause for the conversion, error message, and
-control flow bugs when not mimicked correctly. Our current approach is to
-provide many of these abstract operations as part of the `PythonObjectLibrary`.
-
-### Common operations in the PythonObjectLibrary
-
-The code has evolved over time, so not all built-in nodes are prime examples of
-messages that should be used from the PythonObjectLibrary. We are refactoring
-this as we go, but here are a few examples for things you can (or should soon be
-able to) use the PythonObjectLibrary for:
-
- - casting and coercion to `java.lang.String`, array-sized Java `int`, Python
-   index, fileno, `double`, filesystem path, iterator, and more
- - reading the class of an object
- - accessing the `__dict__` attribute of an object
- - hashing objects and testing for equality
- - testing for truthy-ness
- - getting the length
- - testing for abstract types such as `mapping`, `sequence`, `callable`
- - invoking methods or executing callables
- - access objects through the buffer protocol
-
-### PythonObjectLibrary functions with and without state
-
-Usually, there are at least two messages for each operation - one that takes a
-`ThreadState` argument, and one that doesn't. The intent is to allow passing of
-exception state and caller information similar to how we do it with the `PFrame`
-argument even across library messages, which cannot take a VirtualFrame.
-
-All nodes that are used in message implementations must allow uncached
-usage. Often (e.g. in the case of the generic `CallNode`) they offer execute
-methods with and without frames. If a `ThreadState` was passed to the message, a
-frame to pass to the node can be reconstructed using
-`PArguments.frameForCall(threadState)`. Here's an example:
-
-```java
-@ExportMessage
-long messageWithState(ThreadState state,
-        @Cached CallNode callNode) {
-    Object callable = ...
-
-    if (state != null) {
-        return callNode.execute(PArguments.frameForCall(state), callable, arguments);
-    } else {
-        return callNode.execute(callable, arguments);
-    }
-}
-```
-
-*Note*: It is **always** preferable to call an `execute` method with a
-`VirtualFrame` when both one with and without exist! The reason is that this
-avoids materialization of the frame state in more cases, as described on the
-section on Python's global thread state above.
-
-### Other libraries in the codebase
-
-Accessing hashing storages (the storage for `dict`, `set`, and `frozenset`)
-should be done via the `HashingStorageLibrary`. We are in the process of
-creating a `SequenceStorageLibrary` for sequence types (`tuple`, `list`) to
-replace the `SequenceStorageNodes` collection of classes.
-
 ## Python Global Thread State
 
 In CPython, each stack frame is allocated on the heap, and there's a global