The power of logic

I've recently stumbled across a language called prolog. What is so interesting about it is the way in which you can use the logic to solve problems. Programs in prolog aren't written using instruction sets but through logical rules. The language then resolves the relationship between the objects and rules you've given it and can deduce some pretty impressive things. This will then be my focus for the next while, since through prolog I hope to gain some background into the language used at our very own university's A.I research departments.

Trees and neural networks

Working on trees reminds of brains and how much of a headache they are. Whilst trying to write up a neural network of my own I've started to realize that my lack of graph theory is hindering me, which means to the maths go I must. I'm beginning to find a strong and stronger connection between maths and computer science and though it may seem evident at a superficial level, to start actually digging into the meat of the systems is a wonderful experience. In regards to that I think that my post next week will be regarding lambda calculus, hopefully a mini introduction to it!

On recursion

Object oriented programming and recursion go hand in hand. But not only because of the way recursive methods can be written. I contend that to use OOP is to be recursive. That is to say the solution to problems in OOP is recursive.
Take for example the equivalent of constructing a building object using programming.
To build an entire structure without any plans would of course be an insurmountable task, but if we break the problem into smaller pieces the solution will reveal itself.
We begin by stating that we want to create a building object.
In order to build a building we need bricks,cement and workers.
Now we instead solve the simpler problems of creating a brick object, a cement object and a worker object ( they are by definition simpler than the building object since the building object will utilize all of their complexity as well as its own )
This idea can be scaled to greater and smaller degrees, but the point remains: Recursion is the spirit of solving big problems by applying the same solution to smaller problems.
OOP programming solves the big problem of complex systems by implementing a bunch of simpler systems first ( objects!)

On object oriented programming

I think my favourite aspect regarding the OOP paradigm is the way in which it reflects our human ability to create intuitive systems out of what is at first a seemingly incomprehensible network of bits. The fact that we cluster elements of data and the tools to alter that data into things like objects is fundamentally important to facilitating a clear understanding of what it is we're working with when programming and how it operates.

The most important aspect of OOP I think is not the amount of coding it saves you, but the amount of clarity it provides to its user.