Abstract Software Development

Can C++ provide class invariants?

2012-01-04T21:06:00.000-08:00

There is a long-standing wish of equipping C++ classes with invariants. The wish was mentioned by, Stroustrup the designer and original implementer of C++. Ironically, it is precisely the design of C++ exceptions that takes away any hope of extending C++ class to include invariants.

In order for the notion of invariant to be of any use, the runtime library needs to throw an exception in case the conditions stated in the invariants of a class are violated. However, C++ can only catch exceptions thrown within the C++ source code, not those coming from external sources such as the operating system or the runtime library.

Thus, the only possible implementation of invariants is that the programmer writes the code for testing the invariants at end of each (public) method of a class. The tail-code can then throw exceptions as needed. In other words, any mechanism for specifying invariants as part of the definition of a class will serve no purpose beyond documentation.

Furthermore, catching a C++ exception can hardly be used for anything beyond terminating the program. So the question is, what purpose is served by adding invariants? After all C++ does not offer any form of resumption.

Z++ notion of class includes invariants, as well as method-constraints.

Wormhole and the notion of Continuity as a mathematical ideal

2011-09-24T14:32:00.000-07:00

It is natural to assume no limit for counting numbers. That is, accepting the existence of a largest number is contrary to intuition because there might be a case where we need a larger number, for instance the budget deficit of our country. We know any case of physical reality that we consider, like sands on earth, number of planets that we are aware of and even the budget deficit at any moment is finite. However, mathematics must be adequate for all imaginable cases. Whenever we set a limit for counting one can imagine something larger. Therefore, the limit for counting must not be imaginable which is why we assume no limit, or equivalently that the largest counting number is infinite.

A system chosen to cover all imaginable cases of reality must include all such cases as a proper subset possibly by including some ideal cases. Clearly, an ideal concept such as infinity does not need to correspond to our intuition. Furthermore, Cantor shows that once we allow a notion within mathematics that does not correspond to our intuition it is possible to derive unexpected results. Cantor demonstrates the existence of an infinite sequence of infinities each of a higher order from all previous ones.

Galileo observed that there are as many multiples of 5 as the counting numbers. The sameness of a proper subset to the entire set was so startling that Galileo never spoke of it and merely left it as a note. Vaguely speaking mathematics needs to be consistent so we can depend on results derived within it. When we include a notion that does not correspond to our intuition within this system, we should expect to see results that may not correspond to our intuition as well. A historical case is the interpretation of Euclid’s Fifth Postulate by Lobachevsky.

Superficially, there are two distinct cases of arriving at counterintuitive or paradoxical results. In order to solve problems of an aspect of reality we map a model to the reality under consideration. In doing so, we must approximate the reality by making certain assumptions, knowingly or not. Usually we refer to this process as an abstraction. For instance, Newtonian mechanics is a reasonable approximation for speeds negligible relative to the speed of light. The use of relativity in this context does not produce any measurable gain. On the other hand, relativity is a better model at speeds that are significant as compared to the speed of light. In this case getting unacceptable results through the use of Newtonian mechanics is a consequence of the inadequacy of the model mapped to the reality under consideration.

When an unacceptable result comes directly from inside of mathematics we refer to it as a paradox. Note that unacceptable here means that the result is mathematically sound but defies reality. In other words, we are not dealing with an unacceptable derivable result coming from our inaccurate approximation of reality with a mathematical model. What we are forgetting, though, is the ideal assumptions such as infinity that we have made part of our mathematics. For instance, the source of Zeno’s paradox is the ideal assumption that a line segment can be divided into two halves indefinitely. On the other hand, the assumption that any line segment has a midpoint is as necessary as the notion of infinity with regard to counting numbers.

Let us take a look at Zeno’s paradox by asking Arash the Persian Archer to hit a target at 100 meters, a child’s play for Arash. Zeno tells us that Arash's arrow will never reach its target, though he refuses to face Arash as a target. Zeno argues that before the arrow reaches its target it must pass through the midpoint at 50 meters from Arash. Next, the arrow must pass through another midpoint, which is at 75 meters from Arash. Continuing the argument he correctly tells us that the arrow must go through infinitely many points, which requires an infinite amount of time before reaching the 100-meter point. Thus the arrow will remain flying forever without ever reaching its target.

In a lot of cases, such as the imaginary numbers we have been able to map unintuitive notions to the reality around us and to find ways for using them to solve actual problems of physical reality. However, with regard to Zeno’s paradox the suggested mathematical answer is no more than simply accepting the paradox as the truth. The notion of infinite sum, or an infinite sequence of partial sums, appeared in the work of Archimedes when calculating the area under a curve. Pascal takes the other end and defines a tangent line as the limit of a sequence of secants, as opposed to a line touching a curve at a single point. Leibniz and Newton establish the connection between the two ends via the Fundamental Theorem of Calculus. There is no doubt in how important calculus has been. However, what matters for our discussion is the work of Archimedes.

Archimedes’ approach of an infinite sum converging to a finite number uses the ideal notions of convergence towards a limit point, which is equivalent to accepting Zeno’s paradox as a none-paradox.

A related theorem using the axiom of choice in addition to the notion of continuity is the Banach-Tarski paradox, which shows that a pea can be chopped to pieces and reassembled into a basketball. Here again we have a valid mathematical result that directly defies our intuition.

In general, intuition is not an accurate means for describing reality. It was not long ago when we thought earth is flat simply because we could not walk on ceilings. But it is hard to deny the fact that Arash’s arrow does reach its target. Perhaps in this case our intuition took a wrong turn at a different point. Our intuition leads us to believe that motion is continuous. Is this really true, or is it analogous to believing that earth is flat?

We all have seen the bottom of a swimming pool appearing shallower than the actual depth of the pool. This phenomenon is described as refraction of light. It is believed that when light passes from one medium to another its speed changes causing a change in direction. But does the actual speed of light change, or only its measurable speed changes?

Let us change our intuition to believing that a photon cannot move less than a small displacement, a quantum leap, the size of which depends on the medium. For instance the quantum leap (QL) for air is longer than QL for water. With this intuition we can say that the speed of light remains the same, only the length of leaps are different. Therefore, what we observe is that the measurable speed of light has changed. In other words, a photon is making the same number of leaps in both mediums but the length of leaps are different making it appear as if the photon is moving at a different speed.

The notion of QL resolves Zeno’s paradox by disallowing the bisecting of the motion of a particle, or any object for that matter, indefinitely. Thus, the arrow only passes through a finite number of points rather than the mathematical ideal of infinitely many midpoints.

Note that we are not postulating that there is a smallest QL. We are only saying that any motion comprises of displacements, or quantum leaps the lengths of which depend on the medium. Thus, the notion of continuity is still preserved. The QL near a black hole is very small and approaches zero when light can no longer escape.

The notion of QL provides a more reasonable view for a wormhole. It is argued that at Big Bang the universe expanded instantaneously to a certain point. The speed of light was established within the extent of the universe after its creation, or being. Imagine an area in the vastness of existence where there are no particles, a total void. There are no forces of any kind in a total void because any form of force field requires the presence of particles of some kind for its extent. What will happen when a photon enters one end of void? I believe the QL in a void is the length of the void. That is, the photon will reach the other end of the void in a single Quantum Leap.

At Big Bang our universe expanded instantaneously in all directions, not necessarily as a perfect sphere. Once particles reached a none-void medium their QL became finite and their motion slowed down. In turn, the boundary of our universe established the QL for particles within. Perhaps the center of the Big Bang contains less mass in an identifiable manner as compared to the density of the rest of the universe, even though indefinite number of explosions since then have sent back a lot of mass to this point.

It is hard to guess whether we need equipments at two ends of a wormhole, or one can create a wormhole from a point on earth to anywhere in the universe. In the latter case we can use the wormhole at least as a real-time telescope. I can only hope that no one will be tempted to observe the core of the sun in real time, well at least not from earth.

Requirements for unrestricted distributed computing

2011-06-16T19:56:00.000-07:00

We begin by considering some of the major techniques in use for developing distributed applications, observing that the main tool is communication via sending messages. We then look at other forms of communication that extend our ability to tackle more problems in the space of distributed computing, and simplify our current methods. Finally, we introduce a medium that alleviates the prevailing restrictions in distributed computing.

A distributed algorithm, centralized, hierarchical etc. deals with states of its objects residing on different nodes. This only requires a communication mechanism between parts of the algorithm executing on various nodes. Specifically, it does not impose any conditions of distributivity on the operating systems in control of those nodes.

A distributed algorithm is a special case of distributed computing. The client-server model provides a general medium for solving many problems of distributed nature. For instance, Remote Procedure Call (RPC) uses the client-server model, as does remote linkage where the library code is downloaded to the client node and executed by the client instead of the server. Nonetheless, the client-server model does not impose conditions of distributivity on the operating systems controlling the client or the server nodes.

As things are, linguistic abstractions for communication can be defined and in most cases implemented without dependence to system peculiarities. This allows defining universal linguistic abstractions for the forms of distributed computing that solely rely on communication mechanisms. In other words, the notions of distributed computing in these categories are not constrained by limitations of available operating systems.

Modes of Communication

For clarity, we will refer to the operating system in control of a node as the host operating system (HOS).

At application level three main forms of communication, and their combinations, are used for purposes of solving problems of distributed nature. The protocol mechanism is used in applications such as email. Another mechanism is to request the execution of a function on a remote node, as in RPC or Remote Method Invocation (RMI). A distributed algorithm generally uses blocking with timeout for sending or receiving the awaited data, at which time synchronization takes place.

On the other hand, on a single node, many problems are tackled via signaling. In particular, Graphical User Interface (GUI) depends heavily on the notion of event.

Communication via signaling for solving problems of distributed nature requires assistance from the HOS of the nodes engaged in the operation. The HOS creates and owns the processes, therefore only HOS can inform a process of the arrival of a signal. In particular if a signal generated on one node is to be delivered to a process on another node, the HOS of the two nodes must support a compatible system of signaling.

Distributed Operating System

The notion of a distributed operating system (DOS) can be defined in terms of its processes. Communication mechanism is a necessary but insufficient condition for a DOS. An HOS controlling two or more nodes is distributed only if its processes can get their next time-slice on a different node. In other words, a process can enter the waiting queue on a node, and gain its time-slice on a different node. This is equivalent to the ability of processes to move from one node to another with strong mobility. Thus, an operating system is distributed if and only if it supports strong mobility of its processes.

The notion of strong mobility came about in research on Autonomous Agents. Our observation implies that the materialization of the notion of autonomous agent is only feasible as a process of a distributed operating system.

The notion of strong mobility bears some vagueness, though. Vaguely speaking, only the soul of a process can be transported not its body. For instance, a process may have opened files, interacting with a remote server and so on. Resources of this kind attached to a process cannot be transported. On the other hand, all objects, threads, stack of nested calls, nested scopes of loops/selections, raised exceptions and registration of (distributed) signals as well as the point of control are transportable. Thus, prior to transportation all files must be closed, and reopened at destination as needed. After all, the same files may or may not exist at destination. Communication with another server, for instance a database server will have to be re-established at destination, as well. However, these are simple matters that one can easily remember prior to being reminded via raised exceptions.

Separation of Responsibilities

An HOS is responsible for managing resources and allocating them for use by its processes. Data transmission is one such resource. HOS packages data and sends it to its destination. The receiving node unpacks the data and delivers it to the target process. The interpretation of the contents of packages being transmitted is up to the communicating processes. Think of it like the phone system that establishes a connection so two people can talk.

At end of section on “Modes of Communication” we introduced the notion of distributed signals (signals sent from one node to another). Given that an HOS should not be aware of the contents of data packages, the transmission and arrival of distributed signals requires a runtime library specific to the language used, for writing such software. Since each HOS has its own way of handling signals, these libraries will be expensive to maintain. Furthermore, libraries can do nothing about an HOS that does not support signaling. This follows from our observation that, HOS creates and owns the processes and therefore only HOS can inform a process of the arrival of a signal.

Now, with regard to agents traveling among nodes we run into an impasse. Assume that the sending HOS packages the state and the code of an agent and transmits it to another node. The runtime library on the receiving node must use the contents of the package to create a process and set its state, and finally tell the HOS where to set its instruction pointer when it allows this new process to execute. However, apart from a system call to create a process, we shall need a fairly complex set of system calls to set the state of a new process and its point of execution. Providing such a set of system calls violates the abstraction of the notion of process. Furthermore, an obvious requirement is that all HOS handle processes in a compatible manner if not identical, from a desktop to a PDA and everything else.

A rather obvious conclusion from the preceding observation is that an HOS cannot simply evolve into a Distributed Operating System (DOS). It may now appear that the materialization of the notion of DOS is not feasible. Well, it is not so.

First, we must distinguish between programming a device and developing an application for use on that device. An application is a user of system resources alone, having nothing to do in controlling or managing them. Therefore, an application must run as a different type of process than system processes, which are responsible for allocating and managing system resources. This separation has been known for a long time with regard to processes created by an HOS. Some processes run in supervisor mode and others in user mode. However, that is not the point I am making here about the separation of processes.

For clarity, we shall refer to a process created by an HOS as a system process or a real process. Below we define the notion of a virtual process.

Definition. A process not created by the HOS controlling a computing device will be called a virtual process. A virtual process may also be referred to as an application process.

The notion of a process, real or virtual has certain characteristics. For validity of the above definition a virtual process must possess such characteristics. A virtual process is the representation of an application in execution. A virtual process needs to be created, will have a state and will consist of one or more threads. Furthermore, the creator of virtual processes must manage them and facilitate Inter-Process Communications (IPC), signaling and other related notions. This observation leads to the realization that we need some kind of operating system for the creation and management of virtual processes.

A virtual process as the representation of an application also needs access to system resources managed by HOS. But, if a virtual process directly requests resources and holds them, it will be indistinguishable from a real process. We therefore observe that the operating system creating virtual processes should respond to the needs of its processes. Then, this operating system as a system application can interact with the HOS in gaining access to the resources needed for its virtual processes.

These observations lead us to the conclusion that instead of the impossible task of creating a distributed HOS we can create a distributed operating system (DOS) that runs like any other system process. The DOS will be responsible for creating and managing virtual processes, as well as handling distributed signals. Remember that for an operating system to be distributed its (virtual) processes must be able to travel while retaining their context.

Conditions for a feasible DOS

Our conclusion does not seem to solve our problem in that developing a distributed operating system to manage all user applications is not an easy task, if feasible at all. Thus, we have to choose between continuing to write distributed software using our restricted abstractions, or engaging in research towards building a viable DOS.

Suppose we choose to build a DOS. Unless a few general conditions are satisfied our DOS will have limited use. For instance, it should be small enough to run on a PDA or any small computing device that we may utilize say in home appliances. The latter is to facilitate the building of smart appliances capable of interacting with one another and perhaps our PDA or a home computer.

Perhaps the more important condition is that our DOS should be independent of any HOS except for requesting resources for its processes. Otherwise, porting and maintaining the DOS will be even more expensive than porting contemporary virtual machines. In other words, the DOS must be self-contained in creating and managing its processes, threads, signals etc, without making any calls to its HOS. In particular, a DOS application can be multi-threaded on an HOS that does not support threading.

The self-contained distributed operating system Z47 Virtual Processor came to its completion in 2008, after over two decades of intense research and development. Z47 satisfies the conditions of viability mentioned above.

Linguistic abstractions

A mechanical tool needs an operator. Thus, the mechanization of computation, in its most primitive form such as an abacus also needs an operator. In our days this has evolved into an operating system and a language. At a lower level, a computing device consists of a set of devices and their drivers under the control of an operating system. This arrangement makes it possible for user applications to interact with the operating system via a language.

Theory of computation is the skeleton of theory of automation. However, automation has its own flesh and organs. In particular, notions of distributed computing are not topics of study within theory of computation. A language like FORTRAN replaces an abacus expert but offers no linguistic abstractions towards distributed computing.

The strength of the language of mathematics in formalizing science is in its cumulative nature as a single language as opposed to a collection of languages. Linguistic abstractions of notions of computing should not be dispersed among languages. Applications built by gluing multiple languages are fragile and too expensive to maintain. On the other hand, the use of a single contemporary language requires the implementation of abstractions provided by other languages, resulting in expensive software with a large maintenance crew.

Views of software development

There are two distinct views of software development. Ultimately, programming a computing device must be completely separated from developing user applications. In the latter case linguistic abstractions should replace system calls, which are indispensable for system-oriented software, such as virtual machines. User applications, on the other hand have a meaning independent of the computing device on which they run, except for their user interface.

Applications for users of a computing device need the use of resources available on the device without having to manage those resources. In addition, distributed applications need more linguistic abstractions for signaling, in particular with data transfer, and the mobility of processes. The actual transportation of virtual processes, for instance, should be completely transparent to an application just as paging and virtual memory is to system processes to avoid obscure defects resulting from violations of abstractions.

A developer of user applications should be able to use the language like a poet. In writing her poetry the poet relies on the language capabilities to express herself. The clay tablet, or pencil and paper or a keyboard, are not the determining factors in the construction of the poetry. Analogously, a developer wishes to express his solution relying only on the language he is using, not the system on which he is constructing his solution.

The Z++ abstract language

The language Z++ is the matching pair for the Z47 distributed operating system. However, Z++ contains its own linguistic abstractions for distributed computing without exposing Z47 internals as C++ does to UNIX.

An application developer expresses a solution in Z++ the same way an author writes a book. The developer relies entirely on the linguistic abstractions relevant to his domain of the problem. Furthermore, the Z++ language coherently contains all successful abstractions of other languages since the beginning of programming. This eliminates the need for gluing multiple languages together for a complete solution. All aspects of a solution can be expressed in Z++ alone.

Conclusion

We have identified messaging as the only currently available means for distributed computing. The contents of a message could be elements of a communication protocol, programming data, remote function execution or executable code.

In our attempt to include signaling in solving problems of distributed nature we arrived at the notion of a virtual process and consequently a distributed operating system. The characteristics of a distributed operating system were listed and Z47 Virtual Processor was introduced as a viable representative.

The mechanization of automation rests on two elements, an operating system and a corresponding language. The Z++ abstract language was introduced as the language corresponding to Z47 distributed operating system. In particular we emphasized that Z++ is an evolutionary language by design, coherently containing all the successful mechanisms and notions in all languages. Furthermore, Z++ is monotonically extensible in a manner similar to the language of mathematics.

Formalization of Exception Mechanism

2011-01-30T23:20:00.000-08:00

The notion of exception has been around for a long time. The purpose of this note is to unify various models and scattered terminology into a coherent model complemented by adding new mechanisms to what is already known.

Formalization should be based on feasibility research in the context of a programming language. Furthermore, in order to demonstrate that the model is sound, the algorithms should be verified. However, the discussion of verification is not within the scope of this note. The language selected for research is Z++, which supports the entire model described here.

We begin with the notion of exception layers and handlers. Then, we discuss two forms of resumption, and follow that with handling of exceptions occurring in threads and child processes. Finally, we discuss a mechanism for ensuring that all raised exceptions will have a handler, during compile time.

Layers of exception

A model for exception mechanism starts with the notion of circles or layers. Generally, in each layer certain kinds of exceptions are dealt with. Once an exception reaches the final layer, usually the operating system, without being handled the program crashes. In particular an exception trapped in the layer of the operating system, such as invalid pointer is terminal.

Below is a linguistic representation of the notion of layer for exception mechanism. The scope of layer is between the terms layer and handler. In handler section for each exception that could be handled in this layer we have a case followed by the code for handling its caught exception.

layer

// body of layer

handler
case exception_1:
// handler

// more cases

else
// catchall handler
endlayer;

The else leg acts as a catchall and is optional. The else leg should be used in the final stages prior to handing over an un-handled exception to the operating system. Instead, it is better to have a handler case for each exception of interest for the layer at hand.

Each handler begins a new scope so objects can be declared and further exception layers may be opened, just as is the case with the layer section. Finally, the term endlayer closes the entire layer statement.

The specification exception-type between brackets helps reader know the category of exceptions dealt with in the layer. It also allows the compiler trap handler cases that do not belong to the specified category.

Raising an exception

The Z++ statement for raising an exception is simply raise(exception).

Resumption

Resumption from exception is an indispensable mechanism. Consider a scenario in which deleting an entity from a database fails because the entity was not in the database. Why should we skip all the statements following the failure? The appropriate approach is to log the failure in a file and/or inform the user in a handler, then go back to the statement following the delete statement and continue with the rest of the work.

Unlike repetition that we discuss next the semantics of resumption are quite simple. The execution simply returns to the statement following the one that caused the exception.

The term for resumption in Z++ is resume, which can only appear in a handler. Upon resumption all objects created in the layer section (before the statement that caused the exception) will be available with states prior to the occurrence of exception. However, if an object was passed by reference to the statement that caused the exception, its state could be different.

Repetition

Repetition is a form of resumption that puts control back to the start of the statement that caused the exception. This mechanism allows fixing the problem that caused the exception and trying the operation again.

For function calls, loops and switch statement, as well as all simple statements such as assignments, repeat will return control to the start of the statement. However, in an if-else statement the control returns to the start of the leg in which the exception occurred. The reason for the latter is that, we really need to return to where we got in trouble while testing the condition might put us in a different leg.

One can argue that we should do the same for a switch statement as we do for if-else statement. Nonetheless, it seams reasonable to provide two different mechanisms. One that allows selecting a different leg, as is the case with switch statement, and one that puts us back in the leg that caused the exception. Otherwise we need to make up two terms, one to go to start of a selection statement and another to return to the leg that caused the exception. Such terminology will be of no use with regard to iterations.

The term for repetition in Z++ is repeat, which can only appear in a handler. Upon repetition all objects created in the layer section (before the statement that caused the exception) will be available with states prior to the occurrence of exception. However, if an object was passed by reference to the statement that caused the exception, its state could be different.

Threads

Exceptions can occur in child threads created in a layer statement. A child thread in Z++ passes its un-handled exceptions on to its parent and terminates. Now, if we have already executed statements following the statement that created a global thread, the execution of resumption or repetition will result in incorrect programs.

In order to use resumption and repetition correctly, you will need to call a plain function, which creates a global thread. The call to the function will block until all child threads terminate.

Calls to methods of a task thread block. Thus, the use of threads of task type is safer than global threads for purposes of using resumption and repetition.

Components

A Z++ component starts as a child process, locally or remotely. Un-handled exceptions occurring in a component are passed on to the parent process, but the component process continues to execute in good state waiting for future invocations. Since calls to entry points of a component block, resumption and repetition behave nicely. This is true even when a component is loaded as a remote child process.

However, a component could create its own threads, which will continue to execute even when the parent has not called one of its entry points. Exceptions can occur in one of the child threads of the component. Such exceptions must be dealt with within the child component. In particular, resumption from such an exception may result in an incorrect program unless it is properly designed to deal with the situation.

An un-handled exception passed from a component to its parent can be handled in different ways. The parent may choose to handle and ignore the exception, or to terminate the component, or do something else, such as loading a different component to do the job, or load the same component from another location.

Exception categories

Having exception categories helps in designing programs, as well as in understanding a written program. For instance, a set of exceptions may be related to database operations, another set with correct state of a particular class (for invariants and constraints), and yet another set with loading and interacting with a component. This can be accomplished by naming the exceptions appropriately.

However, the type specification for the exception layer requires that all exceptions in a category to be related. In Z++ this is accomplished via type of exception. In other languages it can be done through inheritance or other mechanisms supported by that language.

One category of exceptions that helps in writing more robust programs is the system exceptions. The system exceptions include division-by-zero, null-pointer and index out of bounds (arrays etc). The point is that, their existence helps engineers deal with such exceptions. Otherwise one has to rely on engineers remembering all such cases.

In Z++ system exceptions are raised by the run-time libraries allowing programs to deal with such cases prior to reaching the layer of the operating system.

Beyond system exceptions, all other categories of exceptions are user-defined. This simply means that engineers must be able to introduce their own categories of exceptions.

Compiler involvement in catching exceptions

It is possible to help the compiler inform us of exceptions that might be raised, and for which we have not defined a handler.

Exceptions occur inside the bodies of functions and methods. The list of exceptions expected to be raised in the body of a function is specified via a throws list after the header of a function.

The compiler uses the list in the throws specification in nested function calls. Starting with the innermost function the compiler verifies that its throws list is covered with the cases of the layer statements in the body of that function. If some exceptions are not covered, the compiler maintains that and checks the list against the layer statements in the next outer call. This continues until the compiler reaches the initial point of call. Now the function in which the initial call started must have a handler for the remaining exceptions that were not handled up to this point, otherwise the compiler will report an error.

This design requires a little more writing for the specification of throws list. For instance, the function calling another function with a throws specification must include the same specification to avoid compiler errors. However, the extra writing helps the understanding of the code and allows the compiler to inform us of our misses in handling raised exceptions.

On Islam of Iran

2011-01-10T19:54:00.000-08:00

It is not surprising to find an exiled person interested in understanding what exactly is the nature of Islam introduced by Khomeini. However, in my argument I will attempt to make logical derivations based on the fundamental principles on which Islam rests. So, I begin by listing the principles that I accept as axioms.

Prophet spoke the words of God.
Prophet announced that he is the last.
Prophet declared it is fine to lie for Islam.

The first axiom substantiates the two axioms following it. We make some conclusions from each of the two axioms, starting with the first, namely that the Prophet was the last human to speak with God, directly or indirectly through an Angle.

The main branch off of Islam is Shia. Now, if Shia did not add to the religion there would be no argument. However, Shia adds a whole new principle known as Immamat. The dominant version of Shia in Iran is the one that believes in Twelve Immams.

The problem here is that the principle of Immamat is an addition to the religion, not even implied by the Prophet. Therefore, to make such an addition a human must be able to speak with God. However, the Prophet has explicitly refuted such a possibility. The simple conclusion is that Shia is a religiously illegal deviation from the Islam proclaimed by the Prophet. Interestingly though, Shia in Iran is attempting to convert Sunnah! Oh well?

Now about lying for Islam. By now everyone knows that Khomeini completely changed his words about a year after his arrival in Iran. When asked about the change of heart he simply mentioned that he lied for Islam (as encouraged by God).

Let me first make a mild conclusion, and then a dramatic one. Suppose Bernard Madoff took all the money he received via deceptions, and added some of his own to build a mosque in New York. In accordance to Prophet, and clear interpretation by Khomeini, Madoff will receive a free pass to paradise probably with 40 virgins awaiting him.

Now let’s derive a more dramatic conclusion. It is easy to conclude from the principles that God is liar. Simply put, the Prophet spoke the words of God who permits lying for his religion. One who permits lying could also lie.

Well now we have a problem. When did God tell the truth and when did he lie? We know the Prophet said one thing in Mecca and another in Medina, just like Khomeini did. So, which version is the true Islam? Is it the peaceful poetry spoken in Mecca, or is it the bloody version of Medina?

This ends the argument. The rest is personal opinion based on observations.

Basically, God can lie and I must follow his words without questioning. I must do as he says either in Mecca or in Medina, precisely as instructed by some religious authority like Khomeini.

If I choose to convert from Islam, I must be beheaded immediately so God Almighty can begin torturing me in his hell without delay. So, the God of Islam can lie to turn me into a Muslim. Once converted, I have surrendered my soul, which sounds more like a contract with Satan.

This Almighty God cannot do anything to me until I am beheaded. A simple corollary to this is that God cannot interact with me in this world. Well then how was he able to speak with the Prophet at first place? After all he could have blinded me just before I posted this note! How is it that the mercenaries of the Mullahs in Iran have to discover this note before I can be executed in Evin (a jail in Iran)?

I am having trouble accepting the teachings of a Lying Supreme Being. I wish to return to Zoroastrian teachings in my ancient land of feasts, music, dances, joy and love. I am tired of all the killings for a Lying God.

A father that teaches his children to lie for the protection of the family must do the same himself. Furthermore, the protection of family could legitimately mean protecting friends of the family and destroying those who may not wish to build a friendship with the family. Otherwise put, once permitted there will be no limit to the interpretations of situations where one can lie.

Differentiating between exception mechanism and signaling

2010-12-12T12:12:00.000-08:00

An operating system in its role as a supervisor oversees the operations of processes. For a variety of reasons, including an attempt by a process to reach out to addresses outside of its scope, the OS must terminate the offending process. In a number of other situations, the OS cannot allow the process to proceed unless it corrects its state. The OS informs a process of its illegal behavior by raising an exception in the context of the process.

An application can also encounter situations that may need raising an exception. Generally in this scenario the purpose is to remedy the situation so the execution of the program can proceed. For instance, in Z++ class invariants or constraints of a method at time of its invocation may be violated. In Z++ these violations can trigger a private method to rectify the problem. But sometimes it may be necessary for the user of the object to correct the problem. Hence in Z++ violations of invariants and constraints can also raise exceptions for reporting the problem to the next level.

We observe that a process can receive exception from two sources only: the OS and the process itself. If the only response to an exception were termination, there would be no point in talking about exceptions in anyway other than crashing. In case of an exception UNIX intercepts the process and directs it to a handler that the process has specified for the exception. After handling the exception, the process is allowed to continue its execution from where it was intercepted. However, C++ makes it impossible to use this mechanism for a number of reasons, among them the lack of resumption from exception.

When it is possible to remedy the situation the execution of a program should continue just as we do things in our daily lives. Simply crashing is not an intelligent solution for all scenarios. In particular, we expect to see more imbedded computers in the future. The manual override and resetting the computer may not always be a desirable solution.

Turning our attention to signaling, this mechanism is not intended for reporting unusual situations that require correction, or else the process will be terminated. Signaling is a form of asynchronous communication among threads and processes. Unlike exceptions, a process can receive signals from processes other than itself. The general pattern of signaling is that one thread or process generates a signal or an event. Another thread or process responds to the generated signal at a later time.

The generation of a signal should not intercept the recipient process. Instead, the recipient should be able to respond to the signal when it is able to do so. But this requires the type of abstractions that a programming language should provide. UNIX, as an operating system, uses signals for exceptions, terminating or stopping a process, as well as plain signaling as a means of communication.

In order to better see the difference between signaling and raising an exception we will briefly describe tell/hear distributed signaling in Z++ and illustrate the need for two forms of resumption from exception.

Z++ hear signals add the dimension of transfer of data from the generator of the signal to the handling thread or process in a manner similar to a function call. For that reason, the generation of a hear signal may be thought of as an asynchronous function call. In particular, hear signals travel among distributed nodes allowing us to also speak of asynchronous remote procedure call (RPC).

The generator of a hear signal tells its signal in the following general form.

Tell Recipient Signal List-of-Data

The recipient will eventually hear the signal in the following general form.

Hear Signal List-of-Data

The tell statement, as is the case with any signal, contacts the remote Z47 Processor, not the receiving process. The actual contact and communication protocol takes place between the local and the remote Signal Managers of Z47 Processors. Part of the protocol is to ask the remote Z47 whether the recipient process exists prior to sending the data. This is like verifying an address with the post office before dropping the mail.

Now suppose the remote Z47 replies negatively. Clearly, the local Z47 must inform the teller process that the recipient is not a process at the given address. At this point we are back to the Z++ source program that executed the tell statement. The proper course of action would be to change the address and try the tell statement again in search of a recipient.

One pattern that may come to mind is to make the tell statement to return a value for its success or failure. One can then use a loop and continue to check the returned value of the tell statement until a recipient is found.

However, the semantics of signaling is not the same as a function call. Traditionally, we do not generate a signal and then check its returned value. A more familiar approach would be to raise an exception when the remote Z47 replies negatively to a tell statement. This approach clearly separates the notion of signal from raising exception. In Z++ the failure of a tell statement causes an exception.

It should be clear that without resumption to re-execute the tell statement the abstraction of hear signaling is essentially useless. In UNIX, an interrupted process continues from where it left for handling a signal. However, in our scenario we really need to go back to the tell statement that caused the exception and try it again, rather than continue the execution from the statement following it. That is the reason for the two forms of resumption in Z++.

It may be worth pointing out that hear signaling is a generalization resulting from dropping the requirement of rendezvous. In Communicating Sequential Processes each process that reaches the rendezvous point will wait for the other until they synchronize and exchange data. But, a process generates a hear signal through a tell statement and moves on. Eventually, the recipient will hear the signal and receive the data. In this scenario neither process waits for the other. For that reason we refer to this form of communication as Communicating Concurrent Processes.

In conclusion we summarize our discussion as follows. Exceptions and Signals are not equivalent. An exception causes interruption to the normal execution of a process and may result in its termination. A process cannot receive exceptions from other processes. On the other hand, a process can receive signals from other processes, and may choose to respond to them when it is able to do so.

And what’s the point?

2010-11-29T16:20:00.000-08:00

This note is about C++ exceptions.

The scenario I mention here is not unique. Actually it is one of the many other similar situations I have encountered in which C++ exception mechanism is of no use.

I begin with an Integrated Development Environment (IDE), written in C++. User loads an application in a language supported by the IDE. The IDE loads a dynamic library to execute user’s application. This is the general idea.

Suppose, during a debug session user code causes a segmentation fault on a UNIX platform. An obvious course of action is to inform the user that his program crashed, then return control to the IDE. User can then set break points and find the location of crash, and so on.

What happens of course is that the entire IDE crashes. C++ can only catch exceptions thrown in a program. However, it is not possible to define a C++ exception to match up with segmentation fault, because it is not possible to sense the fault prior to its happening.

Well, you try UNIX signal handling. This takes a while trying different approaches. For instance you attempt to throw an exception from inside the handler, you try to get a trace of the stack at the time of crash hoping that you can return to a reasonable point in your program, etc. Nothing works, of course.

Suddenly you find out that in C++ you can redefine the terminate() function. After a while you realize that the redefinition only allows you to change its message to something like, “Hi there, I am in terminate function!”. And now you are thinking, what is the whole point behind this design?

Basically, once a signal handler is invoked by UNIX operating system the C++ context is lost. There is nothing that can be done, neither in C++, nor even with the help of UNIX facilities. What is needed is a runtime library that could do the clean up by calling destructors on objects created in a try block, and bring control back to the catch block. But C++ can only do that for exceptions thrown in your program. The latter is the work of the compiler, not the runtime library.

The point to keep in mind is that C++ is merely a front-end parser to the C compiler. The runtime libraries are those of C language. Simply put, C++ is an extension of the C parser not to be confused with an extension of the C language. That means, any attempt for materializing a particular feature for C++ that cannot be supported by C runtime library will result in a lot of wasted time. After all, there is only so much that C++ parser can do in telling C what to do. In particular, we do not want to change the behavior of C in order to accommodate for another language.

Identifying a language for distributed computing

2010-10-30T12:18:00.000-07:00

In an ideal situation one can find a unit for measuring a particular characteristic. When this is not possible some criteria for determining the presence of the characteristic facilitates making a better decision. In this note I will attempt to discuss some guidelines for determining whether a programming language supports distributed computing.

The intuitive notion of distributed computing can be viewed as the ability of programs executing on different nodes to communicate in a cooperative manner for accomplishing their common tasks. This view reflects a major aspect of distributed computing but not its nature. Nonetheless, with this naïve description we see that the support of a language for distributed computing can be studied in terms of its abstractions for communication.

Processes running on a single node use a number of operating system facilities in their communication, including shared memory, message queues and files. These facilities are essential for writing system programs. However, a system programming language such as C cannot anticipate all possible facilities and include linguistic abstraction for them as part of the language. Thus, an engineer engaged in system programming must be aware of such system facilities, and apart from the actual solution or algorithm, also write the necessary code for establishing communication among the processes or threads involved in the solution.

Let us digress to see why C cannot include communication facilities of an operating system as linguistic abstractions. When we start with C to craft an operating system we are dealing with the instruction set of a processor. We are going to create a system that will include a number of facilities, which are not known to the designer of C language. Besides, since we have not yet created those facilities it makes no sense for the language to include them.

Now, C++ is not usable until the core of the operating system is fleshed out. The notion of class is of no value whatsoever at the level of core. However, after the operating system becomes operational C++ would be a better choice for creating system programs such as graphic compilers and debuggers. Since C++ is an extension of C one can also use C system libraries for taking advantage of operating system facilities.

However, linguistic facilities of C++ are meager and the language is too crude for building modern applications even for execution on a single system. Since C++ can only be used after the completion of the operating system, the designer is in complete control of inclusion of linguistic facilities beyond the notion of class and a few ancillary ideas. It makes one wonder whether C++ has reached its end of evolution and C++ engineers will be required to be aware of the system facilities like C engineers normally do.

Returning to our discussion, a solution that NATURALLY spans more than one node is necessarily NOT a system program. The nodes involved do not have to be identical, and even if they are, none of the nodes is in complete control of the entire program. For purposes of this article I refer to such programs as (distributed) applications in contrast to system programs. The guidelines we are going to discuss are for a language for developing distributed applications. Thus C and C++ retain their value for system programming.

Exchanging files is a major form of communication among (programs running on different) nodes. Plain text files with predetermined layout work quite well. There is no value in standardizing this method of communication except for a few cases such as Internet documents and Email servers. File exchange in any form requires that an engineer write code for communication in addition to the actual solution. Nonetheless, there are times that transferring a large amount of data is worth the overhead of writing specialized code. For this reason we will not gripe about this form of communication for distributed computing.

The focus of our attention is at forms of communication that directly exchange program objects among nodes. One approach is to extend existing communication forms on a single node to distributed computing. This is a desirable approach for solving a great deal of problems in the space of distributed computing. However, the abstractions associated with communication on a single system lack the concepts needed for solving more challenging distributed problems. Stated differently, extending facilities such as plain function calls to cross the boundaries of nodes, or using file transfer for data communication, as well as exchange of strings as in client-server model are not sufficient for tackling all problems of distributed computing.

In order to convey this issue in context let us consider an example. Some ancient edifices are still a challenge to erect in modern days. Now, if we were limited to the technology of those days, instead of cities filled with huge buildings we would see a few buildings erected in the entire world every generation or two. In terms of software this is even worse because code cannot be checked the same way as one checks walls and pipes. Essentially, without proper linguistic abstractions our programs will continue to be written the way ancient buildings were constructed, but with undetectable programming defects. Hence, it is not merely so much that something could be done but rather at what cost and with what degree of reliability.

One form of desirable abstraction can be illustrated with a team of people engaged in completing a task. All teammates have specific tasks and each one can ask another teammate for certain adjustments in their actions while continuously operating. In Z++ we refer to this model as Communicating Concurrent Processes (CCS). The importance of having a linguistic abstraction is in the fact that an engineer can incorporate the notion in his thinking while trying to solve his problem. Without such abstraction the engineer would instead have to spend time for designing and implementing a crude mechanism with the kind of abstractions available to him.

In CCS model any process can send a request to any other process in the team, whether the processes are executing on the same node or not. The sender (teller) of request carries on with its operation until it hears back from the recipient (hearer). At that time, the teller sends the data, if any, to the hearer and continues with its operation. However, the entire complexity is hidden behind an intuitive linguistic abstraction thereby relieving the engineer from having to implement a fairly complex notion that he needs as a tool to solve his problem. The complexity of the data being transferred is of no concern to the engineer. It simply resembles a sequential function call within the same application.

A second guideline is in terms of components. Sometimes we need to ask another person at a different location to get up and do certain things for a while. In terms of programming, in this model the remote process is not executing until invoked. The remote process comes up and performs some duties while communicating with its invoker, and terminates. Remote (or local) invocation of Z++ components provides a simple and intuitive solution for this model.

There is a third scenario. Sometimes the Secretary of the State Hillary Clinton needs to travel to different countries and talk to her peers because she cannot solve her problems in her office. As she travels from one country to another she retains the results of her discussions and uses them to plan for her next visit. In term of programming she is an Autonomous Agent. Indeed, Z++ agents travel as live processes from node to node retaining their complete state.

While Z++ equips an engineer with intuitive mechanisms for all three models described above, no other language provides a linguistic abstraction for any of the three notions. Using a language like C++ for distributed computing is tantamount to using ancient tools for building large edifices. It somehow works, but at what cost and how reliably.

The first question that comes to mind in choosing Z++ for crafting distributed applications is how it compares to C++ for other features. Actually, Z++ is a superset of C++ with the ability to link with C++ dynamic libraries on Windows and Linux. Perhaps a few words about the term superset are in order.

Z++ includes the entire C++ language along with enhancements and extensions of C++ features. Basically, an engineer can start out using Z++ like C++. However, C++ is a minor extension of C for inclusion of Simula classes. At the time that C++ was still called C with classes, ADA and Eiffel already had a number of useful linguistic abstractions that C++ should have incorporated. Only templates were later introduced in C++ in the form of linguistic abstractions as a replacement for C header files. The C++ exception mechanism is expensive and hardly useful.

In the following discussion, one has to keep in mind that there is a need for a system programming language like C++. The argument is that it could and should have been designed much better.

When introducing a new language the designer should incorporate all established mechanisms of software engineering. In other words, a new language must accumulate the available knowledge. The use of C structures for jump tables was known at the time of design of C as a language. Using the mechanism for class virtual tables is a good idea, but not an end. Since the widespread use of C++ for almost two decades only namespaces were added as a not-well-thought throw-in. The namespace mechanism could have been designed at least up to the level of the state-of-the-art.

That C++ is a front-end parser to C does not mean C++ can only parse classes and leave everything else as is. It could elevate the treatment of enumeration to the level of ADA and add Eiffel invariants among many other well-understood useful abstractions of modern software engineering.

This digression may explain why C++ constitutes only about 60 per cent of Z++. As a system programming language C++ cannot be elevated to the level of Z++. However, the gap between the two languages could be much less than its current state.

Returning to our discussion, a manufacturing process evolves over time by replacing awkward aspects of the process with more efficient and reliable procedures. In terms of programming this evolution takes the form of building libraries for well-understood routines. However, improved procedures of a manufacturing process do not increase the variety of its productions. Analogously, libraries only improve the quality of production and its reliability. The space of solutions extends solely by creating new means for solving challenging, unfeasible or even unsolvable problems.

Let us cite one relevant example with regard to library extensions. Consider the fact that even though C++ translates its input for C parser, yet it is the C++ parser that disallows the use of private methods in certain contexts, not the C compiler. Thus, libraries that automate XML translations may somewhat help with data transfer. However, the parser has no way of detecting errors associated with the intended abstractions.

In conclusion, we have identified three abstractions for facilitating and enabling the design and implementation of demanding distributed applications. Each of the notions of CCS, remote invocation and autonomous agents tackle a certain category of problems. A modern application more than likely will need to utilize all three abstractions. The language Z++ includes intuitive linguistic constructs for all three notions.

The origin of the number 12

2010-08-07T16:30:00.000-07:00

It seems that the origin of the number 7 for the seven days of a week is related to the shapes of the moon as invisible, full moon and the half moons. However, prior to that the moon must have gotten the attention of our ancestors.

It is hard to argue against the fact that at the dawn of our species women took care of the children. They had to learn to save food for winter, for instance. The arrival of seasons and their duration is not the same on all parts of our planet, nor it is necessarily precise enough at any one location. On the other hand, the cycles of the moon are quite precise.

Consider a woman that has her period at about the same time each month. She will see the moon reaching a particular shape every time she starts her period. Eventually she will also notice the relationship between the number of her periods and the seasons.

The mother is the first teacher. Since the boys do not have periods, a mother must have taught her children about the seasons by counting the cycles of the moon. It so happens that there are roughly twelve lunar months in each year.

While girls might have paid attention to counting their periods relative to the lunar cycles for protecting their children, boys might have paid more attention to the stars.

Anyway, the interesting question is whether the moon had to do anything with the frequency of periods of our first mothers, or this is just another lucky coincidence.

Axioms of Existence without Creator

2010-07-12T21:34:00.000-07:00

The notion of creator at the level of existence itself is equivalent to accepting the existence as the starting point. However, we must also accept certain properties for the existence in order to make up for actions that a creator would have caused.

We begin with a few simple axioms that avoid contradictions. After presenting axioms we proceed with the outcome of imagination resulting from these axioms. Ordinarily, one should make scientific derivations that may help us make predictions. However, at this stage I would be happy with a philosophical view that helps me avoid superstition.

Certainly, there will be better views as we move forward. The question is whether we will be there in that future. Religious superstitions and strangled democracies are effective tools in helping a tiny fraction of us exploit everyone else. This tiny fraction is served by, much larger groups at various levels. Some make the laws, others enforce the cruel laws and yet others spy on our intellectuals or eliminate them.

Who will win and at what cost is unknown. It is therefore worth improving our understanding of whatever it is that we are living in. Perhaps some of us and in a faraway galaxy will achieve the balance of happiness in a cooperative social life without giving up our privacy and dignity as an individual.

The grand solution to understanding the laws of existence will not come from theories and mathematical models for the laws governing the stars. We need a Copernicus to formulate our simple daily observations of Tycho.Brahe before a Newton can write the next Principia Mathematica of the laws of existence.

For now scientist will amuse themselves with fictions in search of truth. Consider the speed of light being constant relative to an observer. Suppose the planet we are leaving, at speed near the speed of light, is transmitting our favorite show, which we are watching on a TV on our spaceship. In order not to see the show in slow motion our ship must slow down in passage of time. This makes scientists believe that we might be able to reach far away planets by traveling near the speed of light.

The other way round is more interesting. Suppose, at the same time the planet we are approaching is also transmitting another one of our favorite shows. We switch our TV channel to watch the show from the planet we are approaching. Now, in order not to see the show in fast-forward our ship must speed up in passage of time. So, at the same time we are passing the time very slowly, and very fast. Which one is the one that is actually happening to us?

Axiom 1. There is existence.

This is simply equivalent to saying I think therefore I exist. Here, we are postulating the being of existence.

Axiom 2. Existence is all there is.

In other words, existence is unbounded. There is no beyond to existence. It also means there are no gaps in existence.

Axiom 3. Existence is simple.

The phrase Fabric Of Existence (FOE) is unfortunate due to lack of better terminology. The axiom means that the FOE is not made up of anything. Think of it as the soul of god.

Now we present a controversial axiom.

Axiom 4. Existence distorts.

The controversial points are the lack of cause for distortions, and whether distortions are permanent. As for the permanence one can argue that the distortions eventually fade away. With regard to principles such as causality I believe there is no difference between those principles and the view of flat world by our ancestors.

The assumption that an entity outside of the existence causes the distortions violates the second axiom resulting in rather meaningless views. Furthermore, we postulate our principles based on our observations within our universe, and its physical laws. Things can be different prior to the birth of a universe.

We can imagine two forms of distortions in FOE, but there may be other possibilities. A contraction is an Inward Compaction (IC) of FOE, while an expansion is an Outward Dilation (OD) of FOE.

We now proceed with philosophical imaginative views resulting from these axioms.

Distortions range from infinitesimal to infinitely large. However, a distortion does not have a physical size. For instance, consider an IC, the kind of distortion that we shall associate with gravity. Depending on its intensity, an IC will have a clear range within which it can attract other IC. The mass and physical size of an IC is this range.

Otherwise put, a distortion is a mathematical point without physical dimensions. What we measure as mass or size of a distortion is the range of its intensity. We will use the term size when referring to distortions, however.

Distortions in their smallest sizes are referred to as energy. We refer to an IC kind of energy as Positive, and to an OD kind as Negative energy.

A sufficiently large IC is called a black hole. As we shall discuss, OD distortions remain small. The following postulate establishes the types of interactions among distortions.

Distortion Postulate. Two IC absorb one another. Two OD repel one another. An IC and an OD attract one another.

Note that two IC absorb one another. I believe existence only produces infinitesimal distortions. This is just an opinion, but I cannot imagine existence suddenly producing a black hole the size of an entire universe.

Tiny IC distortions could be produced close enough to one another so they attract each other. Collisions that result in explosions may follow certain laws such as relative size of the IC and their speed and angle of collision. I believe in most cases they absorb one another and combine into a larger IC.

As an IC grows bigger than its surrounding IC, it continues to absorb them and grow. Note that the extent of the gravitational effects of an IC distortion may be very large but the actual distortion itself need not have a physical size.

Whether we assign a size to an IC distortion or not, I believe that all IC absorbed by a larger IC lose information. For instance, if a black hole absorbs an entire galaxy, there will be no memory left in the existence to recreate any part of that galaxy except for the energy that it sent out during the time of its existence prior to its absorption. We see celestial objects that have ceased to exist for billions of years.

Since the OD distortions do not combine they cannot grow. A collision of an OD and an IC probably cancels out one of them leaving behind the leftover of the larger one in any number of pieces. At any rate, I believe that larger OD do exist in the form of anti-matter.

A distortion of either kind may come with different properties. Some IC may have positive electric charge, some negative charge and others may be neutral. I am not sure if this happens at time of their creation, or it is a property relative to the physical laws of a given universe.

Matter seems to be a large IC as compared to what we consider to be energy. The nucleus is probably just a single IC distortion with many smaller IC, the electrons, rotating around them. The rotational behavior of electrons must be similar to those of black holes rather than moons and planets. This is because I think black holes and nucleus are identical distortions except for their sizes.

I believe we should start with a simple theory at the bottom and attempt to explain ordinary phenomena like refraction, with an understanding of top-level established theories. As we go we should pay attention to avoiding contradictions because existence is not controversial or paradoxical. I hope this note helps as an example of such an approach.

I close this note with an imaginary view. The positive kind of energy, the IC kind, is probably mostly of the neutral kind. Light seems to be of this kind. However, magnetic fields seem to be of the kind with negative electric charge, same as electrons. In other words, all energy is not of the same one kind. So the question now is what about the energy with positive kind of electric charge? Is there, yet another kind of force field that we have overlooked so far?

Z++ and Software Architecture

2010-05-29T23:23:00.000-07:00

Introduction

The scope of this note is the architecture of large (enterprise) distributed applications. Without proper familiarity with prerequisites the contents may sound philosophical or impractically theoretical. A reasonable degree of maturity in architecting large applications is expected.

We recapitulate a few points discussed in the references listed below for language prerequisite.

A component consists of a set of classes or tasks (Z++ threaded form of class), and global functions that glue together instances of such classes. A component captures a specific aspect of an application, which cannot be cast into a plain set of classes. In particular, a component is a complete program that can be executed and used on its own merits.

Applications are composed from components. The new application can adjust the use of its components by specifying its own invariants and constraints.

When composing a new application, the geographic location of execution of its components within the Internet is irrelevant in that it does not require code modification.

A number of examples accompanying Z++ Visual demonstrate that components used in the composition of an application can be derived from one another the same way as classes are derived.

A Z++ autonomous agent is a component that travels from node to node maintaining its state as a process. This is known as strong mobility.

References.

1. Component illustrates the use of components.
2. Invariant discusses invariants and constraints.
3. Threads briefly reviews global threads and tasks.

In addition, Z++ Language Reference provides an overview of the language and illustrates significant features like Autonomous Agents, signaling mechanism, etc.

Architecture and Design

Definition. An application comprises of a set of (distributed) communicating components.

Since an entire application can serve as a component in composing a larger application this definition is recursive in nature. Specifically, in Z++ the distinction between an application and a component is only conceptual. When a component is used as a final product for a particular solution, we think of it as an application. On the other hand, when the same application is used in composing larger applications, we think of it as a component.

The use of a live (executing on some node within the Internet) application as a component does not interfere with the operations of the application. In other words, a new application can simply use any number of live applications as components in addition to possibly other components in its architecture. We use the term module when referring to a live application used as a component. The term module is conceptual and has no corresponding linguistic mechanism in Z++.

Another conceptual term in connection with components is layer. The term layer in Z++ is related to layers of exception and is not associated with components. Nonetheless, the term layer is generally referred to a group of components that together capture a particular level in the architecture of an application. For instance a compiler is usually implemented in layers.

The notions of architecture and design are distinct. At architectural level we are concerned with components and their modes of communication. Eventually, each component must be implemented by, designing classes, tasks, global functions and calls to libraries. That is, at design level we are concerned with actual implementation of a specific component. The smallest architectural unit is a component. A class, task or a global function is a unit of design within a component.

Comprehendible Size

We need to differentiate between the size of an application and the size comprehendible by a single developer. Theoretically, there is no limit to the size of an application, especially when any number of parts of an application could be running on distinct nodes. However, a developer needs to properly understand the code he/she is dealing with in order to find defects and fix them without breaking other parts of that code.

Multiple developers for the same component, does not raise the comprehendible size noticeably. Here and there it helps in locating defects, and occasionally in avoiding the introduction of new defects. The total comprehendible size, however, grows very slowly and in fact beyond a threshold, depending on team members, it begins dropping. For the sake of having a number, I assume that the comprehendible size is about 100,000 lines of coherent C++ code. By coherent I mean the code that the engineer wrote for a particular solution, excluding the understandability of external libraries and technologies beyond a black box.

On the average, an equivalent component in Z++ would be about 75,000 lines of coherent code. In fact, the more complex the code in its use of database, distributed computing, threading and other advanced concepts, the larger the difference in lines of code between C++ and Z++. It is also important to note that Z++ abstractions are easier to understand which in turn reduces the possibility of defects. A lot of defects get buried in lower level details used for the implementations of partial equivalents to Z++ abstractions.

Types of Components

In previous section we mentioned two special forms of use of components, namely a module and a layer. In this section we name a few more.

It is not possible to create a complex application without putting together a set of complex components. Note that by a complex component I mean the natural complexity of the problem being solved, not that the component is written badly.

Large enterprise distributed applications cannot be directly broken down to classes, nor a component is the equivalent of a class. A component is the conceptual understanding of a major aspect of an application for purposes of implementation in a programming language. Although at architectural level we are not concerned about implementation, we should be aware of the capabilities of the selected language. Those capabilities affect the architectural decisions. After all, the architect of an edifice must be aware of the availability of techniques and material for erecting his/her drawing.

In composing an application we can use different forms of modules (live components). Sometimes we directly use a module as part of the new application, and other times we may only need to interact with another application in the form of a server. In the latter case, a component for the new application can interact with a database or an Internet server rather than the server becoming a component of the new application. We refer to the component that interacts with a server as a wrapper. Basically, the new application makes calls into its wrapper component, which in turn communicates with the server via a protocol.

Sometimes an application needs to interact with a set of applications (including servers). Furthermore, the overhead of communicating with each of these applications is too great for the amount of final data that is needed in order to make a decision. In such cases, the application can send out a component that knows where to go and collect the required data, and finally return to the original application. This type of traveling component can be implemented as a Z++ Autonomous Agent. Upon its return the agent can signal its arrival and provide the requested data to the application.

An autonomous agent can do its job in other ways. The agent may go to a node, and after gaining the needed data it can transmit it to its mother application. The agent can then move to other nodes and do the same thing until its operation is completed. For instance, it may receive instructions to return to a previous node and perform some further operations (finalize a reservation, shut down a service, etc).

It should be clear that a Z++ autonomous agent can interact with servers written in any language. For instance, database servers are written in C but they communicate via SQL.

Conclusion

The main point we are making is that, when a program fits within a single component our activity begins with design. We think of classes, functions, threads, signals and libraries for the implementation of the program.

On the other hand, we are saying that today’s applications are generally large and distributed. The development of applications begins with architectural activities for laying out the characteristics of components and their interactions in a distributed setting.

The language Z++ provides a uniform view of abstractions for building large distributed application, and the distributed operating system Z47 is a cushion for longevity of Z++ applications. Physical computing devices are merely a means for user interaction with applications. An application is an abstraction independent of the set of physical devices on which it runs. Thus, an application must outlast short-lived physical computing devices.

Presently, there are system applications that are designed for particular devices. Some of these system applications, such as games, may remain so for a long time if not forever. However, enterprise solutions packaged by the vendor of a device are not good examples of system applications. Unlike games, enterprise solutions use a variety of platforms, each of which may be presented on a set of computing devices.

Z++ tell/hear and Web Services

2010-05-19T16:17:00.000-07:00

Mathematics evolves through simplification of complexity. Higher-level concepts abstract away a great deal of complexity. Otherwise, our fundamental tool would be limited to arithmetic and basic geometry. In the same vain, software engineering will make a jump in solving problems only when a programming language brings about simplification by hiding complexity through automation of higher-level abstractions.

In Robotic Communication we illustrated an application of tell/hear with regard to Concurrent Communicating Processes. The tell/hear abstraction is orthogonal to the rest of Z++ expressiveness, and therefore it monotonically increases Z++ expressiveness. In this note we will illustrate another application of tell/hear for solving the problem of Web Services.

Z++ is generally described as a greatly enhanced superset of C++. Indeed, Z++ corrects C++ defects and extends its subset in many directions. However, Z++ abstractions for a variety of software solutions can never become part of C++. These abstractions, one of which we will illustrate here, require technological solutions which are beyond what a language can do on its own. For Z++ this underlying technology is Z47 Processor.

Without reviewing the boring history of Web Services, let us just state what was envisaged by that terminology. A client is looking for a particular service. The method of describing this service is a service indicator and a list of types of objects that may be sent along for service. The client may only need an acknowledgement of completion of service, or it may receive some data as part of the acknowledgement.

Let us look at a scenario. A user has registered with a service provider for hotel reservations, plane tickets, etc. Using his handheld device, the user fills out a request for a particular type of hotel, pricing and dates. The application adds user’s authentication to the request and sends it to the server. At this time user is able to use his device for other purposes.

A few minutes later user receives a popup on his device informing him of the availability of the service. For simplicity, we avoid the case that the server may have suggested alternatives, and that user may change some data and resend the request. Once the user accepts the offer, the server will confirm the service, charge the user’s account and send back a confirmation. The application will also record the confirmation for future use. In this scenario, the contact-server may also need to contact other servers as a client for finding the right hotel and pricing for its client. This process is also part of Web Services.

Thinking about a solution for the above scenario, we see that most of the cost of development will be in the area of communication and testing of data transmission. After all, a GUI and some file processing is not a major challenge and can be tested quite easily. So, how does Z++ reduce the complexity of developing this type of software?

The Z++ tell/hear signaling provides a simple and natural form of telling a server about a request and later hearing about it. Obviously, the simplicity hides a great deal of complexity. The linguistic design is quite effective in assisting the compiler to trap many coding errors. Furthermore, regardless of the complexity of data, there is no visible code in a Z++ application regarding data transmission, communication, synchronization or anything else for that matter. Basically, the server side of code focuses on the services, and the client code deals with providing its user with a simple GUI.

Z++ approach is as follows. The provider of a service simply registers the service as a hears(…) specification. This is a simple line of code similar to throws specification. On the client side, a client simply tells what it needs in a line that resembles a function call. Z47 Processor undertakes the entire complexity of executing the protocol. The protocol asks the server whether it is capable of providing the service prior to sending the actual data to it. The server checks the request against its registered hears(…) specifications. All of this is transparent to Z++ code. That simply means there is no code to write beyond expressing your intent, and therefore nothing to test or maintain, either.

New services can be added without having to change the code already written in any subtle way. Basically, one adds a new hears(…) specification, and the related code for serving an incoming request. No other part of the code needs updating.

On the other hand, the notion of Web Services is independent of expressiveness of C++ language. That means, one needs to line up library API using the facilities of the operating system on which a client or server will be running. But then a C++ compiler would not able to trap errors relevant to the notion of Web Services. Relatively speaking, such a C++ program will be large, complex and look like assembly language.

Z++ and Robotic Communication

2010-05-09T18:31:00.000-07:00

It seems like technology leaders are hoping for a Shakespeare who could write Romeo and Juliet with only half of the English he used. They limit their champions to Java, then BASIC or something like that, and then they eagerly await an impossible miracle. After all, even miracles that actually occur like Romeo and Juliet are relative to circumstances.

Perhaps someday robots will exceed Turing’s expectations and will be bored in carrying out a conversation with us. For now, however, our robots communicate by means of exchanging data with predetermined structure. The hurdle stopping us from achieving miracle software in robotic communication is not in the nature of the communication itself. Instead, we need a medium in which our Hugo and Shakespeare can develop such poetic software.

We must believe that there are software Hugo and Shakespeare out there as witnessed by the great software we are enjoying today. These software poets have written almost all the poetry that could be written within the existing linguistic abstractions available to them. In order to appreciate the challenge, imagine Hugo having to write an entire page for each of his lines of poetry, and still not be happy with his work.

Looking at history of mathematics, we see that Set Theory of Cantor and later the notion of Abstract Space by Frechet gave birth to modern mathematics in the hands of poet mathematicians. Thus, technology leaders are either unaware of the part of our history that relates to them, or prefer to live in denial. I suppose it is a combination of both.

An engineer writes his poetry in a programming language. So, what kind of abstractions will help our poet developers in achieving their goal of creating software for robots to exchange data in a manner that we can interpret as robotic communication?

Consider n robots attempting to accomplish a task. Each robot will have a name or something like that in order to be addressed by other robots. For simplicity, we refer to each robot as a node, and the name of the node will be its IP address. Note that this is an illustration of an abstraction and we will use the terms robot and node interchangeably.

Suppose robot M (that is, the node at IP address M) wishes to say something to robot N. Before M says anything it must get the attention of N. Also, M is busy doing something and cannot simply stop, say something and wait until it hears back from N, at least not every time that M needs to tell N something. In the same vain, N can talk to M when it needs M to do something for helping it.

We speak in patterns like Subject Verb, etc. We are able to understand a statement that does not quite follow an expected pattern. However, it takes a second or so to make sense of what we have heard. That means there is a low-level communication that expects fixed patterns, and a higher-level that can map an out of order pattern to its correct form. For now, we are only interested in low-level communication with regard to robots. That is, the pattern for data to be exchanged must be predetermined or the hearing robot cannot use the data transmitted to it.

The low-level pattern for robotic communication is a list of data types as in a function signature. Two robots M and N can communicate using a pattern if both are aware of the pattern. So now we need to investigate suitable linguistic abstractions to facilitate expressing these notions in the context of a program. We illustrate these ideas using the approach taken by the Z++ language.

The hearing robot N needs to know what patterns it is capable of accepting (understanding). So, an engineer needs a way of expressing this matter. In Z++, N learns its patterns by registering them in a hears(…) specification, as follows.

hears(signal, type_1, …)

In above statement, signal is effectively the name of the pattern, and the list of types is the actual pattern. We can think of the statement as, when a process executes the statement it learns the pattern. Thus, robot N is only capable of understanding all the patterns that it registers via the hears(…) specification.

Now robot M can talk to N using the Z++ tell statement, as follows.

tell N, signal, data_1, …

The first argument of tell is the name or the IP address of robot N. This is followed by the name of pattern and the actual data to be sent to N. However, the tell statement initially asks N if it recognizes the pattern by sending it the signal and the types of the data, but not the actual data. This gets the attention of robot N and enables M to decide whether or not to send the data. In programming terminology, if the tell statement fails at this point it raises an exception. Considering that Z++ exceptions can be resumed, an engineer is able to properly design the program to handle unusual circumstances.

Finally, N needs a way of receiving the data. The third and the last abstraction, does precisely that as follows.

hear signal, data_1, …

In the above statement, the data sent by tell statement are copied to the data listed in the hear statement. In this article we are not concerned about how intelligently N will use the data it hears from a tell statement. Our intent is to describe the abstractions that enable engineering poets to create their masterpieces.

In Z++ there are only three intuitive statements, which also help the compiler to trap many types of errors. That is the minimum number of abstractions needed for designing an understandable program that deals with robotic communication.

Now we can reiterate what was said at the beginning of this note. Removing the three abstractions mentioned here forces Hugo to write a page for a lot of his lines of poetry, and still feel discontent. In programming context discontent translates to uncertain about the behavior of the program. In particular such complex programs are formidable to debug. However, debugging three abstract statements can even be done by plain code walk-through.

Z++ and Distributed Computing

2010-05-02T08:54:00.000-07:00

For decades now we have been using same software development technologies and yet no new idea has emerged beyond email exchanges. Handheld devices play videos and are capable of connecting to the Internet for downloading music, games and at times for receiving alert text messages. The leap to next level of software, true distributed software, requires fundamental renovations at both ends top and bottom.

Language is the final frontier for entering the era of distributed communicating applications. Gluing several languages together does not elevate our technological capabilities, only exponentially raises unnecessary complexity and therefore the cost of development and maintenance. An expressive distributed language for Autonomous Agents and Communicating Distributed Processes demands an underlying distributed operating system.

Z++ language, powered by Z47 Processor, enables the cooperation of all types of operating systems in running distributed software. What can be developed rather naturally in Z++ cannot be accomplished with the sum of all contemporary languages and gluing technologies.

The failure of XML demonstrates that Web Services require a fundamentally different approach. Z++ tell/hear signaling solves this problem by providing the technology of Asynchronous Function Call. The requesting Z47 initially sends the signature of a function to the provider Z47, and if the server accepts the requests, only then the actual data is sent in binary. The server can also use tell/hear signals to inform the client of completion of service. Since a server can itself seek a requested service from other servers, ISPs and other service providers can use this technology for the implementation of realistic Web Services as was envisaged a few years earlier. It is interesting to note that the use of tell/hear signaling in Z++ is quite straightforward. What we have described here is the protocol followed by Z47 processors, which is transparent to a Z++ application.

Services are generally provided via Internet, and PHP is extensively used for the implementation of services, or as a facilitator. Since PHP can directly invoke local and remote Z++ applications, even in these cases the use of PHP becomes rather trivial as a facilitator. The actual services can be implemented entirely in Z++.

Turning our attention to Original Equipment Manufacturers (OEM), we see that they either pack handheld devices with their own products, or support some virtual machine for the community of their developers. An OEM can attract more than single developers at home by moving away from an old technology of the sixties, known as Virtual Machine. Languages based on this technology cannot evolve any further as observed over past decades. The Z47 Processor is in fact a self-contained Distributed Operating System, of about 500K in size. OEMs only needs to add their GUI maker to the Z++ object-oriented layer for Graphical User Interface thereby providing its developers with a coherent and elegantly expressive language far beyond the sum of all available languages.

With regard to scientists researching intelligent software, the problem here is that intelligent software confined to a single node has limited use. Realistic intelligent applications are distributed in nature and therefore need a means of communication. The prevailing concepts of Remote Procedure Call (RPC) and Communicating Sequential Processes (CSP) are inadequate for the type of communication needed for sophisticated intelligent software. In context of Z++ language, an Autonomous Agent is an application that simply travels to another node. Other than the travel statement, the entire operation is transparent to the Z++ application. An application travels as a live Z47 process to another Z47 node. The process begins execution on the destination node as if it never moved at all. Thus, a Z47 process is capable of continuing its execution as it travels from node to node.

As for communication mechanism, the tell/hear signaling mechanism of Z++ furnishes the linguistic abstraction of Communicating Concurrent Processes (CCS). In CCS model, one node tells its data to another node that is hearing it. The teller does not wait as in RPC, but it can also hear at a later time. This simple and natural mechanism allows Z++ applications to communicate as they go. The data transmission is in binary and transparent to the application.

This category of researchers now have the technology for designing intelligent distributed software for communicating robots in a factory, objects flying in the sky and down to Nano-Technology. The impedance in fleshing out this type of software is due to inadequacy of CSP and RPC, while XML is essentially a nuisance.

Computer scientists are interested in discovering new and better ways of developing software. Linguistic improvements are the most critical issues of this domain of research. However, it is not possible to make a whole new language for every discovery. The language under research for new ideas must be monotonically extensible so that new discoveries can become part of the language in an orthogonal manner. There should not be any loss from what the language was used for in order to incorporate a new abstraction. Z++ is powered by a self-contained extensible distributed operating system. That qualifies Z++ as the only candidate for this type of research.

Computer scientists can now engage in further research towards the development of reliable applications that cannot be envisaged at our time. Leaving Z++ out, relative to the available technology some contemporary research ideas seem more like science fiction. Indeed, while Autonomous Agents are native to Z++ it is impossible to implement such agents with strong mobility outside of Z++. Furthermore, Z++ already solves a few other problems such as Component-oriented Development and developing by teams spread in different geographical locations.

Entering the next stage of software engineering requires breaking the barrier of linguistic impedance. Engineers of different backgrounds design the engine, the electric system and the brake system of a car. Nonetheless, all these engineers use various parts of mathematics that even a mathematician cannot master in its entirety. In the same vain, software engineers need not master the entire Z++ language for purposes of development. Nevertheless, the whole team will be able to speak the same familiar language regardless of the vastness of the application under research, design and development.

Finally, apart from containing the abstractions for solving some outstanding software problems, a language must be coherent and lack partial and weak mechanisms, which create traps for software engineers. C++ is an ad hoc extension of C, which also imports all the weakness of a needed assembly language, and borrows some elegance from Simula. Originally C++ was meant for developing applications, not just more complex system programs than C could manage.

For engineers Z++ is a greatly enhanced superset of C++. An object-oriented design of the familiar database SQL statements is simply part of the Z++ language. Furthermore, threading and graphical user interface are also designed in accordance to object-oriented paradigm. Z++ classes and tasks, template or not, can specify Invariants and Constraints. In addition, template instantiations can be constrained via pattern specifications. Enumerations are extensible and notions like mutex are simply built-in types. Z++ Collections with their Shared Methods extend object-oriented notions horizontally. While this is a brief description of part of the super language Z++, engineers will find it much easier to develop applications in Z++ as compared to C++.

Defining a Distributed Operating System

2010-01-11T19:35:00.000-08:00

In this note, a definition for the notion of Distributed Operating System is presented. The definition is based on the concept of an autonomous process. Accordingly, we first review the notion of process, and define an autonomous process.

Consider a ubiquitous operating system, such as UNIX. What do we expect from an operating system for a particular computing device, such as a desktop or a handheld? One category of functions expected from an OS is to manage the resources (physical/virtual) of the device and provide a means of interacting with them. For instance, keyboard, screen, mouse, soundcard, video card, disk drives etc. We also expect an OS to manage virtual memory and provide memory-protection among several simultaneous applications. This category of OS abstractions is related to controlling and managing physical components comprising a computing device.

The most visible, perhaps the most useful function of an OS from a user’s perspective is to turn an application into an executing process, which happens when a user runs the application. The OS abstractions in this category are associated with managing processes/threads and providing means of inter-communication among them. Processes depend on OS functions in the first category for IO, memory and file access etc. However, this category (process/thread management) is distinct from device-management functions of the first category. In fact, an OS may not even support the notion of a process at all.

The X-Server for UNIX illustrates the distinction between the first and the second category of OS functions. An X application can run on a remote machine while user interacts with it using the keyboard, mouse and monitor attached to a local machine. A variation of this idea is the notion of file-server, which for some time seemed to be an example of a distributed OS.

Now consider a multi-processor computing device. The OS for such a device provides true support for a multi-processor system if whenever a process gains its time-slice it could run on a processor other than the one that put that process on the wait queue. A simple conclusion is that, a process in such an OS may execute on several processors during its lifetime, or that a process is independent of the processor on which it runs.

Preliminary Definition. In an OS for a multi-processor computing device, a process is autonomous if it can gain its time slice independent of the processor that powered it for a previous time slice.

Having defined the restricted notion of an autonomous process, we observe that a distributed OS must comprise of several computing devices (nodes), each of which equipped with its own OS. Thus, a distributed OS for a set of nodes is distinct from the operating systems managing each of its nodes. The expectation from a distributed OS is to manage a class of processes in a manner as if the nodes are CPUs in a multi-processor OS. That is, a process of the distributed OS may gain its time slice on a node other than the node on which it went on to the wait queue.

Definition.
Autonomous process. A process is autonomous with respect to a set of nodes if, for each time slice, it is capable of executing on any one of nodes.
Distributed OS. An operating system for a set of nodes is distributed if and only if it supports autonomous processes among those nodes.

An autonomous process is a representation of a form of application known as autonomous agent. Thus, our final definition for a distributed OS takes the following form.

Definition. An operating system is distributed if and only if it supports autonomous agents.

An autonomous process of a distributed OS cannot be the same as a process of any OS controlling the nodes in a network. This is because a process created by the OS of a computing device cannot move to other computing devices. In other words, autonomous processes are distinct from system processes and cannot be created via system calls of any of the nodes. This simply implies that a distributed OS must be self-contained with regard to the creation of processes (threads, and their intercommunication).

Having defined the notion of a distributed OS the natural question that arises is whether it is possible to construct such an operating system. The answer is yes. Indeed, Z47 is a self-contained distributed operating system (SC-DOS) according to the definition presented in this note.

Concurrent Communicating Processes

2009-10-22T15:56:00.000-07:00

Transformation of a symbol to another takes time, however small. Thus, some action must occur for a transformation to take place. We assume a certain number of transformations (functions) and a few ways of combining them provide us with the set of computable functions. By automating the actions needed to perform these transformations and ways of combining them we arrive at what can be automated. In this sense, what can be automated and what can be computed are synonyms.

However, there are actions other than those needed for the set of computable functions that can be automated. For instance, when we accept that a Turin machine can write a symbol on its tape, we are saying that the action of writing the symbol can be automated. The sending of a message from one computer to another is another example. Thus, what can be automated is a larger set than what can be computed.

In the same sense, an algorithm can be extended to mean a finite sequence of actions that can be automated in order to accomplish tasks, which may involve computations. For instance, imbedded computers allow robots to perform many physical operations algorithmically. Such robots will generally perform computations in order to accomplish their tasks. But they also perform actions that are not related to a computation.

Through simulation one can show that two stack machines are equivalent to a Turing machine. The cooperation of the two stack machines is achieved via implicit communication. In other words, when we add communication between two or more entities we get more than the sum of individual entities. Nonetheless, regardless of number of Turing machines put together, we do not get a larger set of computable functions. This is because communication among Turing machines is not needed in order to arrive at the set of computable functions, at least not the set as we understand it now.

Suppose we have designed a robot that can act like a carpenter and make a large collection of tables, algorithmically by following a set of pre-determined programs. Now, suppose we need tables that their construction will take the cooperation of two carpenters. Replace the carpenters with two communicating robots. In this case, the robots will need to synchronize their actions while putting together certain parts. In other words, by adding the dimension of communication we have extended the (automated) set of tables that can be constructed. Each robot will have a Turing machine inside it for performing the computations it needs for its movements. However, the set of tasks they can accomplish together is larger than the set of tasks each of the robots could accomplish alone.

Concurrent communicating processes refers to two or more separate entities with imbedded computers that accomplish automated tasks via communication. The main characteristic of this scenario is that the processes may use rendezvous, but they certainly use interruption (signaling). That is, after sending a message the sending process does not necessarily halt until the other process sends its response back. Basically, one process anticipates certain changes required in the state of another processes. It signals that process and passes the data to it. The recipient accepts the data and sets its new state accordingly, which may change its future computations for performing its operations.

The use of shared memory between two processes on a single machine seems like a simulation of concurrent communicating processes. A reasonable and simple simulation can also be achieved via two Z++ threads using common objects. This use of concurrent communicating processes is for convenience in computing algorithms that can also be completed sequentially. The use of algorithm in our case is more general than computations involving mathematical functions alone. Indeed, in our model an algorithm involves simultaneous participation of individual entities in accomplishing a common task. After all, the purpose of a mathematical computation is to take some action. When a task requires more than one entity, communication is a necessity rather than a convenience.

The formalization of this model of automation requires more refined research. The model cannot be mapped to a single entity with an imbedded Turing machine. Rather, it seems more like cooperative distributed computing that requires more than one computing entity. In order to have a name for the notion, we call this model concurrent communicating processes. We may need to work more seriously on this model for controlling intelligent space entities of the future in order to extend our knowledge beyond the capabilities of telescopes. The Z47 processor is a good start.

Rubaiyat

2009-07-15T16:04:00.000-07:00

This is the final blog containing persian poetry.

The style of poetry is Rubaiyat. It is therefore appropriate to mention Khayyam first. Rubaiyat are grouped in sets, to the extent that it would make sense. The entire set was written between July 10 and July 12 of 2009. Getting all of typed has not completed yet.

خیام سخن با تو میگفت
گرفتاری ما بنده توست
خیام را نبودی جوابت
بر ما علم کردی بنده ات

This set is about Supreme Leader and his followers with regard to Mahdi.

مهدی آید آنگاه که خواهد خدای
خدای را باشد توان و یارای
تو بنده ناچیز و ژاژ سرای
صاحب زمان را چه دانی رای

ایران عرصه جنگ مهدی نیست
مهدی را نیازی به خدمت تو نیست
گر تو باخته ای عقل چاره چیست
ترسم جز برانداختن تو راهی نیست

گویی بهر قضاوت آید مهدی
آنگه که شیطان بسلطه آرد گیتی
وانگه مدعی باشی که آماده کنی
جهان را برای آمدن مهدی

This set is about rigging votes.

آنچه تو گویی اسلام است
دروغ بهر اسلام روا است
رای من و دیگران چه سودست
آنچه تو گویی شمارش همانست

رییس جمهور را ترس باخت گرفت
دست زد و دامن رهبر گرفت
رهبر نادان را شوق تقلب گرفت
رای مردم نجیب را ببازی گرفت

تو کز آرای دیگران بیغمی
نباشی فقیه و نی آدمی
چو یکی از آرا شود دزدی
دیگر آرا بجنگند بهر درستی

ملت را سر آمده طاقت دگر
بصندوق رای رفتند خون جگر
رهبر پشتوانه مرد پرخاشگر
چو کوری عصا کش کور دگر

دولت قلابی نماند پایدار
پایبوس رهبر نیاید بکار
دزد آرا را نباشد قرار
رای ریزان نگریزند ز کار زار

This set is about Islamic Revolution of 30 years ago, in general terms.

انقلاب ز بهر آزادی بود
نه بر سر چادر و روسری بود
خون ریزی برای زندگی بود
نه برای رنج و غمگساری بود

انقلاب شده سی ساله
ملت ایران بی کاشانه
کس را چه سود زان مبارزه
جز رهبروبسیجی و دگر نخاله

ای که سی سال رفت و در خوابی
مگر این چند روزه در یابی
ایران اسیر دولت قلابی
تو در خواب بینی مرغابی

انقلاب را ملت کند پایدار
نه تیر و تفنگ و پاسدار
کهن فرهنگ خاک کاروزار
بزیر آورد ستم هر زمامدار

رژیم با رسانه ها و عمال دگرش
کرده کر گوش گیتی و ماهوارگانش
گر یکی گوید سخن ز هر سویش
مزدوران رژیم کنند رسوایش

آزاده ملت ایران نیاسایند
تا مرزو بومش به آزادی بیارایند
گر تو نیز باشی ایرانی اندیشمند
چون پنداری شیران بزانو در آیند

بتزویر و حیله تفرق پراکنده ای
با دسیسه ملت را بدو قسم کرده ای
گروهی ابله بهمراه رندان کرده ای
آزادگان را بجنگ هم میهنان کرده ای

انقلابی که سی سال منقلب باشد
آنرا هزاران تفنگ مراقب باشد
طعمه شیادان و خدانشناسان باشد
ربوده زمردم با چوب و چماق باشد

سی سال است با ملت در جنگی
بخیال خود خیلی هم زرنگی
حال که شکستی رسم مردانگی
بزیر آیی با تیپا و اردنگی

This set addresses Supreme Leader.

گر خدا با تو سخن گوید
چرا مزدورانت گرد آرد
بکاه اندکی حقوق یکی چند
آنگاه ببین خدا چون کند

این مزدوران که گرد رهبر بینی
به عشق پول و تفنگ هر جا بینی
از قماش همانند که زمان مصدقی
شاه را به تخت نشاندند چو دیدی

رهبر نادان و پیروان مزدور
بر سر دانشجو زنند دست زور
گر تفنگشان کنی اندکی دور
بیفتند بپای ترسان چو مور

یکی مقامش ولایت فقیه است
دیگری مقامش رییس جمهورست
زنجیر اسارت ما بدست دو مقام
چند هزار ابله و مزدورست

This set is in response to protesters being called Khas-o-Khashak.

بچندی خس و خاشاک کنی لگد مال
بتزویر و ریا ریاست کنی حلال
زین خس و خاشاک برویند نهال
وان کوته پیکر تو کنند بلال

خس و خاشاک مزدوران تواند
رهبر و حامیان نادان تواند
ایرانیان مالک این زمینند
خس و خاشاک امثال تواند

ای دل عبرت بین از دیده نظر کن
خس و خاشاک را آیینه عبرت کن
آیندگان را هوشیار و آگاه کن
دانا را خس و خاشاک نادان مکن

ایرانی را گویی خس و خاشاک
تو ایرانی نمایی به پوشاک
گیرم ندانی حماسه خاشاک
خس چون تو بگردد خاشاک

This set is about various cities and provinces.

بوی رود کارون آید همی
نوای نی به نخلستان آید همی
خواب کز چشمان رود یک دمی
نفیر چماق و بوی خون آید همی

شیراز و اصفهان که بود نصف جهان
کنون نگیرد کس از آنها نشان
صنع و هنر بزرگان هر زمان
گمنام در سلطه تفنگ مزدوران

مازندران و گیلان بهشت ایران
ز بسیجی و رندان گشته ویران
چو بر خیزند دست بدست شیران
بابلی و رشتی کنند ترا حیران

آذربایجان و خراسان بوم شیران
زیر تفنگ و سنان پاسداران
اسلامت را دهند باز به شیطان
که اینان باشند براستی مسلمان

کرد را نباشد هراسی از تفنگت
او نجوید خون بیچاره مزدورت
همانا گر کردستان را آید کدورت
بشنو نصیحت و باز خوان مزدورت

This set talks about women's cover and paradise.

دولت که مراقب حجاب زنان است

مجری کدام قانون از آسمانست

گر موی زن مایه فغانست
تقصیر از مرد چشم چرانست

آنکه معطوف پوشش زنان است
کی وقت پویش و دروس است
بچشمش هر غیر خودی جاسوسست
مشوش خاطر کی توان خلوص است

بهشتت را بزور چماق من نخواهم
خدمت تو بهر سکونت بهشت نخواهم
گر تو و پاسدارانت باشید همسفرم
من جهنم را با جان و دل میخواهم

گر بهای بهشت باشد چماق
ترا واجب هزاران شلاق
سخن از بهشت مگو جلاد
تو خود باشی راهی باتلاق

ملت ایران رعیت خود دانی
خود را ناجی کل جهان دانی
سرمایه ملت خرج افکارت کنی
انگار که مالک کل ایرانی

مارا چه ستیزی با جهانیان
گرسنه بخوابند مارا طفلان
دست بدست بسازیم این ویران
صنع و اقتصاد استقلال ایران

ایران شده میدان کارزار
سیمای رهبر گشته دل آزار
پیرو جوان از زندگی بیزار
زندگی نیارزد دگر به دو زار

رهبر پی گسترش سایه بر گیتی
با چوب و چماق و یکی بمب اتمی
رندان از پی پر کردن جیب خودی
کشند کهن ایران بمرز نا امیدی

This set will contain the rest.

شیرین سخن فردوسی ما را بگوید
توانا بود هر که دانا بود
دانشور پا برهنه را راهنما بود
ولایت فقیه مایه جنجال بود

ملتم خس و خاشاک میهنم پژمرده
خود بگوشه غربت و بس دل آزرده
شوم بسویش من تند و چابک روانه
تا فدایش کنم مر این عمر بیهوده

بغربت گذ شتم این سالها
خاک میهن زیر کفش جلاد ها
جوانیم پیشکش دیگر زمینها
جوانان ایران زیر خاکها

آسمان ایران شده کم ستاره
نادان همه را کرده آواره
دگر ستارگان را نباشد چاره
جز اسارت بزور خمپاره

سی سال بغربت خوابیدم کاهل
در پیری کشتار جوانانم کرد عاقل
مر فرزندان را بساختم صد جلال
دگر فرزندان را بماندم غافل

گر ایران فرسوده بدست بیگانه
مرا چون باشد بغربت کاشانه
ره ایران جویم بی تابانه
چماق و کتک خورم جانانه

سالیان جوانی بگذشت بغربت
به پیری بر آمده مرا غیرت
در جوانی پوییدم ره هجرت
به پیری سرایم سوز محنت

بساختم چند فرزندان بهر تو
گر چه گریختم ز دشمنان تو
کنون باز گردم به آغوش تو
که آنها بیاسایند در خاک تو

The paradox of Supreme Leader

2009-07-06T15:06:00.000-07:00

The majority of Iranians believe in twelve Imams, and no one believes in more than twelve Imams. An Imam is divinely inspired. The twelfth Imam disappeared with the promise of re-appearing. He will appear when the world has been lost to chaos, and will bring about order and justice.

There is a cult in Iran that teaches the notion of Supreme Leader. In order to legitimize the concept, the cult endows the Supreme Leader with Divine Inspiration, a characteristic of an Imam. That makes the Supreme Leader the shadow of god, or at least the representative of the twelfth Imam on earth. The significant point is the claim that the Supreme Leader is divinely inspired.

The only characteristic that separates an Imam, including the twelfth Imam, from an ayatollah is the direct divine inspiration. Therefore, someone with that type of divine privilege can only be an Imam. Now we have two possible interpretations.

Either, the sequence of Imams has continued beyond the twelfth, or the Supreme Leader is the equal of the twelfth Imam. The former is a dead-end. The latter, is a contradiction that has somehow being accepted by a small percentage of believers. But if the Supreme Leader is at the same level of divinity as the twelfth Imam, what would be the purpose of having to await the arrival of the true savior?

This argument is given at the end of the following poetry. However, the none-divine inspiration for the poetry has a different source. My second son was born in December of 1978, when we heard the victory of the Islamic Revolution from radio Iran. I called him Peyvand meaning that from now on, all Iran will be united under one constitution. Unfortunately, the king was replaced with supreme leader, and the revolution was stolen again, though this time from within. The poetry is devoted to my son Peyvand.

ایرانیان گردهم آییم خروشان تا یک زمان زاری کنیم سوگواران

با اشک چشم خود بشوییم تهران زخون سرخ آن رشید جوانان

بیاراییم خیابانهای این شهر پردلان با نامهای آن شیر زنان و مردان

ببافیم باهم یکی حوله آزادگان حوله ای تنیده بدل بافته بجان

نه شاه و نه فقیه و نه دگر رندان زین پس ایران سازیم بوم روشنفکران

انقلابی که او را مزدور باشد پاسداران نباشد به زان پیشینه دوران

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

دریابید ای پیران و جوانان بنگرید ای مادران و پدران

دزدان خاکمان کشند مارا فرزندان تا به کی دهیم تن بین ستم ظالمان

آنکه مزدور نشاند اندر خیابان زبهر خون آن عزیز فرزندان

خدا نشناسد و باشد سایه شیطان ترا عقل برده خوابی بس گران

بزه دینی را خدای دهد جوابان نه چماق و چاقوی زور گویان

مملکتداری را چه کاری به موی زنان خدای را چه ستیزی با دیگر جهانیان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

امر به معروف و نهی از منکر ز آگاهان رهنمونی باشد ز بهر هشداران

ضربات چوب ابلهان و چماقداران نباشد جز وسیله اغتشاش خاطران

هدف هدایت تو نیست به دیگر جهان اینهارا نباشد باور به یزدان

ایزد را پناه گیرند دروغ گویان پر کنند بانکها با پول فراوان

گرسنه بخسبند کودکان بهزاران که ایران شده لبریز از دزدان

بیهوده مجوی حقانیت خاینان ترا اندیشه همی رفته به گروگان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

سراسر زمام مملکت بدست یک انسان راه جاهلانست و کوته فکران

شیوه مملکت مردمش باشند خواهان ولایت فقیه نباشد سوای شاهنشاهان

منتخب نماینگان ملت ایران باشند جویای چاره و درمان

قانون آنست که گویند نمایندگان فقیه باشد مرجع قانونگذاران

قشری ابله با چوبها و چماقان باشند مجری ولایت فقیه نادان

گر کس ندارد حق بجز سیه دلان جمهوری نباشد بلکه یک زندان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

ایران مملو از دانا و بلند فکران گشته اسیر مشتی نفهم و ابلهان

مرز ایران شده دیوار زندان بسیجی و چماقدار همه جا فراوان

سخن گویی جوازیست به کوچک زندان کسی را نباشد یارای بیان

این خفقان نباشد ره دیگر جهان راه خدا کی با افسار و سنان

خدای را ابزاریست این تاریکدلان بهر نابودی افکار اندیشمندان

خدای یگانه بخشنده مهربان نجوید خون کجرو بندگان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

بلهظه ای و بروزی گذشت هر زمان برباد دهد بزرگ میراث فرهنگمان

تاریخ مخدوش سازند ناجوانمردان برند بتاریکی بیدفاع کودکان

فردا فرزندان بی پناه گمراهان ندانند ز فروشکوه خاک ایران

نباشد دمی برای درنگ در درمان بهردم بسختی کشند فکر نو جوانان

خاموش و ترسان آموزش فرزندان بسازد بسان سیاوش آتشی فروزان

ما را نشاید که خواهیم آینده فرزاندان کشند خود خواهران و برادران

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

خون و خونریزی در خیابان نباشد چاره رهایی ز دزدان

بیرحمانه کشند ناجوانمردان پیرو جوان و شیر زنان

کارماند و صناع و دگر هنرمندان به پشتوانه بلند بازاریان

به ولایت فقیه و گمراه ابلهان پیوند ملت را کنند نمایان

همانا گر آش خشم ملت شود فروزان ترو خشک بسوزد باهم یک زمان

ایران گردد طعمه دگر دزدان خونها ریخته و ما باز در زندان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

گر پیوند تو با این قلدران نباشد جز محتوای فصیح قرآن

تو خود داری عقل و هوش و دو چشمان خود گول زنی نباشد زیبنده عاقلان

نشاید که بینی دیگر فرزندان بهر آزادی تو بر خاک افتان

بخانه بمان و نکن خدمت بیرحمان که ایزد جهنم دهدت به ارمغان

چماقداران را نباشد اندکی توان به گردانندگی چرخ ایران

تو غافل در خدمت زورگویان ریزی خون پاک نو جوانان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

ارتش و سپاهی پاسدار ایران نشاید که خیزند بر ایرانیان

حافظ جان ملت و خاک ایران چون کند تفنگ بر ملت نشان

ولایت فقیه که دهد چنین فرمان خود نباشد جز یکی از دشمنان

بیندیش اندکی و باز کن دو چشمان سردار کی دهد کشتار خودی فرمان

آنکه تو کشتی برادر و خواهران بروزی کشد ترا فرزندان

ما همه روییده ز خاک ایران سرچشمه گلمان گهربار گل نیاکان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان
حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

انقلاب اسلامی استقلال ایران پرداخته با خون بسی شهیدان

در جنگها و دسیسه های دشمنان پایدار بخون دلاور پاسداران

چو گلها برآیند ز گل شهیدان بر مزار جاودانه آن پردلان

بیاد آوریم ازخود گذشتگی شیران برای آزادی مرز و بوم ایران

انقلاب ربوده بدست مشتی رندان بریزد خون پورو دخت شهیدان

بنرمی پذیرش ظلم گمراه ابلهان نباشد زیبنده ملتی هشیارو قهرمان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

چنین گفت فردوسی بر جهانیان که دانش پژو بماند پرتوان

انقلابی که نپوید شیوه دانشمندان فرسوده گردد به اندکی زمان

ولایت فقیه خرفت و نادان بریزد خون دانش جویندگان

سراسر مملکت بدست ابلهان دانشجو کند دشمن دزدیده ایران

گر ولایت فقیه گیرد الهام ز آسمان مهدی را چه سودی چشم براهان

شیعه را دوازده امام بوده بدوران ولایت فقیه دسیسه خود شیطان

ولایت فقیه نیست جز سایه شاهان در خباثت بدور از خدا و امامان

حریر آزادی گستریم سراسر خاک ایران همانا پیوندمان باشد او را نگهبان

From Khomeini to Neda

2009-06-29T19:25:00.000-07:00

آسمان ایران آشفته و گریان

ز سوز مرگ شیر دختری جوان

باران گریه سرزمین آزادگان

خونش را بشوید بسان مولیان

شود خونش روانه دشت و بیابان

زبهر آبیاری هامون و کوهستان

بهاران لالها بشکفند رقصان

بسرخی خون آن شاداب جوان

زگلش کوزه سازند کوزگران

وانگهی تزیینش کنند سرود سرایان

که بنگر ندا با ماست شاد و خندان

آسوده ز آزادی دیگر جوانان

I remember when I was saying “Marg bar Shah”, Death to King, when an officer kindly told me to go home. I think I was 5 or so. Later I heard quite a bit from my brother, whom I lost for his involvement with Mossaddegh’s movement for democracy and nationalizing oil.

As I was growing up, I was happy with the way the King was running the country. I almost forgot everything my brother had told me, until December of 1978, when I was doing my PhD in Colorado. Suddenly, I setup a short wave radio with amplifier and large speakers in auditorium. All Iranian students were there listening to the radio. We knew a big fight is going on and soon the radio will be taken over by the revolution. I think it was around 4 in the morning when we heard the announcement that the radio had fallen.

Deep in my heart I wanted a democracy, a system of government without any one self-appointed person having unlimited power for unlimited time. That is what I remembered my brother telling me about. So now, his wish had finally come true. I did not care anymore about how the Shah was running the country. We had earned what my brother sacrificed his life for.

I voted for Bani Sadr, and as soon as I earned my degree, I went back to Iran to serve. Well, is this what my brother was talking about? At the time Moussavi, as Prime Minister, was running the country and Khamenei was just the President.

The constitution was still under debate, in particular with regard to the notion of Supreme Leader. Somehow, bottles of votka and whisky were found in homes of relatives of grand ayatollahs, and some died due to heart attach, or something else. Mujahedin-e-Khalgh had put up a great fight against the regime, which is probably why the notion of Supreme Leader became acceptable.

I remember parents being taken for questioning when their children quoted them on something not quite along the lines of Imam (Khomeini). No one had the right to say anything beyond expressing his/her approval of the words of Imam. Actually, under the Shah you could not criticize the Shah, but the news outlets were always criticizing everyone else. Now, I could not even criticize the horrible actions of someone in the street because he was enforcing the words of Imam. Everyone associated with the regime seemed to be a representative of Imam, who was the Shadow of God on earth. So, what on earth was I?

After a few years I left Iran, and never looked back. I decided to read Khayyam, Ferdowsi, Haffez and forget about everything else. I was glad my brother did not live to see this, and I would take the pain for him. Over the years I sometimes thought about what actually happened, and why we got what we got.

Just before revolution, I recalled how American media were reeling the CIA’s role in destroying Mossaddegh, and putting the King back in power. At the time I felt that America was being nice for having done something bad in the past. How naïve of me! But note that the mullahs did not consider that interference with internal affairs in Iran. They were pleased with America’s help to transfer Khomeini to France, and help distribute his taped speeches in Iran.

Iranians genuinely gave their blood for a democracy, and for Khomeini as the leader who promised to let the people write their own constitution, and that he would not be part of the government. I must say, however, Khomeini was a holy person accepting help towards relieving Iran from monarchy. He would not have accepted any help in exchange for anything at all.

However, America was not trying to be nice. The Shah had announced his project for acquiring nuclear energy in order to reduce country’s dependence on oil. Already he had started steel factories, petrochemical plants and several other large projects. In particular, the number of universities in Iran was growing very fast. The only way to put a halt to all of this progress was to shake the country’s foundations and let them fight it for a few years. In the mean time, America could recruit its puppets for representatives, or even presidency.

Khomeini correctly sensed the conspiracy. But the solution he proposed would also violate the notion of democracy. Fighting the Great Satan with a Supreme Leader is only possible in fairy tales. Besides, in a fairy tale, the hero does not die until the happy ending of the story.

The notion of Supreme Leader is in total violation of human rights. For instance, when the Supreme Leader says women must cover their hair in public that becomes The Law. The interpretation of such laws is generally left vague. For instance, if the enforcer does not find a woman attractive to his taste, he may simply cut her hair in public and let her go. On the other hand, if he finds her attractive he may choose to detain her.

A Supreme Leader cannot possibly cover all corners of everything he says. He does not necessarily approve what enforcers do. The problem is in his power to speak the law without any debate with anyone at all, which entirely defies the whole meaning of democracy. When people have no say in the laws that govern them, it is no longer a democracy. Indeed, in this case the dictatorship has penetrated personal lives, beyond countrywide policies.

Neda was more than likely shot for wearing jeans. Obviously, she was not planning on being out of her car for too long. A moment of trying to get fresh air was all that was needed for an enforcer to spot her.

That is the problem with the notion of Supreme Leader. Your life is worthless. What matters are the words of the Supreme Leader, the Shadow of God on earth. The Leader enjoys his authority, and the enforcers take pleasure in carrying out their on-the-site judgments and getting paid for it. You simply exist so the Leader and the enforcer can have an amusing job. After all someone has to work so these people can get paid, very much like cattle that must graze so we can eat them.

I must say that the much greater majority of Iranians, including myself, want an Islamic Republic founded on a democracy derived from Islamic teachings. However, Iranians want a democracy guided by Islamic teachings. Enforceable laws are supposed to be made in a congress, not declared by a Supreme Leader. I certainly appreciate a cleric warning me about the other world. But I would like to make that choice for myself within the constraints of the laws derived from a democratic constitution.

You hear the regime speaking of a velvet revolution. Actually, no one was after changing anything. The reference to the velvet revolution is with regard to people’s right to vote, and have their votes counted. Basically, Khamenei is saying that, people can vote, but he reserves the right to appoint the president.

What Khamenei did not anticipate, however, was the reaction of masses to his divine words. Now, he has started a chain of reactions that will only end with the removal of the notion of Supreme Leader from the Islamic democracy. The sad part is that more Nedas will pay for it with their young blood.

Neda of Iran

2009-06-23T18:39:00.000-07:00

بیادبود ندای ایران، شیردختری که پس از پیروزی انقلاب بجمع ما پیوست تا با خون سرخ و برنای خود، بر رخ سیاه و ننگین خیابانهای تهران بنویسد

ندای ایران برباد رفته بشنو

فریاد بی صدای ندا را بشنو

بشکن دیوار بسیج و کمر پاسدار

برهان ندا را از ستم تفنگدار

فرزندان کورش و رستم و آرش

برآرند خامنه ای را به رتبه خش

احمدی نژاد پایبوس حیله گر

باز گردد به بار کشی بسان خر

ایران پایگاه شاعران و آزادگانست

سرزمین گل و شعر و داشمندانست

اسارت در سرزمین پاک آگاهان

بشکند به بازوی پر زور جوانان

چو ایران نباشد تن من مباد

بدین بوم و بر زنده یک تن مباد

Around the time that Neda (of Iran) was born, I left Iran and never looked back. I saw two conflicting choices for my children: become a Basiji or fight them. I decided to give my children a few other choices. In what follows, please do not confuse a mullah with the Grand Ayatollah Montazeri (my respects).

From the outset it became clear that the mullahs have changed the course of revolution that Iranians earned by coloring the streets of Iran to the Mullah Revolution. The mere fact that a supreme leader will decide on everything was an obvious deviation from the true purpose of revolution for freedom from dictatorship.

I left Iran knowing that this time in Iran’s history the mullahs are equipped with modern means of killing and detecting the slightest disturbance against their authority. Furthermore, a mullah will force youngsters to appear on TV lying about the reasons for their arrest, and then will execute them.

A mullah will never let go of someone, who might apparently have threatened his authority in any form or fashion. A mullah speaks the words of God, and anyone opposing him is opposing God Almighty himself. Last but not the least is the fact that the God of mullahs wants such nuisances to be delivered to him immediately for further punishment in Hell.

One thing that the world may not see through is the degree of viciousness of a mullah. Khamenei will be more than happy to hear a huge number, such as one million educated students were executed. He will gladly replace them with one million Basiji from far reaches of the country.

Essentially, it is futile to go college and get the proper education without first going to a mullah school and becoming enlightened. Without mullah education, the college education will result in what everyone saw happen to Neda (of Iran), though she actually went through proper Islamic teachings (as apart from mullah teachings).

Eventually Iranians will take their country back, but not by pouring into streets. Sooner or later they will figure ways to eliminate the Basijis without being caught It will take a long time but Iran will not forget its Call (Neda) for freedom.

For Iranians around the world, the situation is quite similar to what it has been for the Jews. They have no country, except that the countries they are in are not harming them in any way. There is a promised land, called Iran, but they are not allowed in their land. So, the question is whether the entire resources outside of Iran can somehow come together in liberating their country. Obviously, those trapped inside are more like the Palestinians. They throw a rock and get a few bullets in return.

A spark like what happened recently could have been turned into huge flames to burn mullahs to ashes, only if you were ready for it. All we can do now is to shed tears to wash the blood of our youngsters away into oblivion. I know you all want to do more than just weep. So, combine your resources. In time you will find the right window.

The world speaks of international laws, or at least some universal laws. Many countries have denounced Iran’s actions against its own people. Yet, every such country holds billions of dollars of the mullahs in their banks. There is no international law that says, deposits from officials of countries that violate international laws are illegal. In particular, Swiss can simply ignore such a law by claiming neutrality. Thus, all the billions will travel from all other countries to Swiss, the wrongly glorified safe haven of drug dealers, dictators and criminals.

The necessary condition for a movement to succeed is the existence of a clearly visible leader who eloquently expresses the desires of the people making up the movement. From what we have seen, the mullahs will eliminate anyone who may even seem to resemble a leader at some time into the future. That is why I speak of a leader outside of the borders of Iran.

We have all these researchers, Nobel Prize winner, lawyers, poets and on and on outside of Iran. Instead of trying a failed agenda, such as King or Mujahedin, why not put down a well-thought constitution that gives the power to the people, not the leader who will lead the movement.

Let us help our kids because we put them in the situation that they are in now. Somehow, we are responsible for the generation of our youngsters that have seen nothing beyond what Khomeini inserted in our constitution.

I remember the disagreement with the notion of Vellayate Faghih (Supreme Leader) between Khomeini and the ayatollahs of the time, in particular Ayatollah Sharriatmadari. There is no such thing as Supreme Leader in Islam. There are Marja for people to follow someone’s teachings, as that is necessary after all. Obviously, the lawmakers should seek the advise of an assembly of Marja in order to ensure that their laws are not in conflict with Islamic Laws.

Given the wealth of medium for communication outside of Iran, we should be able to bring ourselves closer together (inside and outside of Iran), and put together a decent constitution. We have respectable Marja outside of Iran for verification of consistency of the constitution with Islamic Laws. I have no reason to believe that Islam is against democracy, and a government of the people, by their elected officials.

This whole process would be in vacuum unless there is a direct connection with the people inside Iran. Do not expect to suddenly impose yourself as a movement to Iranians within and be accepted just like that. On the other hand, this must be done in such a way to avoid any loss of life. The intent is to liberate them, not to sacrifice them for our sacred goals. Nonetheless, without a good knowledge of awareness inside Iran, any external activity is just a dream that may cost more lives of our youths. We have lost enough of them already.

For several days I have been seeking and reading news about Iran. I confess I am lost, depressed, and I have lost my morale and my momentum with it. Every note or article is followed by conflicting comments and is disputed in various ways. In most cases I can tell the comments by paid agents due to their shallowness. Nevertheless, this is all isolated and unrelated war of words that have no effect towards what the mullahs did and are doing to our youths. Where is this going? Anywhere at all?

There is all this sympathy all around the world, and after a while it will dissipate just as the lives of our children did. I know there is enough power outside of Iran to force the mullahs step aside and submit to a democracy without Supreme Leader. Sadly there is no unity to use these resources. Everyone either wants to be the leader, or assumes others are acting on self-interest. Thus, the mullahs win, and our children will continue to lose their lives.

While we do not even have a unity, the mullahs have the money, and the guns. It is hopeless, indeed very hopeless for our intelligent children trapped inside Iran. There is a lot of noble activity to preserve Iranian Culture and Poetry. That is as it should be. Perhaps there is more that can be done. We will never know what that is until we talk to one another.

Necessarily, the goal of the unity must be an Islamic Republic Democracy with a clear constitution, and without the notion of Supreme Leader. The Islamic part is necessary to guarantee that the constitution is based on teachings of Islam, such as all men/woman are created equal, and that people’s votes are sacred. Injection of any other ideology into the constitution, such as communism will fail. We do not need to borrow from any ideology.

There must be many other better views. However, we will never converge to a unified view unless we talk to one another. Once there is a well-defined goal, it is more likely to generate energy and raise morale. It is absolutely necessary to mourn the death of our children. But then, we should not simply wait for the next bloodshed, so we can mourn again. What do you think?

بسی رنج بردیم در این سال سی

انقلاب زنده کنیم بدین دادرسی

بسیجی و چاقوکش و قمه بدستان

بگردند باز به جاروکشی بوستان

مشتی مغل زاده بی فکر و قلدر

نیابند شوق از فرهنگ پر ز در

ایران بوم ومرز خاکیست پر گهر

که خاکش بباشد سرچشمه هنر

دانشجویان رشید و پژوهشگر

فردای ایران را بباشند لشگر

چوب و چماق و قمه و خنجر

ابزار کسانیست ز عصر حجر

چو دانشجو را نباشد حق بیان

دگر رندان پر کنند ذهن جهان

احمدی نژاد را نباشد ذره ای خرد

کزین برتر اندیشه بر نگزرد

برد کشتی آنجا که خواهد خدای

و ر بدرد بتن جامه ناخدای

Java, reversed evolution

2009-06-15T09:48:00.000-07:00

Once again I was bombarded with statements like “Java is an unstoppable tsunami”. Having designed interpreted and compiled languages, used about a dozen languages for commercial products, studied and researched close to a hundred programming and specification languages that is not how I see things. This note presents one aspect of my view about Java.

A baby in uterus does not start out looking like a human and evolve backwards to a chimpanzee at the time of its birth. Nonetheless, in the uterus of programming, IBM can sell Smalltalk as a solution to Y2K and deliver its adopters straight to their bankruptcy. Leading technologies do not worry about the consequences of what they advertise and sell. Buyers must know what they are getting into.

In order to make the point clearer, consider starting with C++ as an improvement to C. The term improvement implies getting more without losing major capabilities. Now, start peeling off expressiveness one by one. First take the pointer and multiple-inheritance out and then drop enumeration, next discard templates, on and on, until you get Java. All that is needed is an innocent child to scream, “Why is the king naked”?

Having said that, Java has its uses. Libraries similar to Qt provide API in the context of an existing language, usually C++. These libraries strive to standardize commonalities among a few systems for purposes of source code portability. On the other hand, Java is a platform independent graphic library that uses a language of its own rather than depending on API in another language. This makes Java useful in several ways, but solutions for end-to-end enterprise problems are not among them. Here are a couple of recent uses of Java.

When an operating system, such as Android, is written in C, there must be sufficient support available in C in order to make a JVM. Yet, one finds all kinds of support for Java and none for C. The promoters of Android are hoping that a large population will engage in making the kind of applications one can create in Java. Once the momentum is built they can introduce serious end-to-end enterprise solutions in C before anyone else can beat them to it. Thus, in this scenario Java is used as a baiting stage. It makes little sense, if any, to put the entire power of a Linux-like operating system in the service of JVM, and Java applications.

Blackberry is effectively unknown outside the borders of America. The economic downfall made future enterprise sales within the country hopeless for RIM. RIM’s strategy was to use Java to encourage sales among younger generation. Many with the hope of making a few dollars per download would create amusing Java applications for the device. The strategy has resulted in a temporary spike in sales of devices.

Java portrays an interesting interpretation of the process of compilation. Generally, when the execution engine needs to be aware of names as provided by the programmer, we speak of interpretation. For a compiled language the execution engine does not use the actual names (identifiers) in a program. Otherwise, the execution of a virtual engine is not different from a hardware processor in its operation of fetch, decode and execute. In other words, the term interpretation does not refer to the execution cycle. Rather, it refers to what is executed by those cycles. At the front end, an interpreted language lacks a compilation phase known as linkage for resolving external symbol references. Java incorrectly pretends that remote linkage and compilation linkage phase are mutually exclusive.

Natural evolution may not necessarily retain all the good qualities. However, it is almost impossible to find any evolutionary path on any planet that evolves a human into a monkey, except The Planet of the Apes. Eiffel and C++, among other significant languages, were already mature programming languages when Java was hastily put together. Now after over a decade Java has not been able to incorporate at least one major concept, say invariants. Perhaps now you see the relevance of the title, reversed evolution.

Eclipse is a reasonable IDE. However, one can also make an IDE using Qt that will run on as many platforms as Eclipse does, except more efficiently than Eclipse. Moreover, IDE is a standalone application. Simply put, a platform independent graphic library is not sufficiently expressive as a medium for providing reliable solutions to complex distributed end-to-end enterprise problems. Making no distinction between Eiffel and Java is equivalent to making no distinction between Mozart and the monkey in the British Museum.

In search of nature of matter

2009-06-03T22:00:00.000-07:00

Looking for something that does not exist is a none-terminating process. The problem with the theory of matter is that it must exist as an individual particle. The particle may be as small as photon, or even the building block of photon. Nonetheless, the assumption that it does exist implies the existence of an entity, if not several kinds of entities.

There are a few issues associated with this assumption. First, how much, or how many of those particles exist, and why so many? Second, such a particle must be indivisible because it cannot be made of other forms of simpler particles. But how can something exist without being made of simpler entities? Note that there is a big difference between abstractions at a certain level, and the reality. We can start with the existence of matter, and retain all our theory even though the matter as we assume may not exist at all.

In mathematics, we can start with the empty set, and build the rest of mathematical notions. However, we must have a few rules, such as a set can contain elements. What is fascinating, though, is the fact that the entire collection of mathematical notions springs off of the empty set. The reason for this should be obvious. A notion that has parts must be defined in terms of simpler notions. The empty set has no parts, just as Euclid thought about a geometrical point.

The assumption of existence of smallest particle results in infinite recursion. The next question will then be, what is the smallest particle itself made of? The only way to end the infinite recursion is to come up with something similar to the empty set in mathematics. In the beginning there was only the existence. The existence has laws (properties, characteristics).

The simplest law that one can imagine is a distortion in existence. By that I mean, tiny areas of existence becoming denser than their surroundings. Obviously the term dense is not an accurate description because it implies the existence of matter. But I do not have a better term. Think of it as being stretched inwards. Imagine an area of existence, call it space where there seems to be nothing, and suddenly a number of infinitely small distortions appear like blinking stars. However, suddenly is an extremely relative term. The appearance of a distortion may take millions of years, and equal number of years for it to disappear.

What seems reasonable is to assume that each distortion surrounds itself with something similar to a black hole. Thus, two nearby distortions will attract one another in the same manner as two black holes would. But how can a part of existence break off and start moving? Does a black hole really move? If parts of existence move, what is the area between moving parts? After all, absolute lack of existence is incomprehensible. It seems more reasonable to assume that distortions, including black holes, move in a manner similar to sound waves.

There is no paradox in assuming only wave motions even when we see a car passing by. It does not take a lot of imagination to envisage a car move the same way, as a tiny distortion does, like waves in water. In particular, there is no paradox when we see an arrow pierce its target. Furthermore, it does not conflict with visible light and other forms of photons being thrown around with a certain rhythm.

In this view, there is no distinction between a tiny distortion that makes up a photon, and the largest black hole. A distortion is a property of existence and is probably of the same size in diameter, regardless. However, the surrounding perimeter of a distortion depends on its density (inward stretch). It is that density that appears as mass to us.

We will postpone a discussion of bipolar distortions, like magnetic fields, to another article. The distortion discussed in this note is related to what we understand as gravity. It is the sense of gravity that gives birth to the feeling of mass. However, our perception is generally not an accurate portray of reality. It was not too long ago that we thought Atlas was holding the flat earth on his shoulders.

Digression

It took me a while to fruit, long after all the farmers that took care of me have been gone. I have a feeling they knew the outcome all too well. They had no expectation from my prosperity. They only meant that I fulfill my destiny by fighting my way through fate’s path of dirty tricks. They knew without fate’s treachery I would have wasted the energy they poured into me for seeking a short moment of comfort, known as lifetime.

In the desert of life I came across a few oases. Each time Bushes dried out the Trees, even those that I had planted. I wish to retreat to wilderness where everyone’s descendants have equal fate. Where the sons of smugglers do not enslave the sons of scientists by the very same means invented by their parents. Where one’s destiny is determined by fate alone, and not by the laws set by criminals of humanity.

End digression

Microsoft and the Law of Inheritance of Anomalies

2009-05-21T19:39:00.000-07:00

A few years back, the Computer of IEEE started with new staff of computer scientists and the first issue of the journal was filled with articles from well-established scientists. The one that I can recall for this writing was written by, N. Wirth the designer of Pascal programming language. One statement of the article was nicely decorated in the sidebar area. It said something like this: “There had not been so many defects in software until the graphic debugging facilities were invented”.

The implication is obvious. The question is, whether as much software was possible to write prior to the invention of modern debugging facilities? That article must have had the approval of referees, or at least the editor-in-chief. Evidently, they liked that statement so much that it had to be decorated so it would not be missed! After all, I still remember it.

During the time of Professor Wirth there were fewer software development shops, including his academic shop. Before that number could make a jump, modern software development facilities had to be invented. In addition, as tools and languages became better the size of programs increased exponentially. A lot of defects have nothing to do with debugging facilities because the facilities are not applicable (e.g. distributed software). Finally, a larger number of defects does not mean a higher ratio of defects relative to the number and the size of software.

The point of this article, however, is the Law of Inheritance of Anomalies. Consider using a class from a C++ third-party library. When calling some of the methods, you expect a certain member to be updated. It so happens that the member does not get updated consistently. Since C++ has no abstraction similar to class invariants of Z++, this type of inconsistencies is quite abundant in C++ software. Access to the entire library code does not make it feasible to fix the defect in the original code.

Under the above circumstances, one tries to guess via experimentation as to when the member does, and when it does not get updated. Based on that finding, the engineer will write code to work around the library defect. As it always happens, the inconsistency in the library code is actually random! Thus, the workaround does not work as expected, either. Now, your software has inherited the anomalies of the third party library, even with improved genes of your workarounds.

For Microsoft engineers, workaround is normal state of affairs. It all started with DOS, and ever since much of Microsoft’s work has been workarounds. Eventually the number of workarounds will exceed the size of crew that Microsoft is willing to have. Once this tipping point reaches, Microsoft will do the same to its shops as car companies did to their dealers. Perhaps Palm is a good case of abandoning an operating system that is plagued with inherited anomalies.

The context of this article is software. Nonetheless, one can see similar cases in politics. The anomalies planted by Reagan into our economy, as profitable as they were for his constituents, finally hurt millions that Reagan did not care about. In his words, “America is too big for small dreams”. The problem was that instead of removing the anomalies, they were inherited with workarounds, very much like what painkillers do, until they kill you altogether.

Reagan style of economic policy is a depressive form of communism in which the greater majority of the population lives at the mercy of a few that may find them useful for their profitability desires, what Reagan refers to as Big Dreams. The notion of communism is simply restricted to a much smaller elite group. This cannot possibly qualify as a definition of capitalism.

When the availability of jobs is primarily based on the profitability visions of uneducated rich, spending in education merely creates educated slaves. Reagan followers do not like the idea because it is hard to control educated slaves, as we saw in the last election.

Virtual Processes and Distributed Computing

2009-05-11T21:45:00.000-07:00

We begin by introducing the notion of a virtual process and then relate that to distributed computing.

An operating system manages its resources in order to serve the needs of it processes. The actual players are the processes, which use the available resources in order to accomplish the goals assigned to them. In this note we refer to processes created by an operating system as the real processes.

In computing, one frequently comes across the term virtual. For instance, I may be using multiple virtual screens mapped to a physical screen. Engineers are familiar with virtual memory, and many other kinds of virtual devices. The notion of virtual process is not common, however. Normally, one creates virtual instances of a physical entity. A process is an entity created by the operating system, therefore is it already virtual.

The physical reality of an entity should be viewed as a relative characteristic. At the level of an operating system, processes are quite real. Process are the entities that carry out the operations, therefore they do exist. A virtual process would be one that provides the illusion of being a process, without actually being a real process of the operating system.

The Z47 Processor begins as a real system process. However, Z++ applications start as processes of the Z47 Processor, and are therefore virtual processes. The Z47 processor, just like the underlying operating system, manages its own processes, including their execution time-slice. Thus, Z47 creates the illusion of real processes running on a device. Therefore, the processes of Z47 are relatively virtual processes.

Now we turn to distributed computing. In any model of distributed computing there will have to be more than one node. Distributed computing is of interest when the nodes have different computing powers and resources available to them. In other words, the nodes should be heterogeneous. The heterogeneity of nodes, however, does not imply the heterogeneity of communicating processes running on those nodes.

Now consider a Z47 Processor on each of these nodes. The virtual processes of Z47 communicate through the facilities of Z47. As far as a process is concerned, it is simply talking to just another peer process, which may happen to be running on another Z47 Processor on some other node. This model can be viewed as a generalization of the UNIX IPC to distributed computing.

The Z47 Processor is responsible for negotiating with the real operating system for allocating resources to its virtual processes. Thus, Z47 is a virtual operating system running along the side of the real operating system. In fact, Z47 is a distributed operating system because its processes are capable of communicating on multiple heterogeneous nodes as if they are all running on a single node.

The notion of a virtual process solves yet another interesting problem. Since a virtual process runs on a Z47 Processor, it should not have any problem to move to another Z47 Processor and continue its execution there. In fact, that is the case. This is known as strong mobility. Basically, a process goes to the waiting queue on one node, and gains its execution time-slice on another node. This is impossible to achieve with real processes. This form of distributed computing is usually referred to as Autonomous Agent technology.

Distributed Computing and Autonomous Agent provide interesting related readings.

The Nature of Simplicity

2009-05-02T19:46:00.000-07:00

As typing these words, and hearing the beautiful waves of creations of classical music, I am filled with appreciation for what my anonymous as well as immortal predecessors have handed over to me. May it be that I too will have something to hand over to my successors? Remembering friends of a few decades ago, or my heroes that I only read about, I realize that immortality can only exist in the form of memories, for so long as there can be memories. May it be that our species will survive the tyranny of our sub-intelligent greedy subset?

Turning to the topic of this note, the inherent complexity of software development is not open for debate. But one must differentiate between the natural complexity and the superficial one imposed by marketing strategies. Presently, the imposed complexity is greater in size and degree, and is simply taken for granted. Only a fraction of the imposed complexity is a plain consequence of lingering earlier attempts, more often due to marketing strategies.

The focus of Z++ research is the removal of the imposed form of complexity. The natural complexity is in fact simple and beautiful in the eyes of experts. After all, a mathematician firmly believes that mathematics is simple and beautiful. Beethoven must have thought of his music as simple and beautiful. If it were not simple for him, there would be no Fifth Symphony.

A brief digression is in order. Einstein believed that Mozart was a better composer than Beethoven. In his opinion, Mozart found the beauty naturally while Beethoven created his music. Thinking of the notion of gravity as created by Newton, and Einstein’s way of looking at it as a property of space, gives some hint as to what Einstein was trying to say.

It is unfortunate that Einstein chose a poor example in this particular case. Indeed, taking the example literally, it seem like Einstein is contradicting himself. After all relativity is not simpler than Newton’s approach. Beauty comes with underlying complexity that need not be visible beyond the beauty itself. It is hard to believe that Pele had an inspiration on the soccer field and was able to perform his bicycle kick without sufficient prior practice. It appears as if once his theory was demonstrated through actual observation, Einstein forgot all about the years of calculations that went into the one moment of his inspiration about the nature of gravity.

However, looking at how some people put things together in the name of invention, as Einstein did, there is a truth to be observed. Two people can have an inspiration for solving a particular problem. The beauty of their solution depends on their eagerness to acquire more knowledge in the area until they have found the most natural solution. That is how Beethoven, Pele and Newton created their beauty, and Einstein is no exception. Behind the skin of beauty hides all the years of fighting with the flesh of complexities.

In the context of this note, one can say that a simple solution for a complex problem must necessarily rest on a complex foundation. The beauty of the solution is in its being natural for the domain experts. Furthermore, much of the confusing complexity has been planted into the process of software development for gaining and locking market shares. The elimination of the planted complexity is a giant step towards simplifying software development.

Complexity is the inherent nature of simplicity. Without a sufficiently complex foundation, the simplicity of a process or tool will be lost to the complexity of its usage. The beauty of a tool for software development is in its simplicity without loss of generality, as well as extending the generality of previous tools.

Debugging distributed programs is not a simple task. Suppose, we could test all distributed components of a piece of software on one single physical machine as if each component was running on its own remote host. This would be beautiful if after the completion of testing we could send the software for actual use without changing any code. That is how it works in Z++. The beauty here lies in the fact that communication among distributed components is transparent in Z++ language. Thus, the Z++ approach is as simple as it possibly can be, and yet as general as it can ever be.

The point is that, simplicity becomes beautiful only when it automates sufficient complexity. That is the style of beauty of mathematics, except mathematical abstractions need no automation.

Software Development Context

2009-04-17T21:52:00.000-07:00

There is a lot of unfinished work waiting to be published. The engagement with porting the Z++ Visual IDE to Linux, in particular making Z47 Processor work with GTK+ has deprived me of a moment of useful thinking. The painful part is that, since Z++ is itself a system program, the context described in this article applies to its development. After all it has to be developed using C++.

Let us abuse the term context free, somewhat. For instance, we may thing of a C++ program as being context free. It only gains context when we interpret that program for a particular application. In practice we actually wrote that program specifically for the particular application we are mapping it to.

The notion of context that I have in mind is different, though. Consider the fact that C++ is a standard. What that ideally means is that, if you wrote a C++ program, using compiler A, you can compile the same program, using compiler B with identical results. For a moment, assume that is actually the case so long as you can avoid a few things.

So now the question is, what are the few things that you should avoid so that your C++ program is seamlessly portable? Well, that is no less than half of your program, which uses such things as system calls, third-party libraries, SDK etc. The development context that I have in mind is that half that takes a list of acronyms to describe, things like MFC, JDBC, GTK+ and a few more. That is the context of your development because your software cannot be ported to another platform without changing its context.

Thus, even though one may assume C++ programs are portable, C++ applications are bound to their context. Since C++ is a system programming language, C++ applications cannot be separated from their context. That is how it should be for otherwise we would not have a reasonable system programming language for large system programs. The problem is not C++. Rather, the incorrect use of C++ for developing applications, as opposed to system programs, is the cause of unwieldy cost of maintenance.

What is wrong is using a system programming language for developing system-independent applications. This practice constrains the application with the heavy weight of unnecessary context. Certainly, a device vendor loves to see applications developed by using their SDK so that they are tied up with their device. It is the software developer that has to make the right choice so he would not go down with the fall of the device. Applications developed in Z++ survive computing devices because they are context-free.

My tax money!

2009-02-20T20:08:00.000-08:00

By now everyone should know that the so-called ideology of the Gang Of Pests (GOP) is to serve a small percentage of the country’s population. Their services are provided through laws ensuring that their sponsors will continue to suck in almost the entire nation’s wealth, year after year.

However, legislatures are not the only charlatans protecting the real Pests of our nation. Recently, I am hearing a lot about “My Taxes” from talk show individuals attempting to elevate their rating, in particular by directing their attacks towards the stimulus plan. For instance, they make it appear as if homeowners between two others that are being foreclosed are actually paying into helping their neighbors.

Now, considering that 95 percent of nation will receive tax cuts under this administration, even an android can tell that he is not putting any money into helping his neighbors. If you are going to pay less tax, how is it that your hard-earned money is helping your neighbor? Can you understand this, really?

Paramount in GOP’s values is religion, specifically Christianity. The Great Teacher taught us about giving and forgiving. He told us to treat our neighbors like ourselves. And yet, you are screaming for your tax dollars helping your neighbors when in fact you are going to pay less in taxes. This contradictory performance is not even expected from a badly assembled android, and you consider yourself a human!

The sponsors of a talk show are interested in ratings so they can sell pajamas to you for the Valentine’s Day. Then, they want to keep the millions they make off of listeners like you. That is because they are not your neighbors, nor one of your countrymen. They are only interested in luring your income into their pockets, and keeping it all. Are you still thinking that trickle down is actually a theory?

If you are a person with strong faith, you already know that the poor are not poor because that is how God wants them to be. You know that because God teaches you to help the poor until poverty is eradicated. So, who would be interested in large populations of poor and needy? Like a lion in the wilderness, obviously this must be a person who intends to take advantage of your weaknesses and suck in your income. You are paying more in late fees, overdrafts and interests than you are paying taxes. So, who is draining your income? Is it the government that wants to help you with your health insurance, or the pests that plan to take advantage of your misfortunes?

You keep talking about freedom and having government out of your way. Very well, that is certainly a good idea. Now, what about car insurance? That is not a necessity like health insurance or energy. So in this case the government must step in and force you to obtain car insurance. That seems, and is in fact a good idea. But now, if you lose your insurance for 30 days due to lack of income, all insurance companies will require you to pay more than a thousand dollars for the next year before they set back your rate to where it was. This is the meaning of free market, not what you think it is supposed to be. This is why they say the government is the problem.

The pests of our nation want the government to find ways to force you to pay for their services, but beyond that they want to be free to make their own laws. In effect, they want the government, army and every social facility to be at their service. That is a small and useful government, not the one that provides a few basic social services. They prefer millions to die miserably, so they can take advantage of the ones that can struggle and pay for their services. Is this humane in any form of faith or lack of it for that matter?

I also hear a lot about the inefficiency of government. So let me put that in perspective. A company has a staff of well-paid employees that collect and prepare reports for the few decision makers at the top. Together, these take many millions in salary, and a lot more in bonuses and benefits. On the other hand the many thousands that get the actual work done must be content with bare necessities. That is the efficiency of their operation.

A lot of government waste comes from sponsored legislatures who spend much of the government money for the business and personal convenience of their sponsors. For instance keeping minimum wage low allows Wal-Mart have a huge percentage of its associates live off of government welfare programs. It is rather disgusting to see Wal-Mart taking in billions in profit and yet its store employees must live their lives using government money, which by the way is your tax money.

Wars of Imaginations

2009-02-09T18:15:00.000-08:00

In other articles I have discussed the importance of human imagination. Without imagination we would not have invented spears, bows and arrows for hunting, nor would we have discovered the basics of agriculture.

Growing up in a cultured society endows us with certain drivers for imagination. A major such driver is faith. For many, faith shapes their imaginative (biological) mechanism. Bach, Saint Augustine and Dante are a few examples. For many others imagination primarily works in its original form. Some examples are Archimedes, Pascal’s mechanical calculator, Kharazmi’s notion of decimal numerals and equation, Galileo, Newton and Leonardo da Vinci.

In this article I would like to discuss a form of evil imagination that appears in various disguised forms and is the best candidate for the fulfillment of prophecies of end of days. The driver for the evil imagination is quite well known. It is the maturity of the social mechanisms used that is interesting for research, with the hope of eliminating this plague from humanity and bringing peace to our species.

The driver for my imagination is based in actuality of our recent history. First note that if we allocate two trillion dollars for tax cuts to the group of interest to the Gang Of Pests, there would not even be a mention of the debt passed on to our children. That is because the entire money goes to their children, not ours. This fact is quite easy to substantiate. Remember their actor who with their help put us under trillions of dollars of debt, until President Clinton fixed it. Then again, their bush took us back to the actor’s time. Just how many more repetitions are necessary to unveil their evil imagination? Really?

One major function of imagination is to solve problems at hand. To solve a problem, we use our imagination to strategize. We then apply a series of tactics in order to achieve the long-term goals of the strategy. The GOP refers to the goals for the health of the society, as socialism. In effect, democracy has been turned into a powerful weapon for protecting the kings and their rights as they choose. Anything else is labeled socialism.

The Gang Of Pests, under the protection of laws of democracy, and for just two votes is fighting with its teeth and claws to consume our wealth. They want to keep our children as the pool of miserable slaves for their children. So, any attempt from us to save the future of our children is simply redistribution of wealth, because wealth must only go in their direction.

Thus, the evil strategy is continuous flow of wealth in the direction of the pests that have strangled our democracy. Their tactic is tax cut for their gang. Unless we break the vicious cycle of actors and bushes, we will continue to live miserably until their atrocity brings terminal wars to our planet. It is our constructive imagination versus their evil and destructive imagination. We have a much harder task ahead of us.

The GOP refers to its evil imagination as a philosophical difference. Now, a philosophy in this context is like faith, something that cannot be proven but directs our daily actions. Those who believe in a particular religion follow its teachings for salvation or whatever the religion teaches. The GOP philosophy, on the other hand, is as follows.

A tiny percentage of human population is entitled to effectively all the wealth. The rest must live under debt to this elite group for small wages so they might be able to pay interest for owning a house or a car. Since this elite group must control the wealth, the government is blocked from providing any form of service such as health, education and retirement. Any money spent in these areas is considered redistribution of wealth because the wealth belongs to them alone, and they must decide how to spend it.

Among the tactics to materialize this philosophy is heavy taxation of low-income families, and tax cuts for the elite group. When it comes to taxes they speak of actual dollars rather than percentages. Indeed, in some cases taxes stop at some point. For instance social security tax stops just below $100,000 income. You probably know that you pay half and your employer pays the other half of social security tax as part of payment to you. This is so the elite group does not have to pay into social security. After all social security is a social service and therefore paying into it will constitute a redistribution of wealth.

Just remember how raising one percent tax on one percent of the wealthiest in our country made the Clinton era prosperity possible. That prosperity, however, is not to the liking of the elite group, represented by the GOP. They prefer millions of slaves living their miserable lives serving the tiny percentage of the lords. By the way, does this view actually qualify as a philosophical point of view, or just a treacherous plan?

Well, if a person has the point of view of extracting wealth from a society solely in his direction, that person is not social and has no place in a society. It is fair for a person to become rich from his hard work, not from the hard work of millions by simply hiding behind the laws of democracy invented by the Gang Of Pests, and skirted as a philosophy difference. What philosophy?

Z++ task type

2009-02-06T15:45:00.000-08:00

The notion of type seems too complex to be accepted as a primitive, say like the notion of point in Euclidean geometry. The reality is that, type is only relatively complex and as such it is no more complex than point.

There are some similarities between the notion of type and other concepts. For instance, we define physical units in terms of a few selected ones, as in defining speed in terms of distance (length) and time. Similarly, we define new types in terms of a few pre-defined types. This similarity is only partial but a good basis for taking the notion of type as undefined.

Attempting to define the notion of type by identifying it as a set of literals and a set of methods does not take us anywhere either. Indeed, there are other concepts unique to automation (programming) that are used in defining new types. For instance, an instance of a Z++ task is created in a new thread. In this article we will also discuss the notions of task idler and task signal handlers. It therefore seems reasonable to accept the notion of type as a primitive concept of automation the same way that point is to geometry.

We shall refer to the mechanism used for defining new types as a type constructor. For instance class is a type constructor because it is a mechanism for telling a compiler how to create new instances of the type. Note that defining new types is apart from defining the notion of type itself. Useful and well-tested type construction mechanisms are indispensable for creating reliable software because the testing and verification of correctness of the complexity in creating and manipulating instances of a type is localized to the implementation of a compiler.

Task is a type constructor like class. Indeed, like Z++ class, tasks can have invariants and method constraints, and follow the same inheritance rules. Furthermore, task templates are defined exactly the same way as class templates are.

However, an instance of a task is endowed with its own thread. The creation and destruction of the thread associated with a task object is transparent. Moreover, when a task is derived from other tasks, or includes members that are of task type, each task base or task member is endowed with its own thread. Thus, one declaration may create a multi-threaded object, entirely transparent to user program.

A Z++ task object has a queue for responding to calls to its public methods. This means two things. First, a task object invokes one of its public methods at a time, in the order in which the requests arrived in its queue. Second, each time a task object receives its time slice, and if not busy executing a method, it checks its queue for new incoming requests.

When a task object finds its queue empty, instead of using its time slice in idle mode it passes control to the Z47 Processor so another thread can run. In Z++ it is possible to tell the task object to do something via its idler method instead of giving up its time slice. A task idler is a private method that cannot be called directly. The task object invokes its idler automatically. The notion of idler is useful for period checks, updates and other chores.

A task signal handler is a private method of a task object that is automatically invoked when its corresponding signal is generated. This provides a simple mechanism for responding to events. A task can have any number of signal handlers, but each handler must correspond to exactly one signal.

It is not hard to see that task type constructor hides a great deal of complexity behind its simple defining mechanism. Incidentally, the whole idea of research in automation is to cover useful complexity under the blanket of simplicity without loss of generality. This is in contrast to presenting a simple language that only covers simple situations. In the latter case, the actual complexity is passed on to the engineer.

The role of language in software development

2008-12-07T10:25:00.000-08:00

The capability to visualize a problem and its solution is fundamental. Visualization may be in the form of geometrical figures, algebraic formulas or musical notes. Taking geometry for an example, we can solve many problems entirely in our heads. However, when the number of lines and circles continues to grow, we use pencil and paper as an aid to our visualization mechanism in support of our imagination for arriving at a solution.

Visualization takes place in a language containing the abstractions of a particular domain. In software development the abstractions are notions such as loop, thread, class or file. Let us take C++ as the language. Now, let us take a look at some hypothetical application written for a few platforms, say Windows using MFC, Linux using GTK and say Palm using Metrowerks. After a short comparison we realize that C++ is essentially a shell. Perhaps more than half of each of these programs contains statements specific to their respective platforms. Indeed, engineers must visualize certain portions of each of these solutions quite differently.

Superficially, I think of the above situation as the Hugo Impedance Factor. Since Latin is the common shell for French and Italian, one would expect Hugo to be able to create a work similar to that of Dante in redoing his work in Italian.

The language C is indispensable in crafting anyone of the above operating systems. Similarly, C++ is indispensable in creating an initial set of sophisticated system tools for developing end-user applications. However, applications are of a different category in that their goal is to provide specific services to end-users. These services are well-understood notions independent of any particular system. The works of Hugo and Dante are masterpieces in their respective languages. On the other hand, Lobachevsky’s creation could be presented in Russian or French, just as he did.

Recapitulating, we need a language in order to visualize our solutions for end-user applications. Eventually, we will express our solution in that language for a machine. Nonetheless, we want other engineers to be able to understand our solution without the Hugo Impedance Factor. An application is similar to the work of Lobachevsky in that it is independent of the shell language used in expressing it. Therefore, we are able to take the next step, as Hilbert did, and present our solution in a universal language.

System tools are relatively small programs that facilitate the development of applications similar to the way that children build sophisticated toys from Lego pieces. The point here is that, end-user applications are generally large and complex. Indeed, modern enterprise applications are distributed and ideally should be able to utilize computing devices of all types and sizes. This ideal can only be achieved by, following Hilbert’s path and designing a universal abstract language.

Linguistic expressiveness should not be confused with library extensions. The language C is so close to the assembly language that allows the implementation of the notions of class, invariants and templates etc. However, the C compiler deals with the language C. A linguistic concept is orthogonal to the expressiveness of a language when an engineer can use the notion through a linguistic construct recognizable to its compiler. Basically, we have to differentiate between what can be implemented (computed), and how we express solutions. Libraries written in any given language do not introduce orthogonal extensions to its expressiveness (do not add a new dimension).

Considering the fact that applications, especially enterprise solutions, are complex, Java has little to offer beyond a class construct. For instance, there are no mechanisms similar to Eiffel’s invariants and constraints, nor C++ templates, just to mention a few. Solutions to modern applications require an expressive language providing a much richer set of linguistic abstractions. Simply adding more functions to an already huge library does not enhance the language.

The universal abstract programming language Z++ and its distributed operating system Z47 processor provide the most expressive medium for visualizing and developing complex solutions for modern demanding applications.

Government is the Problem, not the Solution

2008-10-04T22:16:00.000-07:00

This is simply another deception along the lines of trickle down theory. In fact, this one comes from the same person who also said “America is too big for Small Dreams”.

Since there is no objection to being a superpower in order to protect the interests of those who wish the government out of the way, I suppose the army is not considered part of the government. Neither is the police force because they are needed to protect those folks from within.

For these looters, government becomes a problem when it provides planning and basic services. Planning reduces problems on which they can feed. Services, on the other hand, result in competition and therefore reduction of profit. In particular, it becomes harder to claim that cutting taxes on the ridiculously rich folks will create jobs. Instead, they must actually pay better salaries and compensation to their employees for the sake of retention.

The idea behind the government being the problem is the fact that the whole purpose of a government is to take care of its entire population. Obviously, the Gang Of Pests cannot live in that kind of peaceful environment. They need a central dictatorship to make spontaneous decisions with regard to increased rate of profitability for the few in control. A democratic government ruled in accordance to its constitution is, controlled by its people. The latter scenario is precisely where the government becomes the problem. For the GOP the government is a tool to create a large pool of slaves so they can manipulate as desired.

Basically, what the title really means is that, the government is a problem when it gets in the way of absurd levels of profit, either by planning or by providing basic services such as health insurance. In particular, a universal health insurance will rescue the nation from being preys of profitability, due to unexpected misfortunes. The GOP wishes to retain all the best of the services of a nation for a few, and have all the others live entirely based on their luck. This strategy generates a large number of unlucky to feed upon, very much like vampires do. Obviously, many of the unlucky ones perish without being consumed entirely. As far as GOP is concerned, that is just the leftover that one throws in trash.

For the GOP, therefore, the role of an ideal government is to provide for the wolves in a variety of ways. For instance, working double shift at low wages is very much like being chased by wolves. Sooner or later, you are going to fall. This time the wolves of health insurance will have a feast. Should things not work as desired, the President himself will help them out with tax cuts. Even if that does not satisfy their quench for looting, well, we will just bail them out by donating our future income, in addition to the so-called incentives for research.

About my situation

My house will be on foreclosure sale on Tuesday October 7. It seems more appropriate to devote a few articles to current events before returning to science. Nonetheless, my intent is to dig into certain aspects of events, in more abstract terms.

I hope this article serves to indicate how many subtle deceptions are going around. These deceptions poison our minds in ways that we cannot think beyond who was boring, and who was a beautifully prepared tape, in a debate (Vice Presidential Debate).

Indeed, if you look at the context in which Reagan made his glorified deceptions, you will find that he was trying to kill a movement that was going in the opposite direction from profitability (such as Global Warming). It is due to his success in masking oppression, that the GOP adores Reagan, just as it hates President Clinton.

It seems like the criminals of humanity have found another version of “He is the guy to have a beer with”. They are hoping that she can be as effective as Reagan in hiding their criminal activities behind deceptions through her charm.

I have a feeling that America is beginning to step out of its dark ages as more Americans leave the republican base. Hopefully, we will have more choices in the future. Meanwhile democrats will do. I prefer to be a conservative in that I do not like sudden untested radical changes when it comes to managing a nation as complex as ours. But being conservative has nothing to do with being a republican.

Bailing out Wall Street or Main Street?

2008-10-01T21:32:00.000-07:00

As a homeless, I was able to see the news about senate’s vote of 74/25 in favor of the Bill. I also saw how the leaders were bragging about their hard work. I heard again about the garbage of the credit freeze and further loss of jobs. So, let us put all of this in perspective.

The topmost claim is that, banks are not giving credit to those who wish to buy homes, cars, and TVs etc. That means those businesses will have reduced income and you know the rest.

The reason that banks are not giving credit is of course bad mortgages that are not making payments. Thus, banks are not receiving the cash they need in order to extend credit. One would think then, the right think to do is to pay a few thousand dollars on behalf of those in foreclosure so the banks get their money and have the confidence for receiving payments for a few more months.

Instead, these idiots are taking the money from those in foreclosure and burying them further in debt. They are giving that money to the banks, so the banks can give credit to some of us who may still have jobs. Basically, they are taking money from us, giving it to them (who ever they are), so they will have the cash to let us borrow and pay them interest on our own money. Thus, they get the money and the interest to come from it. In return, we are allowed to borrow against our own money. If this is not insanity, I must be out of my mind.

The fundamentals of our economy are strong in that there are hundreds of millions of miserable folks like me who will live a painful life making sure a small percentage will have a great life with multiple houses and airplanes in our country, the amusement park for the rich and the connected.

It is so depressing to even write about this topic.

The Absolute Paradox, and Percolate up Theory

2008-09-26T00:52:00.000-07:00

The Existence Absolute

Consider the paradoxical statement, “There are no absolutes”. This reminds me of Russell’s Paradox, namely “The set that contains all sets”. The statement itself is an absolute, and yet it claims that there are no absolutes.

Let us remove the paradox by saying, “There is at least one absolute”. So now the question is whether there are some interesting cases of absoluteness. A simple one is “Every beginning has an end”. One interpretation of this absolute is that, the (fabric of) existence does not have a beginning. Thus, we shall refer to this absolute as The Existence Absolute.

What we perceive as particles, photons and electro-magnetic forces are distortions of existence. Clearly, (the fabric of) existence does not admit gaps, nor it can be made of parts. The question to answer is, how does existence generate distortions, sometimes resulting in the beginning of an entire universe. If we discover the answer to that prior to our extinction, we will probably call it The First Law of Existence.

Let us look for another absolute. What is the first product of self-awareness? A being becoming self-aware must be intelligent, which implies that the being is equipped with imagination. So, when imagination fails to find a way for actual immortality, what will it do? Perhaps think of soul, or waking up from a long sleep in an entirely new body. In other words, imagination will find an answer, which may be false like many of our scientific theories.

Anyway, our interest here is the following absolute, “The first philosophical product of self-awareness is immortality”. This is natural when we observe that any form of intelligent being must have some form of instinct for survival. Furthermore, the self-aware being must have a beginning (birth), and therefore will have an end (death).

In search of one more absolutes, we observe that intelligent beings live in societies. We then observe that, the notion of evil arises from a small percentage of anomalies within such societies. The majority of intelligent beings prefer some social traditions that every member of society observes for the sake of the society as a whole.

As a consequence of The Existence Absolute, anomalies must someday end. So the question is, whether the end of anomalies coincides with the extinction of the intelligent beings. We do not have any examples to work with, but all prophecies say that it is our end that terminates the existence of anomalies. Essentially that is what Armageddon means. But, does it have to be true? Perhaps there is a way to end anomalies for just a moment prior to our own end.

Percolate up Theory

With this introduction, let us take a look at the economic crisis we are in, and the bail out. Obviously, the top management of failing corporations took excessive amount of dollars as salaries and bonuses, essentially looting the capital of their companies. They exaggerated because they knew what was coming, just like we would throw as much as we can in the car when running away from a hurricane. Nonetheless, these are examples of anomolies of a society.

No one was given a loan unless they had a job. But what happens when you lose your job? In fact, what happens to businesses when a little paycheck that you get goes mostly for putting gas in your car, and paying your insurance premiums? For instance, you cut on your food, soap, toothpaste, clothing and vacations, thereby killing all such businesses, and enters the vicious cycle. Oil and insurance companies are another example of anomalies of a society.

How about solving the problem from bottom up for a change. Instead of applying the trickle down theory, let us try a new theory, namely “percolate up”. Taking myself as an example, I had to refinance my home two years in a row just to pay the property tax on it. Since I cannot get a job better than what pays $8 per hour, I have finally reached the point of being foreclosed. Each refinance added thousands of dollars to my loan and raised my interest rate. I would have paid for my house in full by 2012. Instead, after six years of being jobless, I am being foreclosed.

In my case, $20,000 will stop the foreclosure and will pay for one year of my mortgage payments. If this is paid directly to my lender, I can live in my house for one more year and hopefully find a good paying job. Let us take $20,000 as an average, and say there are one million folks like me. That means the government can pay 20 billions to the lenders, save one million people who are at no fault, and the money will percolate up to the failing corporations. It also guarantees one year of stability.

However, people like me are categorized as those who intentionally broke the laws, some kind of criminals. Therefore, even though this will solve the problem the economists will find a way to argue against it. After all why help me with their money as if I never paid taxes for over several decades of decent salaries. Indeed, $20,000 is less than taxes I paid six year ago before I lost my job. Even if it is a golden parachute, it is for one million people, and it also happens to revive the economy.

The feature of data-type misalignment

2008-09-16T23:26:00.000-07:00

In this article I would like to share some of the interesting issues that we ran into in the course of making Z47 Processor available for platforms powered by processors such as ARM, and Windows Mobile 6 platform.

Crafting a driver for a device is a low-level activity requiring specialized skills. A properly managed coherent sum of a large set of devices does not add up to an operating system. For an operating system, such a set is complemented with abstractions such as the notion of a process, and providing a logically designed set of system calls. One then starts with a bare operating system and promotes it to a platform by enhancing it with system programs for developing applications for that operating system. That was done with UNIX by the hands of graduate students of those days.

The goal of an operating system is to facilitate the development of applications for its platforms. However, in case of Windows the development of an application is equivalent to putting up a fight with Microsoft engineers. The number of combinations for each use of a system call and choices made in creating a window is vast, and in most cases they interfere. A particular system call may respond differently depending on what flags were set in the creation of the window receiving the call. That makes system calls context sensitive, depending on what flags are set or what style attributes are selected. To some extent this may be necessary, but not to the extent that we encountered.

Developing an application poses sufficient challenge. Engineers should not have to put up a fight with the mysteries planted by random choices made by the folks who maintain the code of their operating system. No wonder one needs to reboot the machine every so often. I really hope no one has considered Windows for developing critical applications.

Developing C++ (or C# for that matter) applications for Windows Mobile is like writing a driver in assembly code for a very complicated device (not to be confused with a complex device). It is good to know that Z++ essentially cushions the obscurity of Windows through its clear abstractions. So now let us look at ARM processor.

The purpose of a universal programming abstraction, such as Z++, is to allow complex data types to move around among computing devices without any knowledge or concern of the kinds of platforms involved. In such cases, one may use packed arrays as a low-level canonical data type representation. On each computing device then Z47 Processor provides the illusion of data-type abstractions at the Z++ language level. This is as it should be.

Restricting memory access to multiples of 2 or 4 reduces the complexity of a processor and is not of any consequence. A system compiler simply pads data without having to generate any extra code for handling such data. The problem begins when the location and type of data must match, as is done for ARM family of processors. For instance, a two-byte data must be located at addresses that are multiples of 2, while a four-byte data must be located at addresses that are multiples of 4. There is no reason for a processor to be aware of size of data it is trying to reach. Quite to the contrary, the address of a piece of data and its representation are two distinct notions.

If I can get around data-type misalignment by telling the compiler to generate the code to avoid it, I am consciously working around a defect. Do not insult my intelligence by telling me that I must redesign my program because I could not understand the notion of data abstraction. Data abstraction is not supposed to start at the level of a processor. Otherwise why don’t we just make object-oriented hardware processors?

What ARM is doing has nothing to do with the idea of RISC processors, unless RISC now means “CHEAP”. The fact that I can get around the defect is not a good reason to accept the defect as of any value. Generally, software is more expensive to develop. Besides, I have no desire to drive cars of a century ago and start the engine manually. By contemporary standards, lack of a starter is an unacceptable defect regardless of the car’s price tag.

Selling a cheap design as a feature is nothing new. Actually we do that every day in politics. More to the point, IBM would love to sell COBOL by telling everyone that threading is a hazardous operation. But multi-threaded programs have earned sufficient reputation that makes that type of sale strategy impossible.

Java is still selling the idea that pointers must be avoided. Obviously, except at low-level system program, accessing locations directly and changing their values must be avoided. Thus, Z++ has, all the pointer capabilities of C++ except the ability to reach actual physical locations. Incidentally, Java is just a third-party library such as QT, presented in an awkward language, in which you also have to write a lot of your own libraries, in Java.

Let me digress a little bit and discuss pointers. In other articles, I have clarified the point that programming pointers are the equivalent of variables in mathematics. Consider the statements “Let n be an integer. Then …”. Basically, the statement means that, the result we are going to established holds for any integer. In the same vain, when we use a programming statement involving a pointer, we mean that the statement will correctly execute for all actual objects that are substituted for the pointer (by de-referencing the pointer). This is true so long as the type of the pointer and the objects match (with polymorphism in mind). In parallel, a mathematical assertion established for the variable n as an integer does not necessarily hold for a rational number. On the other hand, a result established for real numbers generally holds for rational numbers (polymorphism).

Just as the use of variables allows making more complex statements in mathematics, the use of pointers increases expressiveness. It is not a surprise that a more expressive language is more complex and may cause mistakes until the user learns it well. A high percentage of students have difficulty passing an elementary required course in mathematics. Many students pass calculus II (integration concepts and techniques) with a B or lower grade. It will be difficult for such student to manipulate pointers. But, should every one be entitled to software engineer?

Going back to ARM, developers are familiar with “data-type misalignment” crashes of their programs. The question is whether combining the notions of address and type of data is a consequence of the technology, or a blunder that is here to stay with us. It is more reasonable to assume the latter. Either way, an admission of the issue is more satisfying than selling it as a feature.

I find it odd that some people argue that developers must do better in designing their code when even a simple double indirection fails, limiting the use of pointers. Is this advice for low-level programming devices, or for writing Z++ applications? The point is that, a processor should not interfere with notions beyond its scope, such as data types.

It is true that inexperienced engineers abuse pointer casting. Pointer casting eliminates compilation errors, which is taken to mean that the program is correct. Sometimes you find experienced engineers using an untagged union representing a variety of unrelated types. Nonetheless, it is not the role or responsibility of a hardware processor to educate engineers. Such education must come from academia.

Among many correct and necessary uses of pointer casting is the one I mentioned earlier, namely packed arrays. Any traveler knows the reason for carrying a suitcase. In the same vain, we need a canonical data representation for sending data over to remote destinations. A canonical representation by it very meaning cannot be of a high-level form, such a class, or even a double or an integer, because it is meant to represent them all. Unpacking canonical representations will probably involve double indirection, and at times even triple indirection. Actually, the ARM defect caused a lot more workaround than the one case I have mentioned here.

Democracy, end of social evolution

2008-08-16T15:16:00.000-07:00

Speaking against our implementation of democracy should not be viewed as being in favor of communism. I am only interested in understanding a few things. First, are laws of evolution applicable to our (mankind) social systems, or not? Second, given that evolution is applicable then why so much growing pain, suffering and exploitation? In other words, does evolution in this context mean more poverty for a higher percentage of mankind? In the latter case, how far will this go before it stabilizes to a fixed percentage of poor and a fixed ratio of wealth among various classes in a society?

The reason for the last question above is the model of democracy in our country. Every so often a small percentage of our nation, using the laws of democracy, legally rips off the entire nation and pulls inconceivable amount of wealth, making millions poor and homeless. This is in addition to regular everyday highway robbery as their continuous source of income. All of this is happening in a country that claims to be the beacon of law and democracy.

What triggered the writing of this article was hearing the Olympic commentator throwing in the “American Dream” at the rate of at least once per minute, as if he was paid in accordance to the rate that he used the phrase. Among many others, he continually referred to our gymnastic head coach who is a Chinese. The translation of the notion of “American Dream” here is that the head coach has a job that provides health insurance, and can pay mortgage on his home, send his children to college, etc. Compared to this, the conclusion is that the China’s head coach is having a “Chinese Nightmare”. After all, everyone in his country has health insurance, and no one starves, and no child is left behind. Even worse, he is not free to vote for a corrupted representative who will occupy a seat in the senate regardless of his vote.

Perhaps the most fundamental principle of evolution is its ability to transfer genetic mutations and adaptations to the next generation. A characteristic of intelligence is its ability to transfer experiences on to the next generation. Initially we transferred our social ideals through primitive means like fairy tales and superstitions.

Confining our view to our own nation, just a short while ago we came up with a remarkable constitution. One would think that within an interval of two centuries genetic adaptations of our social life constrained by the constitution would have resulted in some measurable social progress. Somehow we keep going back to square one and starting over and over again, without any evidence of social evolution.

I do not consider taller buildings and airplanes as criteria for social evolution. Our social form of life is no different from the time of Romans, and before. It seems like evolution is somehow blocked, or in some cases reversed. Since natural laws should prevail, either evolution is not applicable to human societies, or some factors are forcing it behave abnormally. It is only logical to assume that the latter causes the former. The corollary is that, peacefully eliminating the impeding factors is the only means of allowing evolution to continue on its natural path. Aggressions, destruction and bloodshed have clearly proven to have negative effect as means of putting a nation on an evolutionary course.

Social evolution can only take place through communication. The extent of communication is vast covering education, public media and arts. However, the members of a society must also think of their nation as the vehicle of prosperity for their children and keep themselves actively involved.

A successful model of blocking a nation’s unity is Wal-Mart. In the name of “American Dream” you find a high percentage of employees with a single goal in mind, that someday they will become a salaried employee, gratefully serving Wal-Mart. There is no communication among employees concerning their future except what Wal-Mart has determined for them. Obviously, an educated American youngster will not be looking to Wal-Mart, starting by pushing carts, so someday he will become a salaried manager. So, you can easily guess how Wal-Mart provides the “American Dream” for its employees.

Now, take the Wal-Mart model and superimpose it on our constitution, and you will get our government. In particular, the migration of technological careers to other countries, and the flooding of our country with cheap engineers, is perpetrated by the lions in our senate. I can hear Obama paying his respect by claiming that such jobs would have migrated as if that is the law of nature. So senator, if I may ask, how come the same jobs are not moving from China or India into America? Is this a one-way evolutionary path, or is it the will of super-delegates who backed you? I am asking this knowing that I will actually vote for you.

Our nation is a big amusement park. There are a few who are enjoying the rides, and those who are selected to serve them well. The top-level servers are politicians who get the most of the “American Dream”. Some of us learn technical stuff to create the rides. Others learn office management, landscaping and other jobs that need education. We borrow the money for our education from the master so we can work for them. Finally, there are millions of us competing for jobs such as cleaning floors and bathrooms. If the masters choose to have their amusement park in another country, we all lose our jobs. It is therefore necessary to suffer so the masters are happy with the level of their profit. And that is the law of the land, and the practical meaning of the freedom advertised in our media. It is the masters that are free while we follow a predetermined path in fulfilling their desires.

There is no difference in physically forcing someone to perform labor, and depriving a person from basic needs so he can only survive by accepting the labor. Only if I could have health insurance, not starve and not worry about my child’s education, I would be free to choose. As things are, it is the employer who has the freedom of filling the position from any part of the world. Obviously, the rich guys from all over the world would be interested in investing in such a lawless society, with their true loyalty remaining with their own nation. Democracy is simply used as the opium of society to achieve this level of inhumane atrocity by our own elected politicians. How is this one nation?

Our species have clearly proven their creativity in crafting weapons from the beginning of time. Our lack of social progress will result in some of us building the ultimate weapon. When that comes, it will not be a violent act of terrorism. Rather, it will be the reaction of some of us fed up with our blocked social advances and put and end to it, once and for all.

We must be the most stupid form of intelligence in the universe, to use the medium of transfer of evolution for blocking it. Socially, we have only evolved to the extent to know how to use communication more effectively in retaining slavery. It should be clear that no form of surveillance could cover the activities of the population of miserable. This is not a prophecy. It is a plain statement of fact that will not be understood until it is too late. Accumulating agony will result in vengeance explosions that will not be contained by throwing a few bombs and putting up a few lies on the TVs.

Imagination and Visualization

2008-07-16T23:19:00.000-07:00

The dimension of curiosity is an instinctive and rather primitive survival mechanism. By primitive I mean less related to intelligence. However, imagination is a mechanism associated with intelligence. Furthermore, the dimension of imagination is independent of curiosity and is not an evolved form of it, despite the fact that we generally use them in conjunction to one another.

It is our imagination that enables us to wonder and theorize. Generally, we think of imagination as a mechanism for visualization through our sense of vision. On the other hand, we have Beethoven, Dante and Shakespeare to think about. In particular, a mathematician’s mental images are not limited to geometrical figures even though the sense of vision is the main tool for visualizing concepts and formulations. Obviously, a mathematician does not hear the sounds of mathematical notions.

How does a software engineer visualize? Software visualization comes as close to that of mathematics as theoretical physics. However, a physicist’s thinking is predominated with mathematical concepts such as derivative, gradient or an entire structure such as Hilbert Space (Quantum Mechanics). So, what type of concepts does a software engineer use in his/her thoughts?

Let me first emphasize that Beethoven must have remembered and thought about previous parts of, let us say his 5th Symphony, before adding a new segment to it. The point is that, Beethoven did not write the symphony by simply making a new line and forgetting about it, and then making another new line. He must have had some way of visualizing much of the entire work in order to make corrections to it. After all Beethoven could not have had his QA team test it for him.

Visualization in the form of thinking in terms of concepts requires language as a vehicle. A language could be the sounds of musical notes, the works of Michael Angelo, Leonardo da Vinci, or Shakespeare, a mathematician or a software engineer. In each case, what really matters is the level of maturity of the language. Perhaps mathematics is the best example for clarifying the point. Contemporary mathematics has a lot more notions and is much more expressive than the time of Euclid. We can model a much larger set of problems with more precision than olden days.

Software development has accumulated a large set of notions. In this note, we are primarily interested in the domain of applications as opposed to system specific programs. By notions I mean to say that the concepts are independent of any particular physical device (excluding user interactions). Furthermore, applications are abstractions modeling automation problems, such as insurance industry. In particular, an insurance analyst does not think in terms of Windows, Linux or whatever else. The modeling of an insurance problem for purposes of automation, accordingly, should only involve software abstraction within a language and independent of any system specific code. When using mathematics for modeling we do not think of theorems that only hold on a particular platform.

One criterion for measuring the level of maturity of a programming language for developing software is its closure. A language that needs help from a platform is not closed. In particular, system calls are gaps in the level of maturity of an abstract language.

A closed language without sufficient abstractions is not mature either. A huge library contributed by user community only increases the chaos to the time before Euclid. It is hard, if not impossible to think (visualize) in terms of library API (application programming interface). Libraries have all types of uses, but replacing linguistic notions is not one of them. Imagine Shakespeare using a small vocabulary, and describing the rest of his vocabulary with a paragraph per word. Ignoring the loss of beauty, just how readable would his work be? Would we be talking about it today?

By definition, libraries cannot increase the degree of abstractions supported by a programming language. The addition of a useful notion, such invariant, constraint or resumption from exception, must be orthogonal to the rest of the language in order to elevate the level of language for visualization. Libraries increase the utility of a language in the same dimension as the language because their additions to the language cannot be orthogonal to the rest of the language.

When using trigonometry I see the entire process of reducing an expression to another (as in establishing a trigonometric identity). This happens in other areas such as transformations in symbolic integration. On the other hand, when dealing with a geometrical problem I know I visualize circles, tangents etc. Perhaps the most interesting of these for our purposes is when I see (somehow) theorems and logical deductions in an abstract setting (take Banach Space as an example). Here, the visualization is mostly in terms of a spoken language. In fact, I can actually express my thoughts to another mathematician without pencil and paper.

Consider the notions of component-orientation and autonomous agents. In a manner analogous to mathematical notions of derivative and integral, these are abstractions that we need in order to model automation problems. We must be able to visualize our solutions within a language that has sufficiently evolved by automating such notions. If I think in terms of differentiation (requiring the notion of continuity) but try to solve my problem within the notions of algebra (discrete mathematics) my abstract model will not be a good approximation to the reality.

Perhaps someday engineers will visualize their solutions in Z++. Until then, they will have to implement their solution for calculus problems, in algebra.

On July 21 my first grandchild will be born. I neither know the gender, nor the name. All the same, this is the only gift that grandfather can afford. This article is devoted to my grandchild to be born to my eldest son, Payam.

Dr. Z.

Fourth of July reflections

2008-07-12T14:30:00.001-07:00

It is fourth of July and I am taking a smoking break at WalMart. I enlisted as one of their slaves (AKA associates) two years ago starting with pushing carts in their parking lot for some seven months. Now I am stocking, cleaning floors and unloading trucks. In what follows, read WalMart as Corporate America.

While smoking I see a cart-pusher chasing carts. I remember the days I was pushing carts, at the age of 60 and with one Ph.D. per arm. Soon, my few minutes of break per every two hours are over and I head back. As I return to the bins to load a cart with cat litter for stocking, Rob passes by, expressing his joy for finally seeing the sunlight through the roof. It had been cloudy all day. Without thinking, I said to him that he had to leave the building in order to see the true sunlight. Then I thought to myself, where exactly do the walls of WalMart end? Is there really a place where the buffalos roam and the skies are not cloudy all day?

While WalMart (Exxon, etc) is making billions in profits our nation is drowning in trillions of debt to foreign countries. The nation’s debt will be paid by, our children while Waltons and Bushes will have their lions make laws so their children will profit even from those payments. Ted Koppel of ABC News concludes that the tall buildings in China are the result of corruption. What he does not say is the fact that we have evolved corruption to our legislative power thereby legalizing corruption altogether.

As slaves, we are not lashed and kicked anymore because the lions of senate make sure there is a healthy flow of younger slaves to replace us. Instead, we are courteously sent to homelessness and bitter life in accordance to the laws that protect our rights to die free in misery. Those are our laws, are they not?

A system that is based upon profitability from miseries of its people, by instinct will make laws to seek opportunities that result from creating such miseries. It will not tolerate waiting for miseries to happen, or participate in remedial operations. Bush’s stupidity simply revealed the true nature of the system to just a few more people.

Our multinational corporations are seeking centralized globalization hiding behind the mussels of a superpower. This form of takeover globalization should not be confused with cooperative and distributed globalization. The centralized globalization sought by our corporations is not cooperative and will eventually bring about the third world war. It is hard to imagine the whole world controlled by corrupted democratic laws made to suit the needs of a few. So far they have done quite well within the borders of our country.

These corporations have very little concern for terrorist attacks. After all, a terrorist can only cause collateral damage. The monetary loss to corporations will be paid by our taxes. Those of us who lose their lives can be replenished with new slaves from all over the world. Basically, we are the pawns of a game of chess, on a treacherous chessboard played by corporations, filled with writings such as, freedom, democracy and trickle-down theory.

The republican rule of having values for their families at the cost of oppressively exploiting the families of the nation is just the blossoming of the faded glory of South Carolina at a much bigger scale, headed for enslaving the world by a few ruling families. Keep in mind that Bush just became the President and the lawmakers have been there since Bush was a teenager. The real thieves are simply hiding behind Bush’s graphic atrocities.

It makes little sense for a wise creator to destroy His creation and judge them in a different form of existence. Armageddon is simply the cleansing of humanity from artificial privileges of nobility. There are no birth privileges other than being born a human, a monkey or a fly. Bushes are no more privileged than victims of Katrina just as Waltons are no more privileged than their employees.

Our ancestors started out with simple forms of social life such as tribes. These primitive forms became the building blocks of civilization. It is hard to imagine that those who carried a civilization on their shoulders, like farmers and professionals, had the time to dream about extending their jurisdiction. Such dreams occur to useless pests who have nothing else to do but to dream. Thus, civilization provided the opportunity for pests to take it hostage for fulfilling their destructive dreams.

A system in which a small percentage controls the slavery lives of the entire nation cannot be democratic. Rather, it is a multi-dictatorship in which the dictators are in constant fight for more profit, while they all agree with oppressive laws made and protected by their lions in our legislative branch.

Jesus was not crucified for going against Romans. Rather His spiritual revolution was against the high priests who used God for the service of Romans so they could have control over masses and live better lives of their own. An intelligent social life will not tolerate the primitive pattern of predators, scavengers and herds of preys. Perhaps we can avoid the inevitable dramatic effects of this pattern by limiting the number of terms that our scavengers can be elected. Two millennia ago, high priest had a lifetime privilege of controlling the law. Our democracy has simply replaced the priests with a different type of scavengers.

It seems like, every morning Queens Walton and Bush go to the mirror and ask, “Mirror, mirror on the wall, Tell me who is the richest of all”. Now, that does not matter at all so long as the riches are not sought by manipulating the laws of our nation. It is absurd to work for forty hours each and every week, doing all types of harsh physical operations and with pain, only to be foreclosed because my income level has dropped so the Queens can take it as profit.

So now, at the age of 62, and years before my illusive mirage of retirement, I walk into the wilderness of homelessness. At least I will not be watching hot stories of poverty in other countries on our TV stations. Indeed I will be one of them without a story. I will live and die miserably in a well-hidden underworld where no one can film, or if they do, it will not reach any audience. This might be better than retiring and having to work for WalMart. Lawmakers must guarantee the Waltons with a huge supply of slaves from inside our nation, just as well as from outside.

July 10 is my birthday. I accept the gift of foreclosure from our scavenger lawmakers handed to me by our wicked President. Cry for thee, not for me.

Dr. Z.

Water, light and black hole

2008-05-28T15:04:00.000-07:00

Considering the amount of water on our planet, I sometimes wonder where was all this water when earth was a ball of fire? Was the atmosphere plain steam? So where did the steam come from? We are laughing at the theory that Atlas held the earth on his shoulders. Would the future laugh at us, assuming of course there is a future in our fate?

We know light bends and slows down when it enters a thicker layer, such as water. For a moment imagine a long rectangular pool with onion-like layers starting with water and getting thicker as we reach the other end of the pool. Let us say the thickest layer at the other end is fluid tar and gets much thicker before we hit the end of pool.

Now create a wave at the end that starts with water. This wave will change its characteristics as it enters heavier layers. The height of wave may reduce and it will probably move slower. By the time it reaches the tar the wave may be so small that we may hardly see it, and it will slowly diminish at the other end of tar without bouncing back.

If we imagine a body of mass to be a concentrated distortion in the fabric of existence, it will be easy to think of thinner layers surrounding it in the shape of onion layers as we move outwards. That is, as we move away from the center of the distortion the concentric spheres surrounding it will become thinner.

Now we may be able to explain why light bends as it passes close to our sun. The light simply hits a thicker layer. So, if there is a lot more of these layers that get thicker as in our pool example, the light may bend so much that it may reach the center of distortion where it will diminish.

Perhaps that is what is happening when light reaches a black hole. As we know, the light slows down and it does not bounce off the black hole.

I would like to finish with a comment about all these recent books on democracy and the lies of the evil occupant of the White House. I am the actual player in the arena of the miseries emitting from a strangled democracy. What do I gain from reading your books about my stolen peace and the prosperous life that I had before Bush robbed the control of the White House? Can you punish him and get me back on track? Otherwise I knew it all too well before you saw the opportunity to make money with your book. You can just put your ideas in a blog for free, as I have been doing.

Now, if you are proposing a theory that may solve the problem of thieves and burglars robbing the Senate, the House and the White House, your book is of value. But then, you must stand up to well-paid scientists who are still trying to prove that trickle down is a theory but that global warming is a myth. Just about anyone can solve the problems we are facing. Unfortunately, the robbers have stolen so much that we are no more than enslaved players of their dreams of profitability and control. That is why President Clinton will not be allowed to return to the White House.

The omnipotence paradox

2008-05-15T21:48:00.000-07:00

This is also posted at War Against Poverty

In previous blogs I have argued that our entire universe is just a particle in the limitless vastness of existence. The view of infinite (number of) universes implies that universes are affected by other universes, and may even collide into one another. More interesting is the notion of parallel universes, though unimaginably far apart.

The main point of the argument is the lack of gaps, which should not be confused with vacuum or void. Lack of gap is equivalent to continuity of existence. The argument is that, if we allow for gaps as areas where nothing exists, such gaps will eventually separate the tiniest particles to ineffective mutual distances.

There is nothing wrong with the view that our universe is made up of a few kinds of fundamental particles. However, it does beg the question as to why these types of particles, and why so many of each kind. Note that indivisibility implies that the number of each kind of particles is fixed.

Perhaps the existence is continuous, and fundamental particles are distortions of the fabric of existence. As such, other universes could be made up of other types of fundamental particles, obeying different laws of physics. Furthermore, if the initial particle (mass, black hole) that is now our universe was just a condensation of fabric of existence, its sudden expansion to any size (big bang inflation) is quite logical.

The reason for this reference to previous blogs is to illustrate that omnipotence is paradoxical, not just relatively paradoxical. It is true that what cannot be done in one universe could be happening in another universe. Nonetheless, the possibility of causing something to happen is constrained by the physical actuality.

Consider the statement “God can do something that He cannot undo”. Assigning the logical truth-value or false-value to this statement puts a restriction on omnipotence. This implies that there are things that cannot be done, or that, not everything is possible in any given scenario of reality. A simple way of seeing the omnipotence paradox is as follows. God can do anything, and therefore He can do something, which He cannot undo.

There is a disturbing conclusion that can be drawn from the preceding observation. It implies that there are things that cannot be done, which is why God needs our military assistance in fulfilling some of His promises. In many cases we compromise with a load of future vengeance, or until we are strong enough to force a better deal. Basically, we are accepting the omnipotence paradox and admitting that God needs our military assistance in fulfilling some of His promises. Considering the fact that we regard God as absolute perfection, the question becomes, why would God make promises that He could not fulfill peacefully? The Creator gave us intelligence, how we have chosen to use it is the work of Devil.

Back in the seventies, the young and intelligent President Jimmy Carter, was manipulated by his director of CIA, George Bush. The President was persuaded that the Shah of Iran would eventually make a nuclear bomb. At the time the Shah had established dozens of universities in all corners of the country. Iran’s exports to Asia were rising rapidly and the final stage was the petrochemical plant, and achieving nuclear energy. The last two, however, were a threat to EXXON. Mr. Bush preferred something like Arabia of Mr. Saudi and his royal family. However, there was no way to fool the American’s with the idea that the Shah is after the nuclear bomb to hurt Israel.

President Jimmy Cater in his visit to Iran stated that, “Under the Shah, Iran is the island of stability”. One wonders just what happened a few months later. I recall the starting incident in my hometown in Abadan that fueled the Iran’s revolution. At a peak time with the Rex theater filled with over 400 people, its doors were blocked from outside and the theater was set to fire burning 400 people alive. This was beautifully blamed on the Shah, all over the country. You know the rest.

Carter had learned his lesson and was not cooperative, so Mr. Bush needed to get to the White House in order to achieve his Big dreams. He chose an actor to hide behind and created the hostage crisis in Iran against Carter. Do you really believe that a bunch of students, without the help of CIA took over the American embassy in Tehran? Just how did these students know how to secure a huge stretch of land with many buildings, within minutes? The takeover was a very well planned operation just as was the incident that occurred during the hostage rescue operation.

And now, a few decades later, George Bush the son celebrated his daughter’s marriage. I wish the young lady a long happy life filled with blessings. However, I expected a word from the Commander in Chief who has sent thousands of our youngsters to their death. Perhaps a moment, and a few words thanking their soul for their ultimate sacrifices. Alas our actions reflect our hearts’ contents. America is the land of opportunity for Big dreams that require millions of miserable slaves who do not deserve a word that may stain the moment of pleasure achieved through their sacrifices.

We need to revisit the laws of evolution, in particular “The Survival of the Fit”. When it comes to our species, the law becomes, “The Survival of the Liars”. The bushes are privileged, and the trees are for pleasurable consumption. Thus, our speech ability creates a paradox to evolution. Since the Liar’s Paradox is already taken (we used it for the omnipotence paradox), we will call this one, “The Paradox of the Survival of the Unfit”. The fit simply get killed in wars so the unfit can celebrate their children’s weddings.

Mapping Distributed Communicating Processes

2008-05-11T21:40:00.000-07:00

Introduction

In this article we will demonstrate that an end-to-end enterprise business automation cannot be mapped to a set of computing devices, such as desktops, servers, handheld and specialized devices based on individual operation systems, virtual machines and the client-server model.

The computing model for an end-to-end distributed automation of business functions is Distributed Communicating Processes (DCP). To illustrate the model, consider the UNIX operating system with regard to processes, threads and their communication (IPC). Suppose you write the entire enterprise software for the UNIX operating system, but that the processes and threads are created on a heterogeneous network of computing devices such as UNIX, Palm, and Windows etc.

In this view, the computing devices comprising the network are merely power sources for executing the software. On the other hand, engineers develop the software in the same vain as one writes C++ software for execution on a single UNIX box.

In this article, we will also illustrate how Z47 technology provides the infrastructure for developing device-free end-to-end distributed enterprise software. That is, Z47 is a mapping of DCP to a network of heterogeneous nodes.

DCP is an abstraction for a computation model, and as such it can only be discussed linguistically. In other words, a linguistic formalization, such as Z++, is the only means of materializing an abstract model. On the other hand, Z47 is a transparent mapping that powers the execution of software developed in Z++.

The Prevailing Problem

The main software of most large corporations is still written in COBOL, assembly and a large number of macros in a variety of macro languages. The desktops are generally used for a GUI presentation of the main programs. Often, desktop software is written in Visual BASIC, Java, C++ and so on.

Due to the lack of expressiveness of the languages for distributed computing, the desktop software is plagued with a large number of gluing technologies and third party libraries. In particular, each time a new technology is added to the ailing software, the complexity rises exponentially. This simply follows from the fact that the new technology needs to interact with many of the existing ones.

One scenario for eliminating unnecessary cost of maintenance would be to rewrite the software utilizing computing devices of all sizes and shapes, including laptops, desktops, servers and a variety of handheld devices. In this scenario applications that comprise the automation of enterprise functions become processes running on computing devices scattered all over. These processes will be interacting in complex ways, communicating, signaling while exceptions may be occurring at one end that need to be handled at some other end. Thus, the model for end-to-end enterprise automation is DCP.

The Mapping Problem

What we are going to make clear is that the DCP model cannot be mapped onto a set of standalone operating systems, languages based on virtual machines and the gluing technologies.

Consider a modern computing device powered by UNIX Operating System (OS). The functions of an OS relating to an application can be divided into two main categories. First, the OS acts as a sophisticated device deriver managing file system, keyboard and other input devices, as well as the screen and other output devices. This category is usually standardized through libraries such as C++ stream libraries.

The other category comprises of support for developing complex applications, including the creation of processes, threads, Inter-Process Communication (IPC) and signaling. The OS functions in this category are intimately bound to the OS. In fact some OS (particularly handheld devices) lack some of these functions. This is why C++ does not attempt to standardize this category. Instead, one utilizes OS system calls.

A successful, and limited form of distributed computing is modeled based on the ability of OS to send and receive data from external hosts. This is known as the client-server model. In this model, the server is started first, and clients connect to it for its specialized services. Let us see why the client-server model cannot directly support the DCP model.

In client-server model each server can become a client for another server. However, it is important to note that all servers must already exist so clients can connect to them. On the other hand, in DCP model parent processes recursively create new child processes and threads, rather than connecting to already existing servers.

The impossibility of mapping the DCP model follows from the fact that a process on one UNIX box cannot create a child process on another UNIX box and interact with it as it does on the same box. The problem becomes more visible when the other box is not UNIX. Note that all processes of an operating system have resources associated with them, and in particular each process receives a slice of time for its execution.

The Starting Point for a Solution

As far as an engineer is concerned, solutions for automating business functions are expressed in a language. Therefore, any approach to providing a DCP model would have to be top-down. First, there must be an expressive language for stating solutions, then an engine to provide the execution power for the statements in the language.

If we start with a virtual machine and design a language around it, our language will be bound to the capabilities of the virtual machine rather than the issues of DCP. Indeed, virtual machines suffer from the same problem as individual operating systems in that a process on one computing device cannot create a child process on another computing device. Since that is exactly what we need for the DCP model, it is easy to see why a bottom-up solution furnished by virtual machines is essentially useless.

Let us emphasize the main issue. A complex application on a single computing device needs to create child processes, threads and allow for interactions among them. In the same vain, an end-to-end enterprise application needs to create child processes and threads on any computing device while allowing for their interactions.

In short, an enterprise application must appear to an engineer as an application running on a single operating system. The computing devices scattered all over are to be viewed simply as sources of power, like batteries Furthermore, a distributed application need not be aware of the type of the devices, nor their being replaced. The latter means that an application should not even need a rebuild when we replace a device in the network.

The Technological Infrastructure

From what we have said so far, it should be clear that DCP model needs a true distributed operating system. Exactly what do we mean by a distributed operating system?

We mentioned earlier that an OS provides two main categories of services for applications. The file system and more generally IO devices can be dealt with via standardization. However, one cannot impose a standard on process and thread creation. Indeed, OS for many handheld devices is closer to a sophisticated device driver and lacks such notions. This creates an impasse for mapping a language for distributed computing on the OS of individual computing devices.

Furthermore, it should be clear now that a distributed operating system must allow for the creation of processes independent of the OS that controls a computing device. The processes of an OS controlling a computing device are bound to that OS. In other words, a distributed operating system must be self-contained in its services for creating processes, threads, IPC and other inter-process operations such as signaling.

Suppose such a self-contained OS is running on each computing device in a network. Then, a process can start off on one device, and create a child process on any other device because these are processes of the distributed OS. At language level the engineer will see the entire application executing on a single operating system while in fact child processes and threads of the application may be running on many different physical computing devices.

The Z47 processor is a self-contained distributed operating system that manages its own processes, threads and their interactions. The self-contained is actually the required criterion. For instance, an application running on Palm cannot create a process on a device running UNIX. Indeed, Palm OS is oblivious of the notion of process. However, an application written in the language Z++ becomes a process of Z47, not the underlying OS. Thus, a Z++ application for Palm can create Z47 child processes on Palm, Linux, Windows or any other OS controlling any device in the network.

The Z++ Language

As complex as it may be, C++ is the most expressive language. Nevertheless, C++ engineers need to fall back on system calls when developing applications. The first conclusion is that, C++ is a system programming language. This means that one develops an application for a particular OS powering a computing device. The second conclusion is that a language less expressive than C++ is not expressive enough for building complex applications thereby resulting in lengthy and hard to maintain programs.

Z++ evolves C++ to a language for distributed computing while enhancing the expressiveness of C++ even for building standalone applications. Z++ presents its linguistic constructs for distributed computing, as well as component-oriented development as minimal extensions to the notion of class. Furthermore, the actual details of creating processes and threads are abstracted away within the automation provided by the compiler.

A Z++ engineer sees the entire enterprise software as a set of components. Each Z++ component is also a standalone executable, and therefore a Z47 process. Since components can start on any computing device within the network, this satisfies the conditions for a true DCP model as needed for automating end-to-end enterprise business functions.

Beyond Distributed Computing

The ability of a Z47 process to create child processes on any computing device in a network provides the infrastructure for Distributed Communication Processes. However, Z47 processes are also capable of moving from one physical device to another.

The movement of a process can be illustrated as follows. A process loses its execution time-slice on one computing device, and later it receives its time-slice on a different computing device.

Z47 process movements are entirely transparent at Z++ language level except for telling the application where to go to, and when. The interpretation of process movement at application level is known as strong mobility. This is because the application travels to another device maintaining its entire state as if it had been executing all along on the device at which it arrived.

The automation of strong mobility paves the way for future intelligent software known as autonomous agents. A Z++ agent, for instance, can take off from Palm and land on a Linux box, and later travel to a Windows box, etc.

Is ignorance really bliss

2007-12-26T12:20:00.000-08:00

Finally, academia is recognizing the power of Z47 as a distributed operating system, and the expressiveness of Z++, in particular the simplicity of dealing with autonomous agents for solving serious problems such airport traffic control. So, I thought it was time to create a PHP extension in order to carry over the simplicity of Z++ to the domain of web browsers. This note is my impressions from initial work on PHP.

The language C furnishes a high level assembly language for Von Neumann architecture of stored programs. C is here to stay as a system programming language so long as we remain under the curse of Von Neumann. However, the simple macro mechanism of C preprocessor has been a great tool in creating all types of gluing languages, such as SQL, PHP and in fact C++. The only distinction with regard to C++ is that its compiler does the dirty work of defining macros. Furthermore, C++ compiler takes advantage of the expressiveness of C pointers thereby extending C to C with classes.

Nonetheless, all these extensions and gluing languages springing off of C are ultimately bound to C, and therefore to the hardware on which they are compiled. This is a consequence of a remarkable observation that a language must be intimately associated with an operating system in order to provide complete control in building applications for that operating system.

Thus, when you create an application in BASIC, Smalltalk, Java or C#, your application is limited to the capabilities of the virtual machines that power those languages. A virtual machine is ultimately bound to the services of the actual operating system for which it is built. This is the fundamental reason for variations in Java language, for instance. Nevertheless, a virtual machine provides a reasonable abstraction for groups of operating systems that are close enough.

The Z47 processor, on the other hand, is a distributed operating system in its own right. For instance, a Z47 process can go to the waiting queue on one node (hardware machine) and receive its slice of execution on a different node. In other words, a set of Z47 processors act as one distributed operating system.

The language Z++ is intimately associated with Z47 processor just as C is intimately associated with an operating system written in C, such as UNIX. Thus, Z++ furnishes a universal abstraction independent of the (hardware) operating systems. In this case ignorance is in fact bliss. The point being that, an engineer can solve all his/her problems without having to deal with specifics of any operating system, and entirely within the linguistic abstractions of Z++. It is only a consequence of intelligence to approximate details with universal abstractions.

However, ignorance is not always bliss. For instance, a cow in a herd is happy and has no clue that someday of our choosing it will be slaughtered for food. The question is whether it is possible to even sense happiness without intelligence? Feeling healthy and comfortable like a cow in a vast pasture is only necessary for happiness, but not sufficient. Thus, a president who is happy with extending his and his friends’ graze land is not intelligently happy. In particular, we all started out in caves and hunted together. No one was created as privileged or elite.

GWB effect and the real face of terrorism

2007-08-31T16:01:00.000-07:00

Starting September 2007, articles no related to Z++ abstract programming language will appear at anonymous-victims-of-history.html.

The events and examples mentioned in this note are intended for drawing conclusions related to sociology, and possibly finding solutions. A scientist should not drown himself (herself) in his research in an attempt to avoid hearing the voices of agony. The souls voicing their pain are innocents, like the scientist, under torture by criminals of humanity.

The Glide from White to Black (GWB), or from Light to Dark will be explained as a consequence of inner acquisition. Sociology is a science obscured by politics. Sociological theories are derived from observations of events that have already occurred. Thus, if the events are skirted with false outfits, theories derived from the observations of such events are inherently fraudulent and will inevitably recycle the unpleasant events of the past.

In simple words and taking mechanics as an example, future events will occur in accordance to the actual reality of laws of physics, independent of how we theorize the laws based on our perceptions. Thus, Global Warming will continue on its natural course independent of the 100-billion-dollar articles published by EXXON supported researchers.

By the way, we pay for the cost of false research through research incentives presented as birthday gifts from son to father. In other words, the nation is sucked to bankruptcy so oil companies will have the capital to support false research. This is an example of GWB effect where masses are looted and the trophies are distributed among supporters.

The GWB effect has frequently surfaced in the brief history of mankind. In every case the cause of this bizarre phenomenon has been a selfish sub-intelligent inheriting, and at times acquiring the power to control the resources of a relatively advanced nation.

Theoretically speaking, the purpose of electing a leader is to eliminate inheritance, as well as the acquisition of power. Prior to the process of election, acquisition was achieved by conquering a nation through war. Presently, we see two forms of acquisition, the inner and the outer methods.

The outer method of acquisition is relatively easy to control for an advanced nation. For instance, America can easily stop other countries from buying out its major technological industries. Considering the fact that America is a superpower, one can easily conclude that the source of all of our problems is the inner acquisition of this power for pursuing personal interests. Hence, we need to theorize ways that will make a democratic nation inner-acquisition resistant.

Once an inner acquisition takes place, it grows generating more cancerous cells inflicting extreme pain and agony to the infected nation. It only ends when the infected nation dies, and as Jesus puts it, “it is reborn” from within. The GWB effect of an inner acquisition is the real face of terrorism that destroys millions of lives just as plague did, except it is more prolonged and painful than plague.

So far in our history, the death of nations has either been terminal, or near-death experience. In the latter case, some cancerous cells remain floating around until they regain the power, and the cycle begins all over again.

Mankind needs to solve this problem so the rebirth acts more like pasteurization, and without creating chaos and destruction. Indeed, chaos and destruction will be caused by, the anomalies and the cancerous cells. The recent case of anthrax should serve as an example for future generations. It is ridiculous to even think that a superpower was unable to find the source of the anthrax attack, and now it is conveniently forgotten.

In a tightly controlled society with perpetrators fully protected by a strangled democracy and a corrupted media, the rebirth of a nation is simply a facelift for perpetrators. The death of the nation merely brings prolonged miseries to millions, while keeping the cancerous cells out of harms way.

Accordingly, any suggestion for pasteurization process will fail until we first solve the more fundamental problem of the relationship between a citizen and his nation. As things are, a child born to a citizen could have been born in any country for all that matters. What actually matters is the fact that somehow the child grows into an adult that can be used in profitable ways, and produce more children to replace him/her.

Essentially, vulture capitalists want to keep all the money they suck out of everyone, and continue to amuse themselves by catching us as fishes looking for our basic needs. Vulture capitalists know very well that once the control of our basic needs are taken away from them, it will be the people who decide, as a democracy is meant to be.

In simple and plain words, maintaining control over basic needs is not merely for profitability, as Michael Moore portrays. Citizens whose basic needs are not threatened are free and will control the course of political activities. Thus, the actual purpose of maintaining control of our basic needs is to take away our freedom. We are an enslaved nation permitted to express its sufferings.

Consider the following example of GWB effect. A scientist has a fixed income, and has probably borrowed some money to pay for health-related matters for his family. Suddenly, oil companies decide to tax him by raising their prices. The company that provides electricity to his house passes on their taxes to him. The latter is an indirect tax paid to the oil companies.

Now, with substantial reduction in scientist’s income, he has to make a choice between punishing his family for what he believes in, and selling his talent to the oil companies for research funds. This person is a hostage. He is not free to make his desired choice, but later he cannot contradict himself, either. Thus, the GWB effect has glided a fine person into darkness. We usually refer to this as selling one’s soul to the Devil.

Rudy Jiuliani, in his latest campaign, repeatedly asked, “They want to take away from you for the common good. Does that make sense”? He emphasized his plan for further tax cuts beyond what Mr. Bush has already accomplished, and ridiculed socialized medicine. Then, one of his supporters spoke in his defense, making the following amazing remarks.

“Last year I wrote a check for $200,000 for my employees’ 401K. If I am taxed for a $100,000 that money must come from somewhere. I will have to take it out of 401K contributions. Just like you have goals in life, I have my goals. So, if the government takes my profit away, I have to get it from elsewhere.”

That is so beautifully stated that speaks for itself. In effect, Mr. Jiuliani wants his masters to have total control over our minimum basic needs, and let them collect even more profit so perhaps they will be generous to throw their leftover to us. And we must fight like dogs to get a piece of the leftover. How can a nation terrorized to the lowest level of indecency claim to support a decent democracy?

Mr. Bloomberg prefers the oxymoron phrase “There is no free lunch” when referring to socialized basic needs, in particular socialized medicine. He means to imply that the services are provided freely, and right away adds that the people of those countries are heavily taxed. Now, even a monkey knows that no one can continue to receive social services without working a good portion of his/her life except Bloomberg et al, which is why the phrase is oxymoron.

By the way, are we really paying less tax than the countries that provide socialized medicine? Are other taxes such as social security considered when making that claim? How about the other half of social security paid by the employer? Note that, just because the employer is making the payment on your behalf does not mean that the employer is being benevolent. You are paying the employer’s half through your work. How about sales tax, property tax and whatever else tax? So I ask again, are we really paying less tax than other countries, or is it Mr. Bloomberg who is getting away with paying his fair share of taxes?

The term fairness in a social context means that the laws must treat citizens as equals in all respects. Now, calculate all types of taxes that you pay for a salary under $100,000. Make sure you consider all taxes that the employer is paying on your behalf. The employer is only paying such taxes because you are doing something profitable for him. Therefore, any tax paid on your behalf for the job you are performing is tax paid by you.

Finally, estimate other types of taxes, such as sales tax. You will see that you are taxed for well over half of your earnings. Next, make sure you understand that taxes paid by Mr. Bloomberg on you behalf, such as social security taxes, is not his tax. His earning is like yours, which are his salary and his profit. So, how is it that you pay more than half of your earning into tax, but he only pays a small fraction of it? Is this not a skewed version of social equality following from GWB effect?

What Caesar Bloomberg is really saying is the following.
“So long as I am pleased with your performance towards my profitability, I will let you have lunch. At any time of my choosing, without regard to your qualifications, experience, years of service and your children, I can deny you and your family from having lunch. Thus, make sure that I remain pleased at any cost to your health and your family. You solely exist to please me.”

Moving to the recent mortgage disaster, when a huge percentage of citizens are forcibly removed from their homes and left on their own along with their children, the country is under attack. As far back as we can tell from history, when citizens of a nation are under attack the ruling body takes immediate protective actions.

The fact that the attack emanates from within, it qualifies as an act of terrorism. The claim that a large percentage of population collectively made stupid decisions is unjustifiable. They simply did not anticipate the suction of funds by oil companies to support their false research, among other things. The repercussions of increase in gas prices suddenly reduced their income to the level of poverty, as another demonstration of GWB effect.

It is my observation that the GWB effect in America has reached its peak. The inner-acquisition of power by corporations has advanced to a point where it will continue to give itself appropriate facelifts for many years to come. We will be lured to pursue opportunities for financial freedom rather than paying attention to a plan for social life. Those of us who can make a difference, like scientists, are mostly taken hostage and will act contrary to their true beliefs. America will be flooded with new immigrants seeking jobs and displacing old timers towards profitability for corporations. My sorrow is for the masses that will live painfully miserable lives so a few can enjoy a pleasurable ride, for years to come.

The cost of freedom is high. The question is, who takes the burden of the cost and who benefits from the secured freedom. Perhaps if we shared the cost and the benefits of freedom, there would not be as many wars. Maybe we should focus on freedom from GWB effect as the actual source of terrorism.

May God bless America.

Science is God’s language

2007-08-26T00:54:00.000-07:00

The main argument in this article is that religion and evolution are not mutually exclusive.

Taking the scientific view, it is generally believed that water is a necessary condition for existence of life on a planet. Some scientists would rather say that the existence of water is a good indication that there might be life on a planet. That simply means that water is not a necessary condition for life to exist.

Let us start out at a point where life has already begun, accidentally or through creation. Only intelligent life forms are able to control environmental changes via technological means. So how do other living things on the same planet survive? The question of survival is significant with regard to the continued existence of life as a whole, not with regard to any particular species. Indeed, sudden climate changes have wiped out nations of our kind even in recent history.

While life is extremely fragile, perpetual change is the characteristic of environment and climate. Consequently, a form of life that is incapable of adaptation will cease to exist. Thus, evolution is a necessary condition for life to continue to exist, once it starts at all. Saying it differently, evolution is a mechanism built into life so it can adapt to the changes in its environment and to continue to exist. This conclusion applies to all forms of life that may have started on any planet.

The issue of dispute is not adaptations resulting from short repetitive environmental variations like seasonal changes. Evolution is referred to adaptations that transcend generations resulting in species with different DNA than their ancestors. Evidently, events similar to the birth of a mule do not fall in this category because parents are from different species.

The necessity of evolution for continued existence of life does not imply that life on our planet was accidental. Quite to the contrary, the evolution mechanism is so complex that it is unlikely to be the result of a series of random accidents. In order for the laws of evolution to exist, there must be fundamental particles of life (like virus) that obey the laws, and then reflect a more complex version of those laws in larger organisms that are composed of them.

The disagreement between religion and science should not be the statement, “God created man”. Rather, the source of dispute should be the process by which God created the man. Except for the final process, namely the creation of man, there is no implication that any other species where created once and for all, without transcendental transformations. In fact, Genesis does not provide any bases for rejecting an evolutionary process of creation.

Perhaps someday we will find out exactly how we suddenly started to walk this planet. Until then, religion does not have to reject evolution. The only dispute, if any, is whether man was created spontaneously, or as the final stage in the evolutionary process of creation. Science is God’s language for stating the laws of evolution. The prerequisite for learning to speak this language is not defiance of God.

Social Structure

Intelligent species extend the laws of evolution to their social structure. Initially, as small tribes we started out quite well. After all, all members of a tribe were needed for survival, and everyone had sufficient mutual experience with everyone else in order to care about them.

In larger societies, the tribal love and care transforms to love for one’s family. In a complex society such as ours, nationality extends the boundaries of the notion of family. Nevertheless, the source of our miseries is the vulnerability of democracy against corruption, and the effective use of corruption by vulture capitalists.

When a rich man approached Jesus seeking salvation, Jesus told him to give his riches to the poor and return to Him. When the man left, Jesus stated the most fundamental law of our social structure, “This man will not come back”. Simply put, it is the evolution of our social structure that will eradicate social miseries and slavery of the masses, not the enthusiasm of the rich people. Our only solution is the elimination of corruption from the body of our lawmakers, a formidable if not an impossible scenario.

Iraq War

Not a single person on this planet can say a word against the great work that our soldiers are doing in Iraq. Furthermore, going to Iraq and removal of the dictator was not such a bad idea if that was the actual goal. Our troubles started when Mr. Bush showed his hand by reserving all rebuilding contracts for his friends.

In recent meeting in Canada, Mr. Bush threw a line of dissatisfaction against the Iraqi leaders in his speech to help our corrupted media divert attention from the real intent of the meeting. That meeting was for committing more of our enslaved population to the expansion of the business of yet another friend, the Walton family.

As far as Iraq war, our soldiers have done what is rather impossible to achieve by any other army. And yet, our nation is losing its bright youngsters, and growing poorer so a few families will benefit so much as to surround their palaces with anti-missile technology.

I do not argue that pulling out of Iraq will have a worse outcome. However, we can work on this without allowing the perpetrators to continue to benefit from it. As a nation we are betraying our soldiers, and their great accomplishments. We seem to be the only free nation volunteering for slavery, or are we free?

Heroes and Imposters

2007-08-14T18:33:00.000-07:00

This article is about current events in America and is not related to Z++ programming language.

Capitalism and democracy are two great ideas that can coexist peacefully so long as democracy is in control. Once capitalism takes over, it uses democracy as a means for a small percentage of population finding pleasure and satisfaction in bringing miseries to the much greater majority. The focus of democracy will be no more than preserving the state of matters to the taste of vulture capitalists.

It is unlikely that God created us with our eventual destruction in mind. It is more logical to assume that at certain points in our history He gives us a hand to avoid Armageddon. Otherwise, our future depends on how we will deploy our accidental intelligence. In the latter case, given the rising percentage of bushes in the forest of trees of humanity, the most likely eventuality is that the bushes will consume the trees and end humanity by devouring one another. Thus, Armageddon could only be the consequence of our accidental creation, and may be avoided.

A nation with 90 percent of its population oppressed by 9 percent for the interests of 1 percent is not democratic. The democracy being exported to other countries is a screen-savor for stretching the size of the 90 percent of our population. All we get out of a two-century-old constitution that is the pride of humanity, is the ability to bark so long as we are not too loud, AKA freedom of speech. Ironically, freedom of speech has become an attractive means for selling TV commercials.

Our social and scientific evolutions have been on different paths. Socially, we have been going in circles and forced to repeat the same unfortunate events with leader substitutions. This is because science is open for research and is well documented. On the other hand, social events are studied through history, which is mainly available in fabricated forms.

The notions of conservatism and liberalism are relative to nation or a person’s interests. Consider Kennedy’s objection to using wind for generating electricity solely because some members of his family do not like to see the generators from the Kennedy’s private island. This is a form of liberalism in which the laws of nation are manipulated for personal conservatism.

Lying to save the life of a family member is not equivalent to lying because a family member wants the sun to rise from west. It is not a law of nature that someone whose last name is not Kennedy, Bush or Walton should live a miserable life of a slave so those owning the last names, in a manner similar to kings and princesses, can live a full luxury life filled with comfort and pleasure.

Nations will remember their heroes forever. However, it is the man that makes the name, not the other way round. Our democracy would be more reasonable if it limited the number of terms a person could remain a senator or a representative. Furthermore, the people would do themselves a lot of good if they do not simply vote for a name lest they elect a wolf dressed as sheep.

Being rich is not the issue. The rich overseeing the laws to keep the poor as slaves while extending their wealth and power is only 10 percent democratic, with 9 percent serving the 1 percent body of monarchs. Here and there we are catching a few thieves who have cheated a few millions, while the real ones remain untouchable by means of a strangled democracy that they have taken hostage.

The desire for profit is quite normal. However, capitalism is not a synonym for cruel exploitation. Spending millions in lobbying to lower salaries and reduce taxes is messing with laws of country for maximizing profit. After all, the less one pays in taxes the more profit, forcing the low-paid to make up for it, and miserably so. This is a clear example of legalization of theft at a very large scale, and then in a democracy.

Think about the following observation instead of feeling offended. When I eat, I always have my dog’s share in mind, and he knows that. The majority of us, however, simply eat our dinner not even remembering that we have a dog. At the end, if anything is left in our plate, assuming that the dog is closer than the trashcan, we let the dog have a taste of our food. The latter is the scenario when we replace the basic social services with the trickle down theory.

Basic social services are the right of a person in a society, not a consequence of being lucky to have a job as the servant of a king. The rich receive the very best of medical and other services at the cost of miserable lives of the poor who pay a high percentage of their income in taxes and live their lives under debt and heavy interests, chasing the mirage of a bitter retirement that keeps moving away from them.

One way to reduce the effects of vulture capitalists is for a democracy to identify the basic needs for a reasonably secure social life and provide it for its citizens, while allowing the private sector to compete. However, the cancerous cells of vulture capitalists have spread too far for a democratic treatment of the social disease we are suffering from. One possible scenario is for many of us to parish under the agony of poverty so the remaining miserable will see their future when they go to Florida’s e-voting machines, only until another breed of bushes begin crawling on the trees of humanity.

Scientists should look for means of breaking the vicious cycle of takeover of vulture capitalists. It is the responsibility of scientists to solve our social problems just as they find solutions for our scientific problems. I am not disputing Jesus’ divinity when I say that he was a social scientist who sacrificed his life for the salvation of humanity. After two thousand years we are still making movies of His heroic life. In contrast, a social scientist serving the purpose of a vulture capitalist is an imposter.

For lack of a better name I will refer to the following phenomenon as the principle of mutual devouring. A vulture capitalist wants to absorb as much wealth as he can, so other vultures like him receive less of it. In doing so, a vulture capitalist is not concerned about the impact he is having on his nation.

Thus, when a person is allowed to take billions paying little tax, and to pay as little for wages as he desires, he will use it to the maximum limits in order to increase his wealth. It is therefore the responsibility of the president and the congress to set these limits right so the middle class prospers and poverty vanishes.

It is treason to change the laws so the rich will have the opportunity to suck the wealth of a nation burying the middle class under debt so the following presidents will help them pay their debts for years to come. A democracy should be able to recognize such obvious cases of treason and to properly punish the perpetrators.

What is the point of a roller coaster life resulting from vulture capitalists playing chess against each other for redirecting profit? Is this how the science of sociology defines its object of study?

Dr.Z.

Established tools do not become extinct

2007-07-28T13:08:00.000-07:00

In 1989 I was asked to teach C to a group of students who were only exposed to COBOL. I was caught by surprise when I found myself in serious trouble while discussing Boolean expressions. That was a long time ago and both languages were old even then. A modern language that forbids the use of traditional concepts is simply creating engineers who cannot use the equivalent of a screwdriver, should it be necessary.

Take a closer look at next construction site that you pass by. You will see sophisticated modern machinery, some rather huge. However, you also see workers wearing belts of simple tools like hammer, screwdrivers and so on. Thus, unlike programming languages a modern construction site does not forbid the use of established tools.

Some languages proudly advertise their lack of support for global scope, others boast of lack of pointers in their language, and yet others sell themselves as supporting a particular paradigm. For their defense, they will tell you about all the bad uses of the notions they are leaving out. Compare that to someone describing the hazards of using a power tool such as a drill. By the way, you hardly hear about the difficulty of designing a coherent language that could support all of the well-established concepts.

Researchers have identified many bad patterns of using the very best of programming concepts. In fact, it seems like engineers would pick up the incorrect patterns of usage unless properly trained. This is probably the greatest cause of defective software, especially when hiring engineers who lack adequate academic preparation in software development. Leaving out pointers and the lack of global scope only ties up the hands of experienced engineers, resulting in bad software written even by such engineers.

Interestingly, some venders use global scope and pointers in crafting their virtual machines and yet the language supported by their machines leaves these notions out. Unlike machine instructions, pointers are conceptual tools and are not associated with low-level programming. However, inadequate training may cause an engineer to carry over his low-level experience to the higher level of an abstract language. That is only a good marketing factor for selling a weak language for use by inadequately trained engineers.

The Z++ abstract programming language combines all successful and well-established conceptual tools for developing application software. Furthermore, Z++ includes sophisticated linguistic tools for distributed computing, component-oriented development, autonomous agents, database and service-oriented applications. All these tools (linguistic constructs) interact coherently by design, allowing the compiler to do a thorough analysis, which is not possible by the addition of extensive libraries to a less expressive language.

The following is a digression.

Intelligence has perfected the ideological notion of carnivorousness. We suck life out of our own species through the very means that were invented to end exploitation, namely democracy. The solution is not a different social system. Rather, we must find ways to curtail the ability of rapacious sub-intelligent anomalies to enslave our nations through corruptions and deceptions.

Beware of the media that you trust most. They will deteriorate the reputation of the best candidates and at the last moment they will create chaos and confusion, appointing another Bush-like to the White House. Only your eyes and ears can be deceived, not your mind.

Consequentiality of language and the essentiality of infrastructure

2007-07-18T14:19:00.000-07:00

With the addition of object-oriented SQL statements to Z++ it is possible to present a more illuminating argument for the need of a monotonic formalism for developing application software.

The article Database illustrates SQL statements and their seamless extension in support of object-oriented notions. Here we argue that with sufficient complexity undertaken by a technological infrastructure, such as Z47, it is possible to support a platform-independent monotonic formalism.

The consequentiality of language

One does not first make a word and then think about what to use it for. A rare exception to this rule is the imaginary unit in mathematics (the square root of –1). However, many mathematicians considered the imaginary unit an unfortunate meaningless symbol until a satisfactory interpretation was found.

As hardware evolved, so did our linguistic formulation of software problems. For instance, at the era of assembly language we were able to conceive the notions of macro and libraries. Presently, a vast set of notions are scattered among a large set of languages. Many of these languages contain constructs specific to particular platforms. Nevertheless, these languages were designed to provide abstractions for developing software applications with lesser dependence to detailed knowledge of the platforms they supported.

Many abstractions introduced by contemporary programming languages are the result of valuable thoughts by scientists. Eiffel’s invariant, C++ templates and ADA’s range for case labels are among many such valuable observations that should be available within a single formalism. Thus, our conceptual understanding of software development has been evolving but our linguistic approach for expressing this understanding has been inadequate in that concepts are scattered among languages.

The Evolution of Software Formalism discusses the stages of maturity of a formalism, and Only software can be multi-domain expert discusses the difficulty of having to deal with multiple languages.

The essentiality of infrastructure

In software development, linguistic concepts are created in response to specific problems, as well as attempts to solve those problems. However, the age of designing a new language that introduces a few more concepts but ignores those introduced by others is over. For developing application software, we have reached the turning point where a single monotonic formalism is needed.

Science and harmony of formalism discusses the characteristics of an infrastructure required for achieving a monotonic formalism. For software development the notion of monotonic growth implies the lack of need for any code change. That is, previously written software should not need adjustments as a result of growth of formalism.

A chimpanzee is a complex biological machine that lacks the complexity for speech. In the same vain, a technological infrastructure for supporting an abstract formalism is necessarily more complex than variations of the technology known as virtual machine. Otherwise, BASIC, Smalltalk, C# or Java would have solved the problem. A virtual machine delegates the needed inherent complexity to the underlying platforms. Consequently, the abstractions of the formalism supported by a virtual machine are platform-dependent.

Code Mobility discusses the inherent complexity of Z47 processor and its suitability for supporting a universal abstractions for developing distributed application software.

Conclusion

Article Database demonstrates the ability of Z++ formalism to grow monotonically. The significance of Z++ extensions is in their universal availability, for all platforms. In contrast, regardless of the value of extending a language like ADA, it is not possible to make such languages available for small devices.

So far as developing applications (as opposed to system programs), we are moving away from the bronze age. In term of programming, my interpretation of bronze age is hearing statements like “Language X can do this, and language Y has that feature”. It is time to say something like, “How do we evolve the formalism to include a new scientific discovery”?

A brief digression

In communism, so long as you follow the law you are entitled to a piece of social services, living a predetermined life. In unregulated capitalism, so long as you follow the law you will live a hopelessly miserable life unless a servant of a lawmaker finds you useful. In the latter case there is a glimmer of hope that you might be able to become an exploiter.

Our goal should be a happy fight against the cruel laws of nature. Perhaps the happier next generation can find ways so we can leave our solar system in search of happiness and excitement for everyone.

We need to correct our social system by properly regulating capitalism, not crippling it. In particular, we must evolve to a point where vulture capitalists cannot bring miseries to us and then sit back and feed on our miseries. A vulture capitalist is an anomaly much worse than a serial killer.

A tribute to Dijkstra

2007-06-23T18:11:00.000-07:00

It should be clear that all the years of my work on Z47 processor and Z++ formalism is not the equivalent of the monkey in the British Museum trying to type “To be or not to be”. Specifically, in all my writings on program correctness I have been careful to distinguish between an algorithm, and its implementation as an actual program.

To pioneers, like Dijkstra, the code looked and felt like mathematical formulas. In fact I remember reading Dijkstra, some 25 years ago, saying that procedures are the equivalent of mathematical theorems. Obviously I could not accept that kind of statement without some formal mapping. On the other hand, I could not dismiss the statement for the same reason. Indeed, I was inclined towards establishing it as a fact.

Interestingly, Dijkstra’s Shortest-path Algorithm is a point of diversion. It portrays an algorithm as a strategy that can be rigorously verified. On the other hand, the implementation of the algorithm is the tactics we use based on the programming languages available to us.

A lot of defects are consequences of poor personal techniques just as a rookie is less likely to score a goal in a feasible situation than a skillful soccer player. However, most defects are created by, experts struggling with complicated programming tricks to mix and match technologies. That is why a coach replaces his soccer star when he finds the star too tired to be effective. Unlike soccer, resting for a few days makes things worse because the engineer has to recreate the information in her short-term memory.

According to Dijkstra, someday there will be a form of mathematics that can be used to prove the correctness of algorithms, systematically: something like algebra for equations, or calculus for continuous events. Even in recent history of mathematics, differential equations were essentially a bag of tricks for a long time. Indeed, much of Kleene’s work and current research is in this direction. However, that research should not be extended to, or mixed with program correctness, as Dijkstra envisaged.

The main cause of defective programs and unmanageable cost of maintenance is the gap between theory and technology. Although programs are not mathematical entities, programming does admit a monotonic formalism analogous to mathematics. The demonstration of this fact has been my research for past decades.

The materialization of programming formalism is of technological nature. Theoretical considerations are required for building the foundation for this technology. Specifically, isolated observations implemented in a large set of disparate languages and libraries, is not a technological solution. The notion of monotonic growth does not mean adding a new language to the set, which simply does a few more things somewhat differently.

The mathematical notion of number derives its usefulness from its lack of dependence to platform. Thus, Peano could study the characteristics of numbers without having to think about different notions of number used for counting different objects. Programming concepts can also be studied without having to think about idiosyncrasies of platforms. The solution to this problem requires a platform independent technological foundation.

Some of the disbelief for the existence of such a technological infrastructure comes from the fact that we have witnessed the rise of several paradigms. However, there has not been any scientific observation to argue that any paradigm is in conflict with any other. There is no slightest scientific evidence to believe that some future paradigm will become incompatible with any of the existing paradigms in such a way that it cannot be absorbed monotonically.

In other articles I have discussed the need for separating, system programming languages from a monotonic formalism for developing applications. In support of this argument, consider the simple fact that the notion of society is studied by a collection of sciences each dealing with its own abstractions.

Turning to the cost of maintenance, a simple research will reveal that the cost rises exponentially with time. In most cases, the interval of time is just a few months and the curve rises sharply. When we look at these products, we find them put together with a large set of technologies, including languages.

The solution to this unwieldy practice is to automate the work done by all these technologies, libraries and minimal languages, algorithmically. Once that is done, and only then, one goes about presenting the solution through linguistic abstractions. It goes without saying that the solution must provide the technological infrastructure for monotonic growth of the language without repercussions.

These points have been the guiding factors in the implementation of Z47 processor for the infrastructure, and the design of Z++ language for the software development formalism.

Zorabi Honargohar

Assembly Line Engineers

2007-06-17T21:39:00.000-07:00

A large software development shop is an array of cubes housing engineers. There are various groups of engineers working across an invisible software assembly line. Several of these groups specialize in particular languages and their associated libraries. Then, there are certified individual familiar with the latest peculiarities of the operating system or technologies they supervise. Yet another group consists of those familiar with high-level architectural ideas and the latest standards, such as UML, XML, SOAP and DCOM.

A smaller software development shop has considerably fewer engineers, and yet the entire parts of the assembly line are fairly noticeable. Thus, despite the fact that the project is smaller the complexity of its development is about the same. Furthermore, evidently each member of the smaller team is aware of a great deal more and is able to use it all concurrently.

For a moment this all seems natural. After all, a car is assembled as it moves along the assembly line. So, perhaps software should also be assembled using several languages, different versions of libraries and so on. That is why applications are costly to maintain and therefore expensive. That is just how it is, or is it?

Since all languages are mapped to the instructions of a hardware processor, a theorist will declare that all languages are equivalent, without reservations. Well then, let us examine the notion of equivalences of languages more closely.

The language Eiffel emphasizes Design by Contract, relying on its linguistic abstractions such as invariants, which its compiler enforces. Suppose we endow C++ with a similar mechanism through some form of library extension. As far as the theorist is concerned, the engineer is responsible for remembering to include certain statements at end of each and every relevant method.

Leaving the implementation of difficult and confusing concepts, like invariants, threading, IPC, strong mobility etc. to engineers results in as many different defects as the number of individuals. In an ideal situation a human will make no mistakes. Nevertheless, it is possible to create such an ideal environment by involving the compiler. Pragmatically thinking, it is better to rely on a compiler for not making mistakes rather than accepting the theoretical equivalence of languages.

Engineers should systematically follow proper patterns. However, the language must also be capable of evolving by providing linguistic abstractions that the compiler could enforce. The whole idea of having a language is to be able to abstract and automate the causes of complexities in order to reduce the defects associated with them. But, is it possible to evolve a language without deprecation of previously written software? The answer is indeed yes.

Our wish is a language that can monotonically grow, providing more abstractions without the costly side effect of having to repair previously written software. We know that aside from translating the language to the instructions of a processor, the compiler will also need help for threading, IPC etc. from an underlying operating system. Therefore, there is really one solution to this problem, and that is the existence of exactly one operating system running on the same one processor for all platforms.

At first glance, the requirement of a unique operating system for all sizes of computing devices may sound ridiculous. In fact, we want to see more operating systems than just Windows and UNIX even for desktop devices. Yet, at the same time, we want to write applications exactly once, without the use of multi-platform libraries and other similar software.

Ironically, Z47 processor solves exactly these technologically outstanding problems, and yet software companies prefer to produce assembly line software and thereby reduce their share of the profit, as they are entitled to. These companies pass their profits to those who have created the illusion that software assembly line is a fact of life.

Platform dependent democracy

2007-06-06T00:48:00.000-07:00

The object-oriented SQL abstractions of Z++ will be release around July 10. This article is of philosophical nature concerning democracy, and is not related to Z++.

Our victories are reflections of our triumphant attempts to achieve our imagination. A few sub-intelligent capitalists confuse imagination with dream of making more money thereby creating hurdles while causing disasters for millions. Perhaps we need to use our imagination in perfecting the notion of democracy and relieving it from its absolute dependence to the pockets of vulture capitalists.

When greedy capitalists take control of a democratic system, they simply turn it into a system of legalized theft and organized communism. The masses are deceived and enslaved while the privileged ones rule by corrupting the very same means that are intended to unveil corruption, in a free nation.

At any time, our imagination is a theoretical approximation of reality. The joy of successive victories in convergence towards the reality of a better life for all of us is the main stimulus of intelligence. It is a shame to allow a sub-intelligent to exploit our historical feuds for absurd personal gains. Repetition of this bizarre phenomenon is a major candidate for terminating intelligence altogether.

History is a great teacher. However, we do not need to wait for a century and then read Herodotus in order to learn our lesson. We have bitterly tasted how it is a shame to trade the proper use of our scientific achievements for the meaningless achievements of a sub-intelligent. We know very well that deceptions will continue to confuse masses. Perhaps researchers can focus on successively converging our democracy towards a reality in which there is less suffering resulting from deliberations by another Caligula.

Turning to the presidential debate conducted by CNN, I heard a candidate saying, “healthcare must not be controlled by Washington because Washington operates poorly”. Thus, the candidate is already declaring that he is incapable of handling whatever happens in Washington. I take it that he simply wants to live in the White House for a few years?

Another candidate blamed the lack of insurance for millions on the people themselves. He said, with proper education so people quite smoking and eat better food, we can cut billions on medical expenses. That is excellent, but who is the recipient of the billions that will be saved? And somehow the insurance companies are going to share their profit with their insured, as the oil companies are doing it now?

A democracy that depends on the platform of the size of someone’s pocket is like a system program. It only works on the platform for which it is written.

Simplicity is only skin deep

2007-05-11T00:33:00.000-07:00

Walking along a river surrounded with trees and colorful flowers it was hard to deny the beauty of simplicity. The beauty was in the effortless sense of pleasure perceived through my ears and eyes. I needed not to decipher my perceptions in seek of pleasure. Alas, that was a seen in the distant past. The rivers have dried up, as have the flowering fruit trees along them. The flowers have been ravaged with useless bushes absorbing the precipitation before it reaches the rivers.

The time came that I began to think about how the river and trees and the flowers were as they were. As I entered beneath the simplicity, I found myself confused and perplexed. I then realized that simplicity is only as deep as its mysterious beauty.

The elegance of a language for software development is a consequence of its simplicity.
However, simplicity that has not evolved on a complex foundation is but fleshless skin. The sense of simplicity I have in mind is the elegance with which a language portrays complex concepts in the form of universal abstractions.

The interpretation of simplicity in designing an abstract formalism has lost direction. After all, simplicity and its beauty are context sensitive. What a mathematician finds beautifully simple and elegant may look no more than a senseless sequence of letters taken from the alphabets of several languages.

For a software engineer, simplicity is the ability to express solutions effortlessly. Once a part of a solution requires digging deeper into the platform idiosyncrasies and specialized libraries, the beauty is simply replaced with agony. A simple language that anyone can learn almost overnight is not beautiful except for those who view mathematics ugly.

Consider the historical points in mathematical progress when concepts were symbolized. For instance, compare the Roman numerals to the positional number system that we use. Or, how mathematicians of antiquity dealt with equations before the notion of unknown was symbolized. Now think about forty-character-long library functions, which take several arguments in a certain order. Where is the beauty in a simple language with a library the size of an encyclopedia, given that all functions in the library are actually correct?

The simplicity, and therefore the beauty of mathematical abstractions is a consequence of their generality. The results that Euclid established from his drawings on sand are just as valid as if he used pencil and paper. Otherwise put, theorems are not valid relative to the platform on which they are obtained.

A discipline of engineering cannot be founded on a set of languages and then more languages for gluing them together. Instead, the discipline needs a monotonic abstract formalism. This is possible, and has even been done for Application software, which have a meaning without regard to whether their initial design was done on sand, or on paper.

An application that depends on its platform of execution is a system program. For instance, Microsoft Word is only an application for Windows platform, which needs upgrade every time that Windows changes. Thus, Word is not an application. On the other hand, one should not expect an application like Word to appear exactly the same way on a PDA. The point is that, Word should be available for any OS for a desktop computer in order to qualify as an abstract application.

A platform-independent application, such as a word-processor or a spreadsheet will allow users to switch to a better operating system without having to lose their files or learn about a different application. More importantly, application developers will not have to pour their bills through Microsoft gates for upgrading their products from XP to Vista, and then again to something else.

Take a look at Z++ and you will see that this is not a dream. Quite to the contrary, it is tangible and concrete.

The Pain of Debugging

2007-04-21T21:39:00.000-07:00

We engage in debugging when a defect has been reported. The activity involves identifying the platform, the tools such as emulators and SDK, and the compiler used for that platform. Hopefully, there is an IDE and a modern debugging facility for our setup.

We then begin tracing the code, or stepping through it and observing the states of objects with the hope of locating the cause of defect. This may all be as it is except when the thread of execution enters an uncharted territory. Here we are in the wilderness of libraries not written by us. The pain is the same whether we are hiking the compiler’s land of standard libraries, such as C++ stream library, or we are climbing Java’s Everest library. A particular characteristic of these libraries is the fact that they change color and shape like the four seasons. So we must also be aware of the particular version we are linking with.

Finally we ask an innocent question. Why can’t I debug the code that I, and my team wrote? What do we have to do with finding bugs in other peoples’ code and reporting it? Surprisingly, there is a positive answer to your legitimate desire!

Z++ Visual is one single development point for any and all platforms. There are no SDK, no emulators, indeed nothing else for that matter. You only step through the code that you, or your teammates wrote. Your focus remains at locating the cause of defect in your code. The rest is taken care of by the Z47 processor.

A Z++ program has a single meaning, independent of platform. When a bug is reported, you analyze it on the same original consol that you wrote the program, regardless of the platform on which the defect was observed. Obviously, your fix takes care of the problem for all platforms. This is as natural as the innocent question that you asked earlier.

Autonomous Agent and Semantic Automation

2007-03-15T22:19:00.000-07:00

Semantic automation is the act of mapping a well-understood notion to a linguistic construct. For instance, the type constructor class is a semantic automation for the notion of abstract data type. A construct for defining template classes is a further generalization of the notion of class towards the concept of abstract data type.

A more illustrative example would be writing the C language for-loop using only if-else and go-to statements. Here, the engineer will be exposing the control structure of a well-understood notion, mixed with the intended statements (the loop body). When a defect needs to be fixed, one has to be concerned with the control structure statements, just as well as the intended statements.

Presently, the implementation of the simplest form of an autonomous agent requires proxies, adaptors and quite a few other complex coding techniques. The coding techniques are analogous to the control statements of the for-loop mentioned above. It is a major challenge to locate the source of a defect. First, one has to determine whether the defect is in the statements relevant to the autonomous agent, or the much larger code related to its control structure.

Even with all the irrelevant complexity, one can only implement very simple forms of autonomous agents in the context of a virtual machine. In other words, even though the notion of strong mobility is well understood, its semantic automation is not within the reach of virtual machine technology.

An autonomous agent is a process, and not a class or a bundle of classes. As a process, an autonomous agent terminates its execution on one node, and continues its execution on another node precisely in the state that it left its origin. The semantic automation of this abstraction is completely out of scope of the capabilities of a virtual machine. Indeed, a virtual machine has no concept of a process. In fact, even threads are mapped to the threads of the platform on which the virtual machine runs.

The technology that can materialize the semantic automation of the notion of an autonomous agent is a distributed operating system. As such, the operating system can remove the process representing an autonomous agent from one node, and add it to the list of processes at another node. The transport will be transparent to the process of autonomous agent. The transport is equivalent to the notion of a process waiting for its execution slice.

The linguistic construct for the semantic automation of an autonomous agent is actually quite simple. Consider the statement “travel IP-address”, where IP-address is the address to reach the destination node. The semantics is that, when an autonomous agent visits this statement, the transport will take place, retaining the state of the agent at the destination node. So now the question is, how does one go about implementing the travel statement?

As mentioned earlier, the automation of the travel statement requires support at infrastructure level, in the form of a distributed operating system that manages its own processes and threads. The relationship between the language that provides the linguistic construct, and the distributed operating system will be analogous to that of C language and UNIX. Note that we are speaking of a relationship not the level of abstraction of the language. The C language is quite low-level.

The operating system and the language for the semantic automation of the notion of autonomous agent have been developed and successfully tested for a number of years. For more information please visit ZHMicro.

C++ Exception Model

2007-03-15T22:11:00.000-07:00

In the C++ object-oriented model of handling exceptions, an application can only catch exceptions that are explicitly thrown by that application. This implies that exceptions caused by the underlying system will either make the application undefined, or will result in a crash. Generally, the following advantages are attributed to this (synchronous) mechanism.

Pay as needed. This refers to the fact that, every exception that an application intends to catch must be thrown by the application. Since exceptions caused by the underlying system are to be caught, one generally pays for everything. Hence, this is a rather useless feature for developing large and complex applications. However, system programs are generally smaller and deal with a few specific exceptions. Even in the latter case, a predetermined set of well-known exceptions could be supported, which is not possible with the C++ rudimentary model.

Overhead. Since there is a minimal overhead involved for catching exceptions that may be caused by external events, this is a true statement. Again, it is only worth in the context of system programs, which demand the most efficiency. For reasons of efficiency, in most cases such programs are written in C, and not C++. Furthermore, one ignores the fact that the creation of exception objects and throwing them arround is quite costly.

Termination. The C++ model is known as Termination as opposed to Resumption. This of course is a contradiction. One does not simply catch an exception only to report diagnostics, and terminate. This is hardly worth referring to as “handling an exception”. The C++ exception model is effectively a complicated logging mechanism.

Exception.pdf illustrates the advantages of Z++ model of exception handling for developing large and complex applications.

May God continue to bless America

2006-09-09T22:42:00.000-07:00

This blogger is poetry, and is unrelated to software development. It is however a close description of my life, and my impressions.

What is the difference between the Romans raiding a country with swords, and the Administration devastating our nation with new laws, and neglecting our constitution? The only difference is the magnitude of the people affected by the Administration.

The most horrible form of terrorism is the one that comes silently from within. It is terrible to become homeless and lose your family so someone will make a huge profit. The definition of terrorism does not necessarily include explosions and WMD, despite the fact that the Administration portrays it as such.

Dr. Z.

My life-thread unable to wait
Under democracy’s weight
Free but useless to state

Sheriff is at my door
Karl strategizing on the oval floor
Democrats looking for another Gore

Carter and Kennedy extending their share of democracy
Bush and Cheney drilling it for more currency
Neither bothered with the nature of emergency

My son killed in war
My wife gone far
I am left with a jar

At age of fifty nine
Ph.D. and creed in divine
I have nothing to dine

Jobs left are for the illegal
Illegal are made legal
Citizens perish as illegal

News portray Snow’s deceptions
Selling ads, ignoring perceptions
Profit reins receptions

Basic needs are for profit
Life for trickle from profit
Tax in service of profit

Talk yields compromise
Profit hates compromise
War lacks compromise

Wars creeping step by step
World war at our doorstep
Profit guides evils’ next step

Scorpion is born from scorpion egg
Terrorist is born from terrorized egg
War irrigates land of hopeless egg

Warning then bombing disputable
Military murder unjustifiable
Humanity no longer desirable

Paradise and hell coexist
Oppressors enjoy and persist
Served by duped scientist

Good and evil are on earth
Devil rose from CIA’s dirt
Democracy long behind left

He took pride in his physical
I cannot think of medical
Slave is but for practical

He wants to keep his gangsters
Opportunities require blasters
Profit feeds on disasters

He likes to play video games
Shock and awe for more fames
People burning in open flames

The incapable of acquiring skill
Unable to read after much drill
Is pumping miseries to the fill

May God continue to bless America for the rich
So they can hire politicians to bitch
And keep Americans in deep ditch

Later on, the wind and the rain
---- Will softly wash away my name
My grave will remain in the lane
---- Free of good and bad fame

Software engineering and the future of mankind

2006-08-18T09:24:00.000-07:00

This article is somewhat philosophical in nature. It intends to demonstrate the enormous potential of software in the future of humanity, and to indicate the required infrastructure for harnessing this potential. It also presents a view of software engineering. We begin with a brief observation of our biological software.

The hardware comprising modern man is the same as its original form of 40,000 years ago. Though brain seems to adjust itself at various stages of a person’s life, there is no evidence that our brain’s processing power has increased since then. Quite to the contrary, there is all the evidence pointing to the abundance of idiots among us.

Indeed, the less intelligent a person, the more likely to achieve positions of power. There are animal-level smartness and human-level intelligence. These are not to be measured by the same standard. Even a monkey has sufficient brain to steal another monkey’s food, whether or not it is actually hungry. Exactly where is the evidence of human intelligence versus animal smartness in recent absurd oil profits?

Returning to our topic, human hardware did little to manipulate nature for better lives for mankind, until mental software equipped the brain with more sophisticated processing capabilities. A baby’s hardware processing power is the same as a baby born 40,000 years ago. The difference is the better mental software that a modern baby picks up through education.

Obviously, our computer hardware will continue to evolve providing more processing power, better input/output interface and so on. However, hardware is only necessary but not sufficient for boosting our technological achievements. The real breakthroughs will come from advancements in (intelligent) software, especially the tools, methods and theories for developing complex and highly sophisticated software.

Software is not limited to applications running on a desktop computer. In fact, the country with greater number of properly educated software engineers will eventually surpass other countries filled with programmers and coders. One reason for this is the fact that educated engineers have better insight and make observations that are invisible to ordinary programmers. Presently, none-practicing scientists are making observations from erroneous practices of programmers. Practicing engineers will be able to make observations against their own performance, thereby accelerating progress in software development.

Consider a country equipped with intelligent missiles that can bring planes down and avoid crashing into an anti-missile defense system. I only mentioned this example so those seeking wars will understand the significance of future intelligent software. Nevertheless, it stands to reason that rudimentary hardware under the control of sophisticated software can easily outperform advanced hardware equipped with weaker software.

The argument here is that apart from tremendous potential in software, it is the most significant means of our future achievements. However, the infrastructure to harness this potential is still in bronze age. The needed infrastructure is a large number of properly educated software engineers. Professional programmers who write code for a living are assets, but not major players of this infrastructure.

The difference between software engineers and programmers is quite similar to the difference between physicians and lab technicians. Presently, we have an overflow of technicians, mostly self-trained, with very few engineers. As a result hardware variations are skirting existing software technologies that do not work well. For instance, consider the variety of cell-phones and the quality of service they provide, in particular the regularity of dropped-calls.

Engineers in areas other than software engineering study a lot of theory while learning a technician’s skills. These training branches are combined into one at later stages of an engineer’s education. Nonetheless, an engineer can also perform as a skillful technician just as a doctor can confidently act as a nurse. This, however, is not the case in software engineering. Indeed, a university curriculum cannot devote some 100 credit hours for covering all the languages, libraries and platforms, nor the student will be able to use such scattered information.

The reality is that we are in a bigger mess than Y2K, which only involved one single language. Eventually, the chaos will be confronted by software developing companies rather than universities or so-called technology leaders. The overburdened software developers will recognize the value of an abstract language, which in turn will provide the necessary incentive for universities to react to the tidal wave.

Some claim that software engineering is distinct from programming in that an engineer deals with software characteristics, such as reliability, availability etc. The fallacy here is that, relevant software characteristics are not easily quantifiable and the easily quantified factors are not practically useful. In fact, without being involved in the development of software an engineer has few useful criteria for measuring any of its characteristics.

Another way of looking at software engineering is through the eyes of a mathematician. Furthermore, avoid confining software engineering to the work of a web designer. It is hard to imagine a mathematician who can prove theorems without the ability to manipulate symbols, though certainly a mathematician is not a biological calculator. In the same vain it is hard to imagine an engineer who can solve programming problems without the ability to program, though an engineer is not a GUI developer on a particular platform.

An abstract language, such as Z++ programming language, does not change the nature of software engineering. However, it does solve a major problem by reducing the distance between an engineer and a developer. In particular an extensible formalism facilitates future abstractions in the hands of software engineers.

The following list provides further reading on the subject of this article.

Z++ and Academic Research
Research requires Abstract Language
An abstract language is indispensable for educating engineers

Software development complexity

2006-06-25T10:25:00.000-07:00

The whole idea of academic research is to reduce the complexity of software development by discovering and mechanizing software abstractions such as structured programming, object-oriented and component-oriented development.

The mechanization of abstractions demands equally innovative technological discoveries. Technological patches merely compound complexity without offering a solution. This note discusses the causes of increasing complexity and the correct approach for eliminating much of the artificially created complications.

Naturally, a venture capitalist (VC) invests in search of profit. A VC is not interested in anything other than the possibility of a high return on investment. One would think that an established technology leader considers factors beyond marketing twists strictly for profit.

Marketing cheap untested technological patches and ideas like MFC, COM, ATL, ODBC, SOM, XML, Beans and Aspects etc. have resulted in a chaotic mess with virtually zero progress towards solving the problems of software development. These technologies have complicated software development even on the specific platforms for which they were expected to help reduce complexity.

When attempting to solve a new problem one sets out by building a prototype. In doing so many good and bad ideas accumulate, which is acceptable for a free product such as Linux. Eventually, those who dare will weed out the bad ideas. However, expectations are quite different when the product is bought from technology leaders.

Recently IBM has been marketing its new invention “Software Governance” in conjunction with Service-Oriented Architecture. The next step will be “Software Legislature” for making laws to impede buying software from other vendors.

Technology leaders have been acting very much like VCs seeking profit without regard to the value of the products they are marketing. Indeed, there is more conscious effort to lock competitors out rather than reducing the complexity of developing software. As a result the complexity of software development has been rising with serious repercussions for the maintenance phase.

Since the solution to a problem must be expressed in a language, ultimately the mechanism for controlling complexity is in fact of linguistic nature. However, there are several important considerations in order for an abstract language to qualify as a viable candidate for a formalism for software development. Some of these factors are discussed below.

Solving contemporary problems

Automation is very often confused with adding more libraries and software-development kits (SDK). Instead of rectifying the problem these solutions compound the complexity of development. They require learning new specific skills that are not transferable to other platforms despite the fact that they are generally skirted that way.

A contemporary challenge is component-oriented development (COD). COD is distinct from multi-tiered development and Service-Oriented Architecture (SOA) but is effective in reducing their complexity. COD is also important because it presupposes platform-independence and distributed computing. Another challenge is strong mobility for Autonomous Agents. The code for an autonomous agent should be oblivious of the mechanism for transporting its state.

These challenges require linguistic solutions, and cannot be accommodated with libraries or patched with technologies like DCOM or CORBA. Furthermore, a linguistic solution for these problems will enable the compiler to trap a lot of obscure errors that generally go unnoticed.

Interoperability

It is not feasible to rewrite everything once a new language is born. The language must include a smooth mechanism for interoperability with major legacy languages. The most reliable form of interoperability is linkage. First, the compiler can catch most of the easily missed errors. Second, the linker will be able to complement compiler’s error checking.

Monotonicity

The distinctive characteristic of a formalism is its ability to grow monotonically. A programming language not designed with extensibility in mind is a dead-end. Monotonic growth means that the expressiveness of the language grows in order to absorb new scientific discoveries.

As the term monotonic implies, new extensions must not impact software already compiled. Furthermore, the term formalism connotes independence from technology. A programming language with different versions for each category of application is inherently technology dependent, and therefore not monotonic.

Device or application centric

A monotonic formalism should support two distinct views, seamlessly. In device-centric view an engineer needs proper mechanisms, such as pointers for efficient implementation of certain aspects of an algorithm. A language like C is entirely device-centric because it is intended for programming devices. However, the device-centric view of a formalism should not be used for device programming.

Application-centric view deals with class, template, COD, SOA and strong mobility among other things. The device-centric constructs are few and all well known. Future extensions are likely to be in the category of application-centric view.

The point here is that, a language with multiple versions such as an enterprise-edition and a PDA-edition is not a single language. In fact, a multi-edition language is just as complex as a language amended with library APIs for each particular purpose, and at times even more confusing.

Conclusion

For almost two decades there has been no significant technological progress in parallel to scientific research, such as COD, mobile agents and model-driven development. The measure of progress in reducing the complexity of software development is not the number of technological patches pumped out as marketing strategies. Indeed, software development has become increasingly more complex with the emergence of such patches.

Technology leaders seek to maintain their market shares at a high marketing cost for their users. Consequently, their research is limited to marketing strictly for profit. They continue to complicate software development in order to maintain control of the market. As a matter of fact, they do not even have the expertise to solve the contemporary problems of software development because their experts are saturated with a bundle of technology patches that must be preserved for profitability.

Z++ programming language is the future of software development formalism, and is freely available from ZHMicro .

Requirements for materializing Autonomous Agents

2006-06-20T09:34:00.000-07:00

A search on “Autonomous Agent” will bring up a lot of references on this topic, including various definitions for the abstraction behind the terminology. For our purposes, an Autonomous Agent is a component with two characteristics.

First, an Autonomous Agent must be able to travel to remote destinations, primarily by self-determination. Second, an Autonomous Agent must retain its state as it travels. The use of AI techniques is desirable but not required.

The first requirement, namely mobility, implies technology independence. The infrastructure is inherently heterogeneous in nature. The purpose of developing expensive agent software is to take advantage of the diversity of infrastructure. It makes little sense to degenerate the infrastructure to homogeneity so Autonomous Agents could be used.

An Autonomous Agent is a technology-neutral process, not a program. An agent starts up as a program, performs initializations and thereafter it continues its life as a traveling process with no technological boundaries. It should be clear that proxy/adaptor technique is not a viable mechanism for achieving Autonomous Agent technology because an agent is not a class.

The move of an agent from node X to node Y is equivalent to blocking/dispatching a process, a function of an operating system. When the agent decides to leave X it is blocked until it arrives at Y and it is dispatched. This high-level semantics of the notion of mobility makes it clear that the prerequisite for achieving Autonomous Agent technology is the existence of a distributed operating system.

The move from point X to point Y should be transparent to the agent. That is, the agent’s implementation should not include code relating to transportation mechanism. Instead, a meta-layer should transport the agent very much like the air transports sound waves. An Autonomous Agent only needs to state its intent of moving to a destination, like the Z++ statement “travel IP-address”.

The requirement that an agent’s travel should resemble blocking/dispatching of processes implies strong mobility. That is, the agent and a snapshot of its state must be transported together. Strong mobility must be supported directly by the meta-layer. Indirect implementations, such as recording the snapshot in a database will not be practical.

In complex situations, however, the state of an Autonomous Agent can be divided into long term and short term. Long-term state could be retained by a database. The long-term state should be used for persistent matters such as large tables of data and rules of inference for expert systems. In other words, long-term state could represent the expertise of the agent, while short-term state is simply the state of agent as a process.

A fancy meta-layer for transporting agents will be of little use unless the agent can interact with legacy software. An efficient and safe method of interoperability with languages like C++ and ADA is through dynamic linkage. Z++ compiler generates dynamic libraries in target languages for interoperability with legacy software.

Z++ is freely available from ZHMicro.

The independence of component-oriented development

2006-06-17T23:06:00.000-07:00

Component-oriented development (COD) and distributed computing are distinct but closely related abstractions. This note discusses the relationship of these notions, as well as the independence of COD in the sense presented here. A specialization of component-oriented development known as service-oriented architecture is also discussed.

Unlike other writings on the subject of component-oriented development, this note does not discuss the advantages of COD. Instead, we examine the characteristics of a medium for materializing component-oriented development.

A concept is independent when the linguistic construct capturing its semantics is not a syntactic sugar within a formalism. An example for making the point clearer would be the claim that Lisp can be used to implement all other programming languages. The claim is only interesting when interpreted to mean that, the notion of list along with operations on list are sufficient for automating all other computational primitives.

An engineer uses the entire syntactic constructs of a language in composing a program. It may be true that all the mechanisms for constructing types, such as class, could be defined using the list primitive. We may as well assume that all constructs of structured programming could be defined using only list operations. However, a program also needs input/output, which require mechanized computational primitives equivalent to the operations of read/write. Thus, in order to support input/output Lisp must admit new linguistic abstractions that are not definable via the notion of list and list operations.

Another example for illustrating the notion of independence is the type-constructor task of Z++ Programming Language. Task is syntactically, and for the most part semantically identical to class. However, when an instance of task is declared the instance is actually created in a new thread. An engineer does nothing relating to threads, such as synchronization, critical section etc. Thus, task hides the details of the computational primitive of threading.

The important point here is that, without a computational primitive for threading, the linguistic abstraction of task would not have been possible. On the other hand, once the operation of threading is mechanized, many linguistic abstractions, such as task become viable.

In COD we deal with the composition and interaction of components. The composition of components needs primitives relating to linkage and other phases of compilation. Interaction of components may involve the operation of loading a component, perhaps remotely. These primitives may be presented inconspicuously in a language. Nevertheless, there will have to be new independent linguistic constructs that hide the details of these operations.

Early implementations of COD appeared in the form of library modules, like ADA packages. Later, dynamic mechanisms evolved this concept into dynamic modules, such as DLL. These implementations used the terms “export” and “import” for composing programs from library modules. The COD abstraction evolved out of a variety of attempts, such as CORBA.

This brief observation clearly indicates that the notion of component-orientation is independent of other notions such as structured programming and object-orientation. An independent abstraction requires technological innovations for its implementation. In the case of COD, these innovations must cooperate among the compiler, linker and the infrastructure.

A true formalism for COD will have to drop the distinction between a program and a component. That is, one must be able to compose a larger component out of any number of components, each of which could also behave as a standalone program. This is in contrast to the division of programs into executables and DLLs.

In a COD language, exceptions and signals generated in a component must propagate to other components in the chain until trapped. Obviously, the compiler must be able to see the relationship among components making up the larger component, without having to recompile the constituents.

A distributed algorithm is made up of components, though not necessarily in the sense of COD. The inception of component-oriented development appears to have been in the form of what is generally known as off-the-shelf components. However, the ability to compose a new component out of components already built on possibly a heterogeneous set of nodes is far more general and useful. We may assume that the conception of COD inherently included distributed computing, but that it was presented in various contexts.

Let us now turn to Service-Oriented Architecture (SOA). It is not attractive at all to rewrite everything once a more general and sophisticated language comes along. On the other hand, supporting everything everyone has chosen to do is begging for chaos. Expressive languages like ADA and C++ are here to stay, and therefore must be supported elegantly.

We consider SOA as a specialization of component-oriented development where components are written in different languages. A serious problem to solve for this specialization is of course interoperability. Z++ Programming Language provides a simple solution for interoperability with ADA and C++ through dynamic linkage.

Z++ compiler takes a set of dynamic libraries, like C++ DLLs, and generates a corresponding dynamic library in the target language. One only needs to compile the generated library in the target language, such as C++. The generated library furnishes direct linkage between Z++ and the target language.

Z++ uses the class construct for composition of components, whether or not components are written in Z++. This allows the use of other abstractions, such as class invariants and method constraints in composing a component from others.

References.

1. Invariant and Constraints
2. Component
3. Service-Oriented Architecture
4. Z++ Language Reference

Only software can become multi-domain expert

2006-06-12T22:17:00.000-07:00

In order to gain a better understanding of our human capabilities for engaging in software development, we need to look back at our individual accomplishments in arts and science. There is no reason to believe that software engineers possess more mental abilities than previous generations of artists and scientists.

Consider some of the greatest composers. You will notice that some of them could play several instruments. Nevertheless, you will find every composer had master-level of expertise in a single instrument. Some poets could speak a few languages, but none wrote poetry in more than one language.

A mathematician knows a great deal about many branches of mathematics but is capable of conducting research only in a narrow area. Most computer scientists are familiar with one programming language. Generally, engineers and physicians are specialized professionals.

A simple and obvious common-sense conclusion from the above observations is that the majority of us can attain master-level expertise in a single area. Some of us can achieve a few proficiencies, at different times in our lifetime. Nevertheless, a great deal of knowledge and skills is only necessary but not sufficient for master-level expertise.

In all areas of engineering, except software engineering, graduates leave college as an inexperienced expert. In contrast, software engineers leave college with a lot of scattered information about many different products as a basis for their expertise. In most cases their expertise does not match any job because there are more products involved in developing any reasonable software. Frequently, loss of job for a software engineer is equivalent to looking for a job as a new graduate.

In defense of software engineering, one may think of playing musical instruments as an analogy, in that some orchestras play wind instruments, and others specialize in string instruments. The analogy is applicable so long as we confine our view to system programming. An application developer is a composer who writes notes for system programs to play. Furthermore, application developers should know something about the domain of application, whereas system programmers need to understand the system.

The diversity of hardware is quite desirable. However, each manufacturer having its own army of specialized developers is only useful in the war of market shares. For instance, consider an insurance company that wishes to support online activities for its customers. When it comes to PC they will probably choose Windows first, with the possibility of supporting other desktop platforms in the future.

In the preceding scenario, the situation gets much worse when a company decides to support PDA. This same phenomenon is also the cause of specialized software development companies. Generally, companies develop software for a specific platform and sometimes port their applications to another platform.

In essence, a human cannot become an expert system-level developer in multiple platforms. Each platform has its own SDK, specialized libraries, system calls, tools and culture. On the other hand, an engineer can in fact develop applications for all platforms, because Z++ is the multi-domain expert for application software. Only software can become multi-domain expert. Until this is comprehended, chaos and confusion will reign.

Z++ formalism demonstrates that the process of developing application software is reducible to an activity similar to the way a composer writes music for an orchestra. A developer need not know anything about system tools of a platform just as a composer need not know how to play the instrument that will turn his/her notes into sounds.

Z++ is freely available from ZHMicro.

Code Mobility

2006-05-04T00:11:00.000-07:00

The difference between empirical knowledge and what we refer to as science is in the body of coherent abstractions comprising a scientific endeavor. The significance of science rests in our ability to apply its abstractions to a large class of related problems.

In order to present the Z++ abstraction for code mobility a small amount of code had to be shown, which is very difficult to present in a blogger. The article “Code Mobility” in PDF format is available from the following link. The article also presents the argument for the Z++ scientific approach and its validity.

Code Mobility and Distributed Computing

Flexibility for remote command processors

2006-04-17T00:25:00.000-07:00

This article illustrates how the command processor of a remote node can be extended. The flexibility attained from such extension and its benefits are also discussed, and a solution is presented.

The essential role of a command processor

Generally, the purpose for which an application is intended determines its interface. Without loss of generality, we may assume that an interface is a command processor. The User Interface may take any form, such as graphical, vocal or some combination of future possibilities. Our focus is on the interface to the application’s engine rather than its user interface. The command processor of an operating system is usually called a shell, while the lower level interface is presented as a set of system calls.

We interact with a remote node, such as a satellite, through a local user interface. However, the actual interaction with the remote node takes place through its command processor. For all practical purposes the command processor of a remote node is a panel of hardware buttons like those on a stereo system.

Extending a command processor

When interacting with an operating system, such as UNIX, we have the luxury of enhancing the shell by adding new commands or entire applications. However, a remote node is not within our reach, unless it appears to us like a local operating system. For UNIX platform the X-Server does some of the latter.

The ability to extend a shell is simply an application of software flexibility versus hardware firmness. Thus, providing the same level of flexibility for the command processor of a remote node is more than plain curiosity. However, achieving a reasonable level of remote flexibility requires an infrastructure, somewhat like a universal operating system.

After some research we observe that for our purposes, a universal abstract operating system does not need to support the full functionality of an operating system that drives a desktop computer. For the sake of conversation, let Z47 stand for an abstraction of a universal operating system that can be deployed on satellites, PDA, mainframes, as well as desktop computers. Let us review the list of expectations from a Z47, which enables us to extend the command processor of a remote node.

Infrastructure for extending remote command processors

First and foremost we expect Z47 to provide us with an interface so we can compose applications (executables), just as we do for UNIX. However, at this era we expect a more formal and expressive language than scripting and interpreted languages. In particular, simple intuitive linguistic constructs should hide the complexity of routine matters like RPC and remote linkage.

Then, Z47 must handle the creation and management of its threads, processes and their intercommunication (IPC). Last but not the least, it should be possible to initiate a process on a remote node just as we are able to load and run executables on a desktop.

The last requirement, that is initiating a process on a remote node, is of particular interest. On a desktop, executables are kept on a permanent storage medium until needed, at which time they are loaded and executed. For a remote node, in our scenario, the local node acts like a storage medium. When needed, an executable is sent to the remote node and executed there.

Extensible command processor

A local node may send an executable to a remote node, and the executable may later request other executables to be uploaded. This makes the remote node appear as local for all practical purposes. Thus, the remote node is no longer an unchangeable black box with a fixed command processor. Instead, new executables can be launched on the remote node just they are launched on our desktop.

Repairing remote defects locally

Having a local node act like a storage medium for a remote node is quite useful. We can fix defects, or enhance components on the local node. In fact, the new version of a component may be uploaded directly, overlaying its previous version. This helps fix a problem found at a later time when the remote node is not physically accessible.

Sprinkling intelligence

An abstraction such as Z47 opens up the door to other desirable possibilities. For instance, so far as an operating system is concerned autonomous agents are applications. Whether or not an application is intelligent is internal to the application itself. The complexity of sending the executable to a remote node and initiating it must be transparent to the application and its developer. That is, it should not matter to the engineer where the actual execution occurs, and how messages are delivered to objects.

The solution

Clearly, Z47 will need a lower, device level operating system in order to interact with physical devices, such as UNIX, Windows, Palm etc. So long as interactions are properly formalized through linguistic patterns of the programming medium supported by Z47, an engineer does not need to deal with the actual operating system. That is the whole purpose of abstraction, and the power of its generality.

Now, Z47 is the processor that powers the Z++ abstract software development language. The relationship between Z47 and Z++ is like that of UNIX and C, except more abstract and thus considerably more general. Comparing Z++ to a language that runs on a virtual machine, like Java or C#, is a misunderstanding of the idea behind Z47 and Z++. As a matter of fact, Z++ as a programming language is a superset of C++, coherently combining the best of ADA, APL and Eiffel.

Conclusion

Z47 is a tiny distributed operating system, about 500K that captures all mechanisms needed for executing applications of any degree of sophistication. Z47 directly supports Z++ just as UNIX supports C. Thus, applications are developed abstract and independent of platform.

Applications composed in Z++ can move to any node in a heterogeneous network and begin execution. This capability provides the infrastructure for distributed components and mobile, or autonomous agents.

Z++ Visual is freely available from ZHMicro.

The evolution of software formalism

2006-04-10T00:41:00.000-07:00

The purpose of this article is to illustrate the nature of software formalism, its historical evolution, and its role in designing and developing application software. In previous articles I have clarified the differences between programming devices, and developing applications. Briefly stated, software applications are abstractions independent of computing devices on which they run.

From this point on the term software will mean application software, as opposed to system programs. A program is a sequence of code composed with focus mainly on the device being programmed. An application, on the other hand, is composed with no attention to any particular device.

Initially, automation was conceived as a direct encoding of algorithms in a programming language, such as FORTRAN. Later, software formalism was conceived as paradigms, such as logic or functional paradigms. Whether object-orientation is a paradigm or not is still a subject for debate.

A scientific formalism goes through several phases. Initially, the process of divesting abstractions takes place over a relatively long period of time. Isolated abstract concepts then begin forming a coherent linguistic medium for expressing problems in a particular domain. Eventually, the medium is enriched with techniques for solving the problems that can be modeled within the formalism. At its final stage of maturity, the formalism is studied for its own sake, dusted and polished.

Software formalism is distinct from mathematical formulations of theories. Nonetheless, it is applied precisely in the same manner as mathematics is applied in modeling real-world problems. An application is composed of loops, selections, threads, components and template patterns, in the same sense that a theory is formulated in terms of tangents, derivatives and differential equations.

An important aspect of formalism is its ability to grow monotonically in order to extend the scope of its problem domains. Unlike mathematics, however, software applications are sensitive to fluctuations in the linguistic medium of formalism. Presently, we have reached the proper understanding of a reasonable formalism for all conceivable domains of applications. There is no scientific or technological reason for the existence of languages supporting a certain set of devices or platforms.

The discoveries of the past few decades indicate that future extensions will not contradict our current view of abstractions. Instead, new abstractions will be orthogonal to the existing ones, and the formalism will continue to grow monotonically. For instance, object-orientation extends the notion of abstract data type, and component-orientation is orthogonal to object-orientation.

Developers build metal patterns for techniques that they learn or create. Patterns are linguistic entities associated with metal images corresponding to relevant abstractions. When learning software engineering, initial patterns are almost identical to the linguistic constructs of the language providing the medium for software formalism. However, even the patterns of an experienced engineer resemble the statements of some programming language.

It goes without saying that learning patterns in English and implementing software in French is not an ideal scenario. For instance, geometrical figures provide a natural medium for dealing with patterns in geometry, while equations are more natural for dealing with algebraic patterns. However, in terms of programming, algebra and geometry interoperate with no consideration for incompatibility.

Attempting to map a pattern to different languages will result in unavoidable defects. Unlike other branches of engineering, a book of patterns illustrated with pseudo-code is not the proper way to train software engineers. The state of software formalism is quite mature and ready for a linguistic approximation. The programming language Z++ approximates the software formalism quite closely. This closeness of medium and formalism avoids the English/French effect in software development.

Z++ is a monotonic linguistic foundation for future research, just as it is a firm abstract medium for developing platform independent applications.

Z++ is freely available from ZHMicro.