On tree-sorting

Book stores. Music stores. Clothing stores. All of them sort their product by one category or another, most likely the one that makes most logical sense at the point of initial design of the sorting algorithm, a.k.a. the store itself. The problem is that once you sort by genre, it gets pretty tough finding an artist, if you have no idea about, or simply can’t remember the location of the artist on the genre dimension.

This is why sorting by grouping into tree-like structures, based on a specific paradigm, makes absolutely no sense, since there are endless ways to sort an array of objects. You could argue that sorting by the “most common” paradigm makes most sense, but it only does so in the given context.

I have nothing against sorting words alphabetically in a dictionary. Us humans have to categorize and twist data to get some sense out of it, but there is no need to store data in the same way that we understand it? Of course you could argue that then you no longer need to understand the data, and can simply read/write it, well then why do computers yet have to learn how to understand natural language, recognize objects and alike? And why are we so badly trying to develop intelligent systems which “know” us, and can come with the information we need, whenever we need it? My guess is, it’s because we really do want the computer to understand the data fed into it.

Out of context:

       Does that also mean that intelligence comes with understanding and vice-versa?

I seem to finally understand the up-side of using relational data-structures, since this is exactly what they try to achieve. However relational data-store is not enough, you can’t store all the data in the world, and at times it is much quicker to compute it. So as long as it is faster to store(and retrieve at a later point) – store(keep in store), and in all the other cases compute(*or do some smart guessing). And since you don’t know what it is that you will compute, and why; generics, and datatype irrelvance seem to be perfect for this, more precisely I’m talking about generics 🙂

So:

    Truely dynamic systems must rely havily upon relationality and generics?

P.S. I bought a book titled Beautiful Code, written by big guys in programming, about architecture of their software and development, so you will be hearing a lot of that I guess 🙂

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s