Original title is Aspect-Oriented: a Candidate for the Biologically Inspired Programming Paradigm for Neural Networks and Evolvable Software. Will be posted in several blogs, this is the first part.
Abstract
We observe that the nervous systems of biology handle “the non-orthogonal concerns” effectively other than the Object-Oriented paradigm does. This natural phenomenon inspires us with a programming paradigm to handle “cross-cutting”. It is argued that the Aspect-Oriented paradigm is a candidate for the biologically inspired programming paradigm. To support this point, the Aspect-Oriented paradigm is used to implement a simple Artificial Neural Networks(ANN) and the preliminary experiment shows good results. In addition, we proposed a biologically inspired framework of evolvable software which could be implemented by using the Aspect-Oriented paradigm combining with neurocomputing and genetic computing.
Key words: biologically-inspired computing,programming paradigm,aspect-oriented programming, object-oriented,evolvable software
1 Introduction
Neural networks are massively parallel processing systems that require expensive and usually not available hardware, in order to be realized. Instead of hardware implementation software simulation is widely used in research and industry, for its low costs and flexibility. Moreover, Object-Oriented Programming(OOP) language is the usual choice to implement artificial neural networks. The artificial neural networks, however, implemented with Object Oriented(OO) technology provide little support to change the size and topology of the neural networks in runtime[1,2]. Furthermore, the parallelism of artificial neural networks is not friendly to the programmers who have to transform manually the parallel neural networks into the codes executed serially since an OO program is a collection of dialoguing of a group of objects indeed. This manual transformation is a complex process and the final implementations are often hard to be reused. We argue that these problems in implementation of artificial neural networks can be solved by using Aspect-Oriented Programming (AOP).
Our research reveals that nervous systems of biology handle “non-orthogonal concerns''(cross-cutting) effectively. This natural phenomenon inspires a programming paradigm for neural networks and evolvable software, which can handle non-orthogonal concerns effectively as that of nervous systems of biology. As far as we know, there is no discussion on this phenomenon.
Moreover, we believe that the AO paradigm is a candidate for the desired paradigm since the AO paradigm partly satisfies the considerations to implement the desired paradigm and bears a natural analogy with nerve systems. To verify this idea, we implement a simple artificial neural network which solves the MONK’s problem using AOP.
Nevertheless, the simulation of neural networks is never the only thing we talk about here. The more interesting topic in this paper is how to apply artificial neural networks in evolvable software development though this idea is very young now. The next section gives brief reviews on separation of concerns and AOP. The biologically-inspired programming paradigm is discussed in detail in section 3. The implementation of ANN using the AO paradigm is arranged in section 4. We propose a biologically-inspired framework of evolvable software in section 5. Section 6 is the conclusion.
2 Reviews on the Principle of Separation of Concerns and AOP
One of the approaches to solve complex problems is to divide the problem into some smaller, simpler and loose coupling sub-problems, which is called the separation of concerns principle [3]. The principle confirms that we could not handle many problems at a time and we should deal with problems one by one, and the important problem should be represented intentionally (clearly and declaredly) and should be localized. Thus we can get intelligibility, adaptability, reusability and many other important qualities of software systems since the degree of satisfaction of software requirements could be conveniently verified with such intentional representation and localization. Nevertheless, the separation of concerns principle gives no guide to separate concerns. Many methods are proposed in the past decades, such as procedure-oriented method and OO method, to e↵ectively handle orthogonal concerns. Unfortunately, many concerns are non-orthogonal. As a result, there are massive redundancies when we represent all of these problems intentionally and locally with these methods.
Aspect-Oriented Programming (AOP) [4]provides a mechanism to handle non-orthogonal concerns by modularizing cross-cutting via augmenting the Object-Oriented programming paradigm with Aspect, join point, Pointcut and Advice[5]. AOP is based on the idea that computer systems are better programmed by separately specifying the various concerns and properties or areas of interest of a system and some description of their relationships, and then relying on instruments in the AOP environment to weave or compose them together into a coherent program.[6] AOP does what OOP cannot do effectively, that is clearly and cleanly modularize functional system code, i.e. source code, by separating concerns into well localized units, called aspects, to eliminate code tangling.
The OO technology becomes popular owing to its synthesizing three important factors of software development, i.e. computer platform, thought way and the features of issues. The basic elements of the OO paradigm are objects and interactions between them. This paradigm is in harmony with the thought process of humans and the rules of the natural world and hence that we can map problem space to design space directly, and then to programming space[7]. It should be pointed out that the rules of the nature world the OO paradigm inspired are the rules of the mechanistic nature. We can innovate new software technology with inspirations from the organic nature to handle non-orthogonal concerns effectively other than OO does[12].
[To be continued.]