Evolutionary computing (neural networks and related models, like genetic algorithms) and computational logic (logic programming, constraint logic programming, etc.) are two -- at first view -- quite different non-standard programming paradigms which have become popular within the last few years. Both their flavor is extensional, i.e. algorithms or programs are not explicitly stated but instead some desired result or behavior is used as target and the actual computational task is achieved via some general solution strategies.
The generality of the resolution processes (referring to a general meaning of the term: the process of finding a solution) used with these approaches is one of the reasons for their attractivity. It frees the software developer of unnecessary detailed implementational work. This aspect becomes in particular important when one incorporates aspects of concurrency. Problems like synchronization can be hidden from the programmer. Thus, both approaches are especially well suited for parallel and distributed computation.
But there are also distinct differences between both approaches: neural network and related paradigms optimize an algorithm (in the sense that they try to achieve a better ``performance'' depending on the concrete problem) whereas in computational logic the aim is to search for a justifying proof. Thus, we have two different criteria for solutions: optimality vs. correctness; the resolution process in both frameworks can be described as optimization and constraint satisfaction, respectively.
The difference of both approaches is strongly related to their basic ``data structures'': whereas the neural network approach is based on a continuous and probabilistic representations of algorithms it aims to optimize (e.g. weight matrices) the conventional (logic) programming approach foots on a discrete algorithmic model (e.g. proof trees, rewrite systems).