I wrote my own Poly Tree Node Class.

class PolyTreeNode  attr_reader :children, :parent, :value  def initialize(value)    @value = value    @parent = nil    @children = []  end

 def parent=(parent)    @parent.children.delete(self) if @parent    @parent = parent    unless parent == nil || parent.children.include?(self)      parent.children << self    end  end

Since a tree node points to its parent and to its children, I need to take care of both pointers when a new parent is assigned. Since this node’s parent will point to it, I need to remove it from its parent’s children.

 def add_child(child)    child.parent = self  end

 def remove_child(child)    raise "That is not my child!" unless @children.include?(child)    child.parent = nil  end

Likewise, when a child is added to a node, I need to add pointers to both objects. When adding a child, I need to set this node to be that child’s parent, and the #parent= method that’s already been defined will take care of adding the child to this nodes list of children.

A little bit of magic happens with remove child. When child.parent is assigned to nil that will remove the two objects pointers to each other. When an object has no pointers to it, it gets “garbage collected” and no longer exists. In programming, if nobody knows about you, there’s no reason for you to exist.

 def dfs(target_value)    return self if @value == target_value    return nil if @children.empty?    result_node = nil    @children.each do |child|      result_node = child.dfs(target_value)      break if result_node    end    result_node  end

This is depth first search. It recursively searches each child it sees. That means that it will get to a return statement before it actually returns a value from the call stack.

 def bfs(target_value)    queue = [self]    until queue.empty?      node = queue.shift      return node if node.value == target_value      node.children.each {|child| queue << child }    end    nil  end  

This is breadth first search. It checks each node of the tree by adding a node’s children to the queue as it checks them.

def inspect    @value.inspect  end end

Regular Python lists are flexible and useful, but overkill in some situations. They allocate large blocks of contiguous memory, which becomes increasingly difficult as memory is in use.

Linked list nodes reserve just enough memory for the object value they want to refer to, a reference to it, and a reference to the next node in the list.

As we talked about in ADT, the implementation requires a lot of consideration to get the most economic method.

In the above case, linked list node are objects (nodes) with a value and a reference to other similar objects. It is not lists made up of an item (value) and a sub-list (rest). Node is no the list itself; it’s just a piece. It needs a wrapped class to track the list. Thus linked list is created.

In CS we recycle our intuition about the outside world as ADTs. We abstract the data and operations, and suppress the implementation. 

For example, list is sequences of items that can be added, removed, accessed by position. Stack is specialized list where we only have access to most recently added item (i.e. we can only remove the top one and added to the top. First In Last Out.). Queue is specialized list where we only have access to the earliest added item. (like a queue in coffee shop, First In First Out). Sack is specialized list where we remove items at random position. 

The public interface of our ADT should be constant, but inside we could implement it in various ways using list or even dictionary. When deciding which implementation we should use, we need to consider the amount of time needed for the code to run when the size of queue/ stack/ sack is huge. For example, if we decide to pop and add to position 0, then when an item is added, all other items need to move one place to the right; when an item is removed, all other items need to move one place to the left. And this is gonna cost a lot of energy.

List comprehension is a really convenient way to code more concisely and clearly. Instead using a for loop which consists at least two lines, we can use one line to do the same thing. And it creates a new list from an old list without changing it.

For example:

return [for name in iterable if condition]

does the same thing as

new_list = []

for name in iterable:

if condition:

   new_list.append(name)

Introduction

Object oriented programming started with the development of these 2 programming language.

CLU

Smalltalk

These languages were not able to propel the OOP concepts till the advent of Java , followed by C++ and Python.

Abstract Data Type

The core of all Object Oriented programming is Abstract Data Type. The fundamental use of Abstract data type is that we can add user defined data type…

After my Writing-Without-Writing Project, it became clear to me - esp. when I began coding - that Code was just Text and that Text was fundamentally a Social Object around which people and meanings could gather. That is, however complex a piece of software might be, it can still be printed onto paper, meaning that it is textual. Even more so, it is textual be design and specification: A line of code is made up of characters of a given alphabet, something which hasn't changed since  clay tablets were being inscribed with cuneiform script by ancient Sumerians of the 4th millennium BC. The only real difference is we traded the clay tablet and reed stylus for a keyboard and a computer.

Text, then, as written language, is the representation of a language by means of a writing system. Writing systems may change, but Text stays the same. 

A writing system is an organized regular method (typically standardized) of information storage and transfer for the communication of messages (expressing thoughts or ideas) in a language by visually (or possibly tactilely) encoding and decoding (known as writing and reading) with a set of signs or symbols, both known generally as characters (with the set collective referred to as a 'script'). These characters, often including letters and numbers, are usually recorded onto a durable medium such as paper or electronic storage/display, although non-durable methods may also be used, such as writing in sand or skywriting.

via Wikipedia

I conjecture that Code, Text, Writing, are all various forms of "language media". Furthermore,

In literary theory, a text is any object that can be "read," whether this object is a work of literature, a street sign, an arrangement of buildings on a city block, or styles of clothing. It is a coherent set of symbols that transmits some kind of informative message. This set of symbols is considered in terms of the informative message's content, rather than in terms of its physical form or the medium in which it is represented.

via Wikipedia

Therefore, what will heretofore be referred to as "The Datatypes Project" is really an extension of the "Writing-Without-Writing" Project, which was an extension of "The History-Project", which in turn was an extension of "The Exhibition in Tonal Cinema" Project. For the last 20+ years, I have been working on strategic intermedia art projects; intermedia because I am committing to a singular Expression through at least three different media, Word, Image, and Sound; strategic because the underlying concepts - the "Message" to be expounded - were carefully chosen through a critical process of discourse analysis, media ecology, and other "Critiques of Currentness". The Datatypes Project is the culmination of this work where I will try a hand at a new kind of Abstraction: a cross between multiple forms of Abstraction, from abstraction in mathematics, to abstraction in computer science (ex. data abstraction), to abstraction in philosophy and in arts & culture.

In other words, I want to make "abstraction" of "abstraction" itself, break it down into its components, its constituent parts, and visualize "abstract data types" in an aesthetic, painterly manner. I want to make my paintings a form of information design, themselves a kind of "abstract machine" whose language and mechanics are the language and mechanics of Painting.

What is an Abstraction?

Abstraction is a process by which concepts are derived from the usage and classification of literal ("real" or "concrete") concepts, first principles, or other methods. "An abstraction" is the product of this process – a concept that acts as a super-categorical noun for all subordinate concepts, and connects any related concepts as a group, field, or category.

via Wikipedia

Some examples of common abstract data types I may treat are (but not limited to):

Container

List

Map/Associative array/Dictionary

Multimap

Priority queue

Queue

Deque

Set

Multiset

Stack

String

Tree

Graph

There you have it. The Datatypes Project has begun. May the games begin and the good times roll. I will be interspersing my work with concepts and notation pulled from game theory, network theory, complexity science, theoretical computer science, and other mathematical domains such as linear algebra, calculus, catastrophe theory, extreme value theory, and so on.