text:
User:Vuara/Protothought

http://www.ling.ed.ac.uk/~jim/berlin.paper.html

Protothought had no logical names

James R Hurford, Language Evolution and Computation Research Unit, Linguistics Department, University of Edinburgh In New Essays on the Origin of Language edited by Jürgen Trabant. Mouton de Gruyter, Berlin. pp.119-132. Note: This HTML version may differ slightly from the printed version; the printed version is the `authorized' version.)

1 Introduction

The evolutionary history of any complex system, such as human cognition, or the human language capacity, necessarily starts with something simpler1. It is accepted as a working hypothesis that a precursor of modern human capacity for complex syntactic language was a capacity for protolanguage (Bickerton, 1990), a kind of communication system with no syntax. In protolanguage, although words may have been uttered in short sequences, there were no rules defining wellformedness of strings, and therefore words in protolanguage could not be said to belong to separate syntactic classes, such as Noun or Verb.

A view commonly encountered about the emergence of true syntactic language is that, during the protolanguage period, there existed a somewhat complex system of mental representation, capable of representing the structure of events with their participant agents and patients. In this view, the move to syntactic language was in large part an externalization of this pre-existing system of representation. ``The mechanism [of syntax] was there all the time, but it was not being used for language.'' (Bickerton, 1998:350) Let us call such a system of mental representation `protothought'. It is often assumed that the structure of this protothought was something like Predicate Calculus (but possibly without quantifiers).

2 Predicate Logic, Semantics and Psychology

Assuming something like a modern Predicate Calculus form of mental representation for our pre-linguistic ancestors actually attributes to them at least a five-way distinction between types of atomic mental entities, as the following simple formulae illustrate.

CAME(john)      [translation: `John came']

x[TALL(x) & MAN(x) & CAME(x)] [translation: `A tall man came']

In such representations, one has to distinguish the following types of atomic element, each of which functions in the representations in a distinctive way and relates to external meanings in a distinctive way:

 * predicates (e.g. CAME, TALL),
 * individual constants (e.g. john),
 * individual variables (e.g. x),
 * connectives (e.g. &),
 * quantifiers (e.g. ).

The proposals which derive the basics of modern syntactic structure from such pre-linguistic mental representations are seldom fully explicit on points of detail, but typically seem to assume that individual constants are the evolutionary sources of Proper Nouns, and perhaps also of Common Nouns, while the predicate constants are the sources of Verbs. One account which is completely explicit on this point is found in the computer models of Kirby (2000a, 2000b), and here is it clear that individual constants are the evolutionary source of what emerge as Proper Nouns, and predicate constants the source of Verbs.

Such an apparatus for prelinguistic mental representation is implausibly rich. I will argue that a reduced apparatus is more plausible. Specifically, in the proposed less complex format for mental representations, there are only

predicates individual variables, but no individual constants, just one connective, namely conjunction, `&' just one quantifier, the existential, `', implicit in all representations. The implication of this proposal is that formulae such as the first given above, CAME(john), were not available as pre-linguistic mental representations, specifically because they contain individual constants. Why do I believe that individual constants cannot be justified as elements of mental representation pre-existing language? A brief look at the place of Predicate Logic in modern scholarship will help to set the scene.

The originators of modern logical calculi did not intend them to be taken as psychological entities in any way. Frege, for example, was averse to `psychologism', believing that the private concepts of individual people are beyond investigation. The central tradition stemming from Frege interprets logical formulae by a direct relationship with a presumed objectively given world, thus bypassing any psychological stage which might be located in the mind/brain of a user. In this view, meaning is a relation between (logical) language and the world; no mind intervenes or mediates in this relationship between language and the world. ``According to Montague, the syntax, semantics and pragmatics of natural languages are branches of mathematics, not of psychology.'' (Thomason, 1974:2) This approach to meaning has been characterized (and criticized) by Lakoff (1988:119-154) as `objectivist semantics'.

The designers of the Predicate Calculus assumed, surely correctly, that the world contains individual objects, such as the sun, the moon, particular people, dogs, cats, tables and chairs and so forth. These individual objects are the denotata of the individual constants in logical formulae, such as john. Since, in this tradition, no minds mediate the relation between language and the world, the function which assigns denotations to individual constants is merely stipulated; it is typically explained by the author of a text on logic with enough ordinary-language prose to make the idea of an inherent, or stipulated, link between the logical name and the object it denotes clear enough to the reader. Often, the author conjures up some fictitious little world, with fictional characters in it, and can be confident that a reader will get the idea. Textbooks2 and more advanced accounts of meaning in logic assume that giving a real semantics to sentences involves mapping them to an assumed objective world, without involving any psychological entities such as concepts, thoughts or ideas.

When linguists began to build generative models of languages including their semantics, it seemed appropriate to assume that the classical and simple languages of logic, such as Predicate Calculus, could be taken in their entirety and used as mental representations of meaning, much as standard IPA phonetic transcriptions can be used to represent pronunciation. Generative grammar, as indeed most modern schools of linguistics, aims to model linguistic competence, that is psychological representations of language in speakers' heads. But it cannot be safely assumed that a formalism, such as Predicate Logic, that was not designed to suit psychologistic purposes, will be appropriate for such purposes. A semanticist who accords psychological reality to semantic representations (e.g. logical formulae), faces not only the task of stating what in the world the components of these representations map onto, but also the task of accounting for how these mappings could come to be known by the language user.

Theorists of language evolution who assume something like Predicate Calculus representations pre-existing language in the minds of early hominids also face the problem of accounting for the mappings between the mental entities, such as predicates and individual constants, and parts of the world. An account of how mental predicates (e.g. LITTLE, GREEN, MAN) come to be mapped onto properties of the world is, I claim, relatively unproblematic, whereas an account of how mental individual constants (e.g. john, mary) come to be mapped onto particular individuals is, I will argue, impossibly problematic.

3 Perception and Cognition of Objects

It is crucial to distinguish between perception and cognition. Mental representations of events and their participants are involved differently in these two psychological processes. Let us start with perception, or more precisely `perception-as'.

3.1 Perception

3.1.1 Unfocussed perception

Some experiences come uninvited. A creature may notice a particular smell, or feel cold, or hear thunder. In prelinguistic hominids, these experiences would undoubtedly have caused different reactions, and can be regarded as separate mental predicates whose denotations are the classes of stimuli giving rise to them. In hearing thunder, or noticing a smell, the perceiver perceives only the smell or the thunder; no other object or person is perceived. Such perceptions can be represented schematically as isolated zero-place predicates, as in

SMELL31

COLD

THUNDER

These could be paraphrased in modern English as `There is a certain smell (around here)', `It's cold', and `Ah, thunder'. Note the lack of any contentful grammatical subjects in these paraphrases.

If the creature has no language, there is no question of these categories being connected with any words. I assume that non-linguistic creatures have representations which involve mental categories, and that they are able to judge whether or not perceived objects belong in these categories. Such mental categories are partitions of an innately given structured space of possible categories, acquired through experience. Activation of different categories, whether by immediate experience or by rumination, will stimulate different patterns of behaviour; this is what enables non-linguistic creatures to behave systematically in relation to the world. Our imagined creature carries such categories as SMELL31, COLD, and THUNDER in its mind somehow. Their existence in its mind has been distally triggered by its previous experiences. In the act of perception, these categories are reactivated.

3.1.2 Attending to perceived objects

We now bring particular objects into the discussion. For concreteness, let's say a creature looks, with some attentive deliberation, at a fresh green sycamore leaf. In this case, the focus of attention is the leaf itself, which is an object in the world. In attending to it, and judging it to be a green leaf, the creature applies certain mental categories to it, which we can relatively safely represent as the mental predicates GREEN and LEAF. Let us assume that this much is possible, the creature's species having evolved to be able to recognize greenness and the class of leaves.

Just as with thunder and coldness, the categories GREEN and LEAF are carried in the creature's mind somehow, having been planted there by its previous contacts with the world. In the act of perceiving a green leaf, these mental categories are brought to bear on an object of attention in the external world. It is natural, for illustrative purposes, to represent the principal elements in such an act of perception by a formula such as3:

GREEN(x) & LEAF(x)

where x denotes the real-world object attended to, and the predicates correspond to the mental categories which the creature judges to apply to this object. Such a formula, then, has a mixed, partly external objective, partly mental, semantics. This is appropriate, because an episode of `perception-as' is an encounter between mental categories and real-world objects. The x in the formula is essentially deictic (or `indexical'). It is not the constant name of any particular object. It only stands, in this convenient expository representation of an act of perception, for whatever object happens to be the object of perception. If, on yet another occasion, the creature sees a different green leaf, the same representation as before, `GREEN(x) & LEAF(x)', would be appropriate, as this is another act of perceiving an object as a green leaf. If I may call this x a variable, it is attention that associates the variable with a real perceived object in the world.

The same mental predicate can be either a zero-place predicate or a one-place predicate, depending on whether the stimulus comes from an object to which the perceiver is attending. Thus if the creature deliberately sniffed the leaf, its perception might also include SMELL31(x).

There is a fuzzy borderline between attention to a specific object and awareness of ambient impressions. Attention involves selection of one source of stimulation over others which have an equally good chance of being selected, or attended to. A creature might decide to have a good look at a hole in a tree, as opposed to the tree's bark, or an upper branch. A hole in a tree is something of a size that one can reasonably pay selective attention to. Compare this with a large cave, especially one in which the creature is sitting. As the cave is all around it, it is not clear whether to count a perceptual judgement about the cave as an unfocussed perception or the perception of an object attended to, that is whether this should be represented as4

DARK(x) & CAVE(x) & SMELLY(x)

or as

DARK & CAVE & SMELLY

It will pose no problem to the account proposed here if we allow that mental representations cannot be fully determined, or theorized about, in all cases. Either the creature represents its perceptions as simply ambient (the zero-place case) or more specifically about the place it is sitting in, as opposed to some other place it has chosen not to attend to (the one-place case).

3.2 Cognition: Representing previously perceived objects

We move now to cognition. The important aspect of cognition, for our purposes, is the memory, or store, of experiences which are no longer current. Consider how the non-linguistic creature, while not actually perceiving a green leaf, stores in memory the fact that it did once see a green leaf. When objects are no longer attended to, the association of an external object with an attention variable is lost, because it is the very act of attention which brings about this association. In the transition from perception to cognition (i.e. the process of putting into memory), then, the variable loses its former (extensional) meaning. The creature can remember that it once had a `GREEN(x) & LEAF(x)' experience, but there is now nothing pointing, as attention once did, to the object itself. The closest that Predicate Calculus can get to this is formulae with existential quantifiers, like:

For any x [GREEN(x) & LEAF(x)]

For any x [DARK(x) & DAMP(x) & SMELLY(x) & CAVE(x)]

The second formula here might be paraphrased as `(I remember) there was a dark damp smelly cave'. Memory of complex experiences (but not involving more than one object) is captured by conjunctions of such atomic proposition-predicates. Each conjunction, or bundle of features, is a separate entry in the mental database, a memory of a separate experienced event.

Implicit in this account, and the central plank of the whole argument, is the theme that in prelinguistic cognition there are no components of mental representation with the logical status of individual constants, i.e. elements that, as the philosophers say, allow their possessors to re-identify particulars with absolute reliability.

3.2.1 There are No Particulars in Animal Cognition

The individuals most important us are our near kin, mothers and babies. The following quotation demonstrates the prima facie attraction of the impression that animals distinguish such individuals, but simultaneously gives the game away.

“The speed with which recognition of individual parents can be acquired is illustrated by the `His Master's Voice' experiments performed by Stevenson et al. (1970) on young terns: these responded immediately to tape-recordings of their own parents (by cheeping a greeting, and walking towards the loudspeaker) but ignored other tern calls, even those recorded from other adult members of their own colony.” (Walker, 1983:215)

Obviously, the tern chicks in the experiment were not recognizing their individual parents --- they were being fooled into treating a loudspeaker as a parent tern. For the tern chick, anything which behaved sufficiently like its parent was `recognized' as its parent, even if it wasn't. The tern chicks were responding to very finely-grained properties of the auditory signal, and apparently neglecting even the most obvious of visual properties discernible in the situation. In tern life, there usually aren't human experimenters playing tricks with loudspeakers, and so terns have evolved to discriminate between auditory cues just to the extent that they can identify their own parents with a high degree of reliability. Even terns presumably sometimes get it wrong. “ ... animals respond in mechanical robot-like fashion to key stimuli. They can usually be `tricked' into responding to crude dummies that resemble the true, natural stimulus situation only partially, or in superficial respects.” (Krebs and Dawkins, 1984:384)

A creature can appear to recognize a particular individual reliably if it gets sensory impressions which are fine-grained enough to distinguish this individual from others with which it is likely to come into contact. To manage successfully in `recognizing its mother', a creature need not have a mental distinction between individual and property; all that is needed is the ability to distinguish just the set of properties which in practice differentiates its mother from other candidates.

English dictionaries often distinguish two senses of the word recognize, as below:

1 If you recognize someone or something, you know who someone is or what someone is when you see them or hear them, because you have seen them or heard them before. EG She didn't recognize me at first ... 2 If you recognize something ... you are able to identify it when you see it, for example because you have learned about it or had some previous exoerience of it. EG They are specially trained to recognize the symptoms of radiation sickness ... There was a field planted with what he recognized as maize. (Collins Cobuild English Dictionary) This lexicographic distinction rests on the ontological distinction between individuals (or particulars5 ) and universals. The central claim here is that prelinguistic creatures could not have had mental representations containing elements corresponding to particular individuals; they could only recognize things in sense 2 above, but not in sense 1.

3.2.2 Individual particulars, universal properties

Prelinguistic creatures could not have been able to reidentify particulars with absolute reliability, because, in fact, neither can we. Given what we know about the world, it is, in the limit, impossible. This is not to deny that much of the time we are quite successful at reidentifying particulars, especially where it matters. But situations where reidentification is impossible are also common. For instance, every morning I pick up a bottle of milk from my doorstep. If I have a backlog of undrunk milk from previous days, I add today's bottle to the two or three that are already in the fridge in a particular spatial sequence, so that I know which is which. If someone disturbs my milk filing system, then I no longer know which is which, because I cannot reidentify particulars6. Where it really matters to us to keep individuals apart, we either mark them somehow (as with my milk filing system), or we develop more refined perceptual categories, so that we can remember the difference between individuals in terms of their slightly different properties. This presumably why humans are so proficient at face-recognition. But it is both impossible and unnecessary to refine ones perceptual categories to the point where every individual object is distinguishable from all others. One paperclip is much the same as another, as are sheets of paper, grains of sand, freshman students, and so on.

The argument above has concentrated on the difficulty with logical individual constants as components of mental representations. The impression may have been given that logical predicates are not problematic in the same way. Philosophers have emphasized to me that, in the limit, predicates are also subject to similar problems. Putnam's Twin Earth argument (Putnam, 1975:223-247) establishes that there could be objectively (i.e. from a God's eye view) two different sorts of stuff that we label water. Our concept of water could fit both kinds of stuff, and the stuff that is chemically XYZ could, to all intents and purposes, serve exactly the same range of purposes as the stuff that is chemically H2O. We wouldn't know the difference. In Putnam's (1975:222) words, ``Extension is not determined by psychological state''.

There is, however, a great practical difference between an ability to reidentify particulars (such as the very lion who was stalking me yesterday) and an ability to reidentify universals (such as lions in general), and hence a great practical difference between individual constants and predicates.

Invariant factors in the environment in which humans have evolved have given rise to our perceptual space, and the discriminability of regions within it. The species has evolved to see just the colours it can see, hear just the sounds it can hear, smell just the sounds it can smell, and so forth. Despite some individual variation, the same inputs from the world trigger broadly similar perceptions in everyone, across a wide range of possible inputs. More importantly, there are relatively few cases in which objectively7 disjoint stimuli trigger the same perception. Putnam mentions such a case: ``Although the Chinese do not recognize a difference, the term `jade' applies to two minerals: jadeite and nephrite. Chemically, there is a marked difference. Jadeite is a combination of sodium and aluminum. Nephrite is made of calcium, magnesium, and iron. These two quite different microstructures produce the same unique textural qualities!'' (Putnam, 1975:241) Examples such as it jade pose no problem for a theory that prelinguistic creatures could have had mental predicates corresponding to various classes of stimuli. Their mental predicates would have had a perceptual and functional basis. If it looks like a duck, sounds like a duck, smells like a duck, feels like a duck and tastes like a duck, it is a duck.

Properties are procedurally prior to individuals. That is, we use an object's properties to try to determine which individual it is. We humans are often obsessed by this question of which individual is presenting itself to us. We can never be certain, but we get as close as we can by finer and finer subclassifications of the properties we are observing. In life's ongoing calculation of `what is happening', the fundamental empirical premises are the properties which the world presents to us. The conceptual identities of individuals appear only in our conclusions.

Central to the concept of an individual are the related ideas of uniqueness and spatiotemporal continuity. These are not part of the idea of a property. Many things are red, in different places at the same time. But an individual cannot be in two places at once. Consequently, the evidence needed to assign the same property (a mental predicate) on different occasions is weaker than the evidence needed to conclude that something is the very same individual. To assign a property, in many cases all we need is the evidence of our senses. ``No doubt about it, this is green.'' But without keeping a constant eye on an object, or insulating it somehow, we can never be sure that it hasn't been replaced by a twin, a different individual.

3.3 Language hints at knowable identity

Modern human languages contain devices which are interpreted as if the reidentification of particulars posed no problem. Proper names are the prime example. But in fact our ordinary usage with proper names is more rough and ready than the usage of logicians with individual constants. We all know many people called Jim, and usually the context of the speech situation clarifies which Jim we are talking about. Thus Jim is in fact only a shorthand for whichever of the people who have been regularly labelled `Jim' in the experience of the interlocutors is most salient in this context. Clearly, Jim in English does not pick out a single individual, though doubtless there are some rare names which do happen to pick out single individuals. But we would not wish to distinguish logically or grammatically between different proper names on the basis of their relative rarity of application. Markers of definiteness, like English the, are also basically shorthand for whichever of the things concerned is most salient in this context.

Individual objects are less enduring over time than properties. The objects to which proper names are most commonly attached, namely people, only live for a few generations. But almost all of the properties which we see in an individual person can be seen, in different combinations, in other people, long before and long after the brief span of the particular individual. Ars longa, vita brevis might be adapted to the case of properties and particulars, which is related to why, in philosophical discussion, properties are often called `universals'. The relative impermanence of particulars, as opposed to properties, undermines the utility of constant expressions for particulars in the continuing language of a community. Place-names are the most useful designators of enduring individual objects in modern languages, but our early ancestors would have had much less use for fixed place-names than we have. In any case, there is evidence that in modern languages, all place-names in fact derive historically from descriptions, that is from expressions involving property-terms, like the dark pool or the new castle. Probably, all person-names are ultimately so derived as well.

Linguistic devices suggest that humans are capable of mentally representing unique individuals, using the mental equivalent of logical individual constants. We might even grant, for the sake of this argument, that modern humans do have this capacity. But it is only language that pushes us toward this conclusion. Without an insight into our language, an outside observer of modern human behaviour could not tell that we are able to mentally represent particular individuals. We, in our turn, when we consider the minds of non-linguistic creatures, must adopt the simplest hypothesis compatible with the observed facts. There is no need to hypothesize mental individual constants in animal minds. When animals respond systematically to impressively finely graded stimuli, even to the extent of reliably recognizing what we human observers believe to be unique individuals, there is no need to postulate a special category of mental representation, individual constants. Finely graded predicates, or alternatively, conjunctions of less finely graded predicates, will do the job.

4 Social life without individual constants

We are considering the emergence of language with modern characteristics from pre-existing cognitive capacities in pre-linguistic creatures. I hope to have made the case that the cognitive representations available to pre-linguistic hominids for remembering the events of their lives are most unlikely to have contained the equivalent of logical individual constants. A more plausible form of pre-linguistic mental representation would have had only predicates, individual variables, a conjunctive connective and an implicit existential quantifier. The baby australopithecine or habiline would have had many stored memories of episodes involving its mother, many containing a form something like this:

SMELL31(x) & SQUAWK7(x) & WARM(x) & CUDDLY(x)

(Here and henceforth, the existential quantifier is omitted from such representations, as it can be taken as implicit. The variables, however, cannot be eliminated, as they are needed for representing memories of events involving several different objects.)

Our immediate prelinguistic ancestors certainly had complex social lives, as do modern chimpanzees. Expressing it in modern human terms, they remembered who were their friends and enemies, who was whose child, who had recently fought with whom, and who had groomed whom. But the whos in this last sentence tend to impose our modern logical analysis on the animals' behaviour. It is possible, with finely graded predicates, to represent as accurately as is necessary any of the information that australopithecines or habilines would have stored about members of their social group. That this is generally true is shown by a transformation that one can apply to any first-order logical formula containing individual constants, replacing the constants by corresponding (suitably fine-grained) predicates. For example,

CAME(john)

can be replaced by

CAME(x) & JOHN(x)

where JOHN is a predicate which is only satisfied by one individual. Of course, expressing it in terms of a predicate being ``only satisfied by one individual'' is again to express things from a modern, language-informed perspective. To a pre-linguistic hominid, as to a tern chick, it was only important that the mental predicate be specific enough to be reliable in all the circumstances in which it was likely to be used.

Two-place predications involving different individuals can be handled in this way, but with distinct variables. Thus Kanzi is Panbanisha's child could be represented as

KANZI(x) & PANBANISHA(y) & CHILD(x, y)

Clearly, representations without individual constants are sufficient to account for the Machiavellian intelligence of apes.

It is assumed here that our prelinguistic ancestors were capable of forming associations between different concepts, allowing inferences between thoughts involving different predicates. Thus

SMELL14(x) EDIBLE(x)

might have been a mental rule useful in foraging. Similarly, `portmanteau' predicates could have been created, abbreviating longer conjunctions of more basic predicates. Thus the baby australopithecine we mentioned earlier could have had a rule such as

[SMELL31(x) & SQUAWK7(x) & GAIT12(x)] MOTHER(x)

5 So what? How does this argument relate to other issues in the evolution of language?

The origin of syntax is a central problem. At the heart of syntactic structure is the Subject-Predicate dichotomy. So any claim about the origin of the Subject-Predicate dichotomy is central to theorizing about the origins of modern human language.

There are two tendencies in the search for explanations of features of language, whether these are evolutionary or otherwise. One tendency is to look in the direction of possibly innate, not necessarily communicatively functional, characteristics of the minds which gave rise to language. Bickerton, in particular, has stressed the representational function of language, as opposed to its communicative function. Accounts of the rise of Subject-Predicate structure from the `pre-existing representation' point of view assume a pre-existing dichotomy between two types of concepts, a predicate type, and a subject (or argument) type; individual constants are the principal instances of concepts of the subject/argument type. In this view, pre-existing propositional representations of Subject-Predicate form get rather straightforwardly translated into linguistic clauses with corresponding structure.

Such proposals push the question of the origin of Subject-Predicate structure back into pre-linguistic representations, and that is considered far enough to absolve the proposers from further explanation. But, as I claim to have shown, it is unnecessary to attribute such pre-existing mental structure to prelinguistic creatures; they could have got along fine without it, and so they probably did not have it.

The opposing tendency in linguistic explanation is to appeal to communicative function. Communicative function cannot be a consideration relevant to pre-linguistic (or pre-communicative) mental structure. Pressure from communicative function can only arise once mental representations are externalized in public conventionalized symbols. From this perspective, an alternative explanation for the origin of Subject-Predicate structure is communicatively functional Topic-Comment structure. It must be emphasized that Topic and Comment are not categories of classical (modern) logical systems. Topic and Comment are categories rooted in pragmatics, in the shared knowledge of speakers and hearers, and thus are not, and never have been, the concern of truth-conditionally oriented logicians.

The argument presented in this paper has been largely negative. I have argued that our prelinguistic ancestors could not have represented the world in terms of formulae involving individual constants, where these individual constants were destined to become the evolutionary antecedents of modern referring expressions by a process of externalization into public language.

This negative argument is a prelude to a positive argument, in which a mechanism will be shown whereby essentially communicative pressures gave rise to the emergence of modern Subject-Predicate structure, based on prior representations in which the only constants were predicates. In brief, some predicates became selected as prototypically serving a Topic function, while others became selected as prototypically serving a Comment function. And this happened concurrently with the emergence from protolanguage of longer, more coherent strings of words.

But, for now, that is another story.

Endnotes This is not to deny that evolution can sometimes simplify. But the dominant evolutionary trend is from simple to complex; and the original proto-systems were undoubtedly simple.

E.g. Cann, 1993; Guttenplan, 1997; McCawley, 1981.

To the best of my knowledge, the first use of such formulae, suggested as prelinguistic representations of meaning, is in Batali (2000).

For simplicity, I allow the connective & to conjoin more than two conjuncts; as we will not be dealing with disjunction, this will not affect the argument at all.

I use the terms interchangeably here.

My dairy does not datestamp its products.

Objectively, to the best of our current scientific knowledge, that is.

References

Batali, John 2000 The negotiation and acquisition of recursive grammars as a result of competition among exemplars. In Briscoe, E.J. (ed.) Linguistic Evolution through Language Acquisition: Formal and Computational Models. Cambridge: Cambridge University Press.

Bickerton, Derek 1990 Language and Species. Chicago: University of Chicago Press.

Bickerton, Derek 1998 Catastrophic evolution: the case for a single step from protolanguage to full human language. In Hurford, J.R., M.Studdert-Kennedy, and C.Knight (eds.), Approaches to the Evolution of Language: Social and Cognitive Bases, 341-358. Cambridge: Cambridge University Press.

Cann, Ronnie 1993 Formal Semantics. Cambridge: Cambridge University Press.

Guttenplan, Samuel 1997 The Languages of Logic, 2nd edition. Oxford: Blackwells.

Kirby, Simon 2000a Learning, bottlenecks and the evolution of recursive syntax. In Briscoe, E.J. (ed) Linguistic Evolution through Language Acquisition: Formal and Computational Models. Cambridge: Cambridge University Press.

Kirby, Simon 2000b Syntax without natural selection: how compositionality emerges from vocabulary in a population of learners. In Knight, C., M. Studdert-Kennedy and Hurford, J.R. (eds) The Evolutionary Emergence of Language: Social Function and the Origins of Linguistic Form, 302-323. Cambridge: Cambridge University Press.

Krebs, John R., and Richard Dawkins 1984 Animal signals: mind-reading and manipulation. In Krebs, J.R. and N.B.Davies (eds) Behavioural Ecology: an Evolutionary Approach. Oxford: Blackwell Scientific Publications.

Lakoff, George 1988 Cognitive semantics. In Eco, U., M. Santambrogio and P. Violi (eds), Meaning and Mental Representations. 119-154. Bloomington: Indiana University Press.

McCawley, James D. 1981 Everything that Linguists have always Wanted to Know about Logic, but were afraid to ask, Oxford: Blackwells.

Putnam, Hilary 1975 The meaning of `meaning'. In Gunderson, K. (ed.) Language, Mind and Knowledge, Minnesota Studies in the Philosophy of Science, VII, University of Minnesota Press. Reprinted in Putnam, H. 1975 Mind, Language and Reality: Philosophical Papers, Volume 2, 215-271. Cambridge: Cambridge University Press.

Stevenson, J., R.E.Hutchison, J.Hutchison, B.L.R.Bertram, and W.H.Thorpe 1970 Individual recognition by auditory cues in the Common Tern (Sterna hirundo), Nature, 226:562-563.

Thomason, Richard 1974 Introduction to Thomason, R. (ed.) Formal Philosophy: Selected papers of Richard Montague. New Haven: Yale University Press.

Walker, Stephen 1983 Animal Thought London: Routledge and Kegan Paul.

Acknowledgements

This work was supported by grant [No.R000237551] from the UK Economic and Social Research Council, and by a Fellowship at the Collegium Budapest Institute for Advanced Study. I have benefitted from helpful comments and advice from John Batali, Manfred Bierwisch, Peter Carruthers, Terry Deacon, Daniel Dor, Dan Nettle, Bruce MacLennan, Luc Steels, and Paul Taylor, but don't blame them for any faults in the paper.

title: User:Vuara/Protothought


text:
User:Vuara/New Essays on the Origins of Language

http://www.isbn.nu/toc/3110170256

New Essays on the Origins of Language

Table of contents

Introduction: New perspectives on an old academic question Jurgen Trabant 1

Biological aspects of the question On the subcortical bases of the evolution of language Philip Lieberman 21 Origin of the human language faculty: the language amoeba hypothesis Eors Szathmary 41

The first language

The apparent paradox of language evolution: can Universal Grammar be explained by adaptive selection? Manfred Bierwisch 55 Elementary forms of linguistic organisation Wolfgang Klein 81 From potential to realisation: an episode in the origin of language Bernard Comrie 103 Protothought had no logical names James R. Hurford 119 The birth of rules Jean Aitchison 133 How language changed the genes: toward an explicit account of the evolution of language Daniel Dor and Eva Jablonka 149

Beyond biolinguistics

The narration "instinct": signalling behaviour, communication, and the selective value of storytelling Volker Heeschen 179 Taxonomic controversies in the twentieth century Merritt Ruhlen 197 The origin of origins: a play in five acts, with a prologue im Himmel and an epilogue auf der Erde Henri Meschonnic 215

References 229 Index 257

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
User:Vuara/David Peat

http://www.paricenter.com/library/readinglists/newscience.php

David Peat's books:

The Blackwinged Night: Creativity in Nature and Mind, Helix Books, Cambridge, Mass, 2000

Synchronicity: The Bridge between Matter and Mind, Bantam Books

Blackfoot Physics, Fourth Estate, London. (The US edition of this book, entitled Lighting the Seventh Fire is now out of print. A new, updated version will be published soon by Phanes Press.)

Infinite Potential: The Life and Times of David Bohm, Addison Wesley

Co authored with John Briggs

Looking Glass Universe, Touchstone Books

Turbulent Mirror, Harper Collins

Co-authored with David Bohm

Science, Order and Creativity (second edition, 2000), Routledtge

David Bohm, Science and the Implicate Order, Routledge

A series of interviews with scientists can be found in

Glimpsing Reality: Ideas in Physics and the Link to Biology Eds. Paul Buckley and F. David Peat, University of Toronto Press, Toronto.

title: User:Vuara/David Peat


text:
User talk:Cconceicao

Hello there! And welcome to Wikibooks. Can you work out any differences with the other Javscript contributors, and merge the Javascript and JavaScript articles into a single, clean article? Thank you. (:  Sj 08:59, 10 Aug 2004 (UTC)

title: User talk:Cconceicao


text:
Oracle Database/SQL Cheatsheet

This "cheat sheet" covers most of the basic functionality that an Oracle DBA needs to run basic queries and perform basic tasks. It also contains information that a PL/SQL programmer frequently uses to write stored procedures. The resource is useful as a primer for individuals who are new to Oracle, or as a reference for those who are experienced at using Oracle.

A great deal of information about Oracle exists throughout the net. We developed this resource to make it easier for programmers and DBAs to find most of the basics in one place. Topics beyond the scope of a "cheatsheet" generally provide a link to further research.

Other Oracle References
 * Oracle XML Reference—the XML reference is still in its infancy, but is coming along nicely.

SELECT
The SELECT statement is used to retrieve rows selected from one or more tables, object tables, views, object views, or materialized views.

SELECT INTO
Select into takes the values name, address and phone number out of the table employee, and places them into the variables v_employee_name, v_employee_address, and v_employee_phone_number.

This only works if the query matches a single item. If the query returns no rows it raises the  built-in exception. If your query returns more than one row, Oracle raises the exception.

INSERT
The INSERT statement adds one or more new rows of data to a database table.

insert using the VALUES keyword

insert using a SELECT statement

DELETE
The DELETE statement is used to delete rows in a table.

deletes rows that match the criteria

UPDATE
The UPDATE statement is used to update rows in a table.

updates the entire column of that table

updates the specific record of the table eg:

updates the column invoice as paid when paid column has more than zero.

SEQUENCES
Sequences are database objects that multiple users can use to generate unique integers. The sequence generator generates sequential numbers, which can help automatically generate unique primary keys, and coordinate keys across multiple rows or tables.

CREATE SEQUENCE
The syntax for a sequence is:

For example:

ALTER SEQUENCE
Increment a sequence by a certain amount:

Change the maximum value of a sequence:

Set the sequence to cycle or not cycle:

Configure the sequence to cache a value:

Set whether or not to return the values in order

Generate query from a string
It is sometimes necessary to create a query from a string. That is, if the programmer wants to create a query at run time (generate an Oracle query on the fly), based on a particular set of circumstances, etc.

Care should be taken not to insert user-supplied data directly into a dynamic query string, without first vetting the data very strictly for SQL escape characters; otherwise you run a significant risk of enabling data-injection hacks on your code.

Here is a very simple example of how a dynamic query is done. There are, of course, many different ways to do this; this is just an example of the functionality.

Length
Length returns an integer representing the length of a given string. It can be referred to as: length b, length c, length 2, and length 4.

length( string1 );

SELECT length('hello world') FROM dual; this returns 11, since the argument is made up of 11 characters including the space

SELECT lengthb('hello world') FROM dual; SELECT lengthc('hello world') FROM dual; SELECT length2('hello world') FROM dual; SELECT length4('hello world') FROM dual; these also return 11, since the functions called are equivalent

Instr
Instr (in string) returns an integer that specifies the location of a sub-string within a string. The programmer can specify which appearance of the string they want to detect, as well as a starting position. An unsuccessful search returns 0.

instr( string1, string2, [ start_position ], [ nth_appearance ] )

instr( 'oracle pl/sql cheatsheet', '/'); this returns 10, since the first occurrence of "/" is the tenth character

instr( 'oracle pl/sql cheatsheet', 'e', 1, 2); this returns 17, since the second occurrence of "e" is the seventeenth character

instr( 'oracle pl/sql cheatsheet', '/', 12, 1); this returns 0, since the first occurrence of "/" is before the starting point, which is the 12th character

Replace
Replace looks through a string, replacing one string with another. If no other string is specified, it removes the string specified in the replacement string parameter.

replace( string1, string_to_replace, [ replacement_string ] ); replace('i am here','am','am not'); this returns "i am not here"

Substr
Substr (substring) returns a portion of the given string. The "start_position" is 1-based, not 0-based. If "start_position" is negative, substr counts from the end of the string. If "length" is not given, substr defaults to the remaining length of the string.

substr( string, start_position [, length])
 * returns "pl/sql" since the "p" in "pl/sql" is in the 8th position in the string (counting from 1 at the "o" in "oracle")

 * returns "cheatsheet" since "c" is in the 15th position in the string and "t" is the last character in the string.

 * returns "cheat" since "c" is the 10th character in the string, counting from the end of the string with "t" as position 1.

Trim
These functions can be used to filter unwanted characters from strings. By default they remove spaces, but a character set can be specified for removal as well.

trim ( [ leading | trailing | both ] [ trim-char ] from string-to-be-trimmed ); trim ('  removing spaces at both sides     '); this returns "removing spaces at both sides"

ltrim ( string-to-be-trimmed [, trimming-char-set ] ); ltrim ('  removing spaces at the left side     '); this returns "removing spaces at the left side    "

rtrim ( string-to-be-trimmed [, trimming-char-set ] ); rtrim ('  removing spaces at the right side     '); this returns "  removing spaces at the right side"

Create table
The syntax to create a table is: CREATE TABLE [table name] ( [column name] [datatype], ... ); For example:

Add column
The syntax to add a column is: ALTER TABLE [table name] ADD ( [column name] [datatype], ... ); For example:

Modify column
The syntax to modify a column is: ALTER TABLE [table name] MODIFY ( [column name] [new datatype] );

ALTER table syntax and examples:

For example:

Drop column
The syntax to drop a column is: ALTER TABLE [table name] DROP COLUMN [column name]; For example:

Displaying constraints
The following statement shows all constraints in the system:

Selecting referential constraints
The following statement shows all referential constraints (foreign keys) with both source and destination table/column couples:

Setting constraints on a table
The syntax for creating a check constraint using a CREATE TABLE statement is:

CREATE TABLE table_name (    column1 datatype null/not null,     column2 datatype null/not null,     ...     CONSTRAINT constraint_name CHECK (column_name condition) [DISABLE] ); For example:

Unique Index on a table
The syntax for creating a unique constraint using a CREATE TABLE statement is:

CREATE TABLE table_name (    column1 datatype null/not null,     column2 datatype null/not null,     ...     CONSTRAINT constraint_name UNIQUE (column1, column2, column_n) );

For example:

Adding unique constraints
The syntax for a unique constraint is:

ALTER TABLE [table name] ADD CONSTRAINT [constraint name] UNIQUE( [column name] ) USING INDEX [index name];

For example:

Adding foreign constraints
The syntax for a foregin constraint is:

ALTER TABLE [table name] ADD CONSTRAINT [constraint name] FOREIGN KEY (column,...) REFERENCES table [(column,...)] [ON DELETE {CASCADE | SET NULL}]

For example:

Deleting constraints
The syntax for dropping (removing) a constraint is:

ALTER TABLE [table name] DROP CONSTRAINT [constraint name];

For example:

INDEXES
An index is a method that retrieves records with greater efficiency. An index creates an entry for each value that appears in the indexed columns. By default, Oracle creates B-tree indexes.

Create an index
The syntax for creating an index is:

CREATE [UNIQUE] INDEX index_name ON table_name (column1, column2, . column_n) [ COMPUTE STATISTICS ];

UNIQUE indicates that the combination of values in the indexed columns must be unique.

COMPUTE STATISTICS tells Oracle to collect statistics during the creation of the index. The statistics are then used by the optimizer to choose an optimal execution plan when the statements are executed.

For example: In this example, an index has been created on the customer table called customer_idx. It consists of only of the customer_name field.

The following creates an index with more than one field: The following collects statistics upon creation of the index:

Create a function-based index
In Oracle, you are not restricted to creating indexes on only columns. You can create function-based indexes.

The syntax that creates a function-based index is:

CREATE [UNIQUE] INDEX index_name ON table_name (function1, function2, . function_n) [ COMPUTE STATISTICS ];

For example: An index, based on the uppercase evaluation of the customer_name field, has been created.

To assure that the Oracle optimizer uses this index when executing your SQL statements, be sure that UPPER(customer_name) does not evaluate to a NULL value. To ensure this, add UPPER(customer_name) IS NOT NULL to your WHERE clause as follows:

Rename an Index
The syntax for renaming an index is:

ALTER INDEX index_name RENAME TO new_index_name;

For example: In this example, customer_id is renamed to new_customer_id.

Collect statistics on an index
If you need to collect statistics on the index after it is first created or you want to update the statistics, you can always use the ALTER INDEX command to collect statistics. You collect statistics so that oracle can use the indexes in an effective manner. This recalcultes the table size, number of rows, blocks, segments and update the dictionary tables so that oracle can use the data effectively while choosing the execution plan.

The syntax for collecting statistics on an index is:

ALTER INDEX index_name REBUILD COMPUTE STATISTICS;

For example: In this example, statistics are collected for the index called customer_idx.

Drop an index
The syntax for dropping an index is:

DROP INDEX index_name;

For example: In this example, the customer_idx is dropped.

Creating a user
The syntax for creating a user is:

CREATE USER username IDENTIFIED BY password;

For example:

CREATE USER brian IDENTIFIED BY brianpass;

Granting privileges
The syntax for granting privileges is:

GRANT privilege TO user;

For example:

GRANT dba TO brian;

Change password
The syntax for changing user password is:

ALTER USER username IDENTIFIED BY password;

For example:

ALTER USER brian IDENTIFIED BY brianpassword;

Importing and exporting
There are two methods of backing up and restoring database tables and data. The 'exp' and 'imp' tools are simpler tools geared towards smaller databases. If database structures become more complex or are very large ( > 50 GB for example) then using the RMAN tool is more appropriate.

Import a dump file using IMP
This command is used to import Oracle tables and table data from a *.dmp file created by the 'exp' tool. Remember that this a command that is executed from the command line through $ORACLE_HOME/bin and not within SQL*Plus.

The syntax for importing a dump file is:

imp KEYWORD=value

There are number of parameters you can use for keywords.

To view all the keywords:

imp HELP=yes

An example:

imp brian/brianpassword FILE=mydump.dmp FULL=yes

Arithmetic operators

 * Addition: +
 * Subtraction: -
 * Multiplication: *
 * Division: /
 * Power (PL/SQL only): **

Examples
gives all employees from customer id 5 a 5% raise UPDATE employee SET salary = salary * 1.05 WHERE customer_id = 5;

determines the after tax wage for all employees SELECT wage – tax FROM employee;

Comparison operators

 * Greater Than: >
 * Greater Than or Equal To: >=
 * Less Than: <
 * Less Than or Equal to: <=
 * Equivalence: =
 * Inequality: != ^=  <>  ¬= (depends on platform)

Examples
SELECT name, salary, email FROM employees WHERE salary > 40000;

SELECT name FROM customers WHERE customer_id < 6;

String operators
create or replace procedure addtest( a in varchar2(100), b in varchar2(100), c out varchar2(200) ) IS begin C:=concat(a,'-',b);
 * Concatenate: ||

Date operators

 * Addition: +
 * Subtraction: -

Basic PL/SQL Types
Scalar type (defined in package STANDARD): NUMBER, CHAR, VARCHAR2, BOOLEAN, BINARY_INTEGER, LONG\LONG RAW, DATE, TIMESTAMP and its family including intervals)

Composite types (user-defined types): TABLE, RECORD, NESTED TABLE and VARRAY

LOB datatypes : used to store an unstructured large amount of data

%TYPE – anchored type variable declaration
The syntax for anchored type declarations is  %type [not null][:= ];

For example name Books.title%type;  /*  name is defined as the same type as column 'title' of table  Books */

commission number(5,2) := 12.5;

x commission%type;  /*  x is defined as the same type as variable 'commission' */

Note:   Anchored variables allow for the automatic synchronization of the type of anchored variable with the type of when there is a change to the type.  Anchored types are evaluated at compile time, so recompile the program to reflect the change of type in the anchored variable.

Collections
A collection is an ordered group of elements, all of the same type. It is a general concept that encompasses lists, arrays, and other familiar datatypes. Each element has a unique subscript that determines its position in the collection.

--Define a PL/SQL record type representing a book: TYPE book_rec IS RECORD (title                  book.title%TYPE,     author                  book.author_last_name%TYPE,     year_published          book.published_date%TYPE);

--define a PL/SQL table containing entries of type book_rec: Type book_rec_tab IS TABLE OF book_rec INDEX BY BINARY_INTEGER;

my_book_rec book_rec%TYPE; my_book_rec_tab book_rec_tab%TYPE; ... my_book_rec := my_book_rec_tab(5); find_authors_books(my_book_rec.author); ...

There are many good reasons to use collections.

 * Dramatically faster execution speed, thanks to transparent performance boosts including a new optimizing compiler, better integrated native compilation, and new datatypes that help out with number-crunching applications.

 * The FORALL statement, made even more flexible and useful. For example, FORALL now supports nonconsecutive indexes.

 * Regular expressions are available in PL/SQL in the form of three new functions (REGEXP_INSTR, REGEXP_REPLACE, and REGEXP_SUBSTR) and the REGEXP_LIKE operator for comparisons.

 * Collections, improved to include such things as collection comparison for equality and support for set operations on nested tables.

Functions
A function must return a value to the caller.

The syntax for a function is

CREATE [OR REPLACE] FUNCTION function_name [ (parameter [,parameter]) ] RETURN [return_datatype] IS    [declaration_section] BEGIN executable_section return [return_value]

[EXCEPTION exception_section] END [function_name];

For example: CREATE OR REPLACE FUNCTION to_date_check_null(dateString IN VARCHAR2, dateFormat IN VARCHAR2) RETURN DATE IS BEGIN IF dateString IS NULL THEN return NULL; ELSE return to_date(dateString, dateFormat); END IF; END;

Procedures
A procedure differs from a function in that it must not return a value to the caller.

The syntax for a procedure is:

CREATE [OR REPLACE] PROCEDURE procedure_name [ (parameter [,parameter]) ] IS    [declaration_section] BEGIN executable_section [EXCEPTION exception_section] END [procedure_name];

When you create a procedure or function, you may define parameters. There are three types of parameters that can be declared:

  IN – The parameter can be referenced by the procedure or function. The value of the parameter can not be overwritten by the procedure or function.

 OUT – The parameter can not be referenced by the procedure or function, but the value of the parameter can be overwritten by the procedure or function.

 IN OUT – The parameter can be referenced by the procedure or function and the value of the parameter can be overwritten by the procedure or function.

Also you can declare a DEFAULT value; CREATE [OR REPLACE] PROCEDURE procedure_name [ (parameter [IN|OUT|IN OUT] [DEFAULT value] [,parameter]) ]

The following is a simple example of a procedure:

/* purpose: shows the students in the course specified by courseId */

CREATE OR REPLACE Procedure GetNumberOfStudents ( courseId IN number, numberOfStudents OUT number ) IS

/* although there are better ways to compute the number of students, this is a good opportunity to show a cursor in action           */

cursor student_cur is       select studentId, studentName from course where course.courseId = courseId; student_rec   student_cur%ROWTYPE;

BEGIN OPEN student_cur; LOOP FETCH student_cur INTO student_rec; EXIT WHEN student_cur%NOTFOUND; numberOfStudents := numberOfStudents + 1; END LOOP; CLOSE student_cur;

EXCEPTION WHEN OTHERS THEN raise_application_error(-20001,'An error was encountered – '||SQLCODE||' -ERROR- '||SQLERRM); END GetNumberOfStudents;

anonymous block
DECLARE x NUMBER(4) := 0; BEGIN x := 1000; BEGIN x := x + 100; EXCEPTION WHEN OTHERS THEN x := x + 2; END; x := x + 10; dbms_output.put_line(x); EXCEPTION WHEN OTHERS THEN x := x + 3; END;

Passing parameters to stored logic
There are three basic syntaxes for passing parameters to a stored procedure: positional notation, named notation and mixed notation.

The following examples call this procedure for each of the basic syntaxes for parameter passing: CREATE OR REPLACE PROCEDURE create_customer( p_name IN varchar2,                                             p_id IN number,                                              p_address IN varchar2,                                              p_phone IN varchar2 ) IS BEGIN INSERT INTO customer ( name, id, address, phone ) VALUES ( p_name, p_id, p_address, p_phone ); END create_customer;

Positional notation
Specify the same parameters in the same order as they are declared in the procedure. This notation is compact, but if you specify the parameters (especially literals) in the wrong order, the bug can be hard to detect. You must change your code if the procedure's parameter list changes.

create_customer('James Whitfield', 33, '301 Anystreet', '251-222-3154');

Named notation
Specify the name of each parameter along with its value. An arrow (=>) serves as the association operator. The order of the parameters is not significant. This notation is more verbose, but makes your code easier to read and maintain. You can sometimes avoid changing code if the procedure's parameter list changes, for example if the parameters are reordered or a new optional parameter is added. Named notation is a good practice to use for any code that calls someone else's API, or defines an API for someone else to use.

create_customer(p_address => '301 Anystreet', p_id => 33, p_name => 'James Whitfield', p_phone => '251-222-3154');

Mixed notation
Specify the first parameters with positional notation, then switch to named notation for the last parameters. You can use this notation to call procedures that have some required parameters, followed by some optional parameters.

create_customer(v_name, v_id, p_address=> '301 Anystreet', p_phone => '251-222-3154');

Table functions
CREATE TYPE object_row_type as OBJECT (  object_type VARCHAR(18),   object_name VARCHAR(30) );

CREATE TYPE object_table_type as TABLE OF object_row_type;

CREATE OR REPLACE FUNCTION get_all_objects RETURN object_table_type PIPELINED AS BEGIN FOR cur IN (SELECT * FROM all_objects) LOOP PIPE ROW(object_row_type(cur.object_type, cur.object_name)); END LOOP; RETURN; END;

SELECT * FROM TABLE(get_all_objects);

Conditional Operators

 * and: AND
 * or: OR
 * not: NOT

Example
IF salary > 40000 AND salary <= 70000 THEN ELSE IF salary>70000 AND salary<=100000 THEN ELSE

If/then/else
IF [condition] THEN [statements] ELSEIF [condition] THEN [statements} ELSEIF [condition] THEN [statements} ELSEIF [condition] THEN [statements} ELSEIF [condition] THEN [statements} ELSEIF [condition] THEN [statements} ELSEIF [condition] THEN [statements} ELSEIF [condition] THEN [statements} ELSE [statements} END IF;

Associative arrays

 * Strongly typed arrays, useful as in-memory tables

Example

 * Very simple example, the index is the key to accessing the array so there is no need to loop through the whole table unless you intend to use data from every line of the array.
 * The index can also be a numeric value.

 * More complex example, using a record

APEX
aka APEX, is a web-based software development environment that runs on an Oracle database.

String substitution

 * In SQL: :VARIABLE
 * In PL/SQL: V('VARIABLE') or NV('VARIABLE')
 * In text: &VARIABLE.

title: Oracle Database/SQL Cheatsheet


text:
Conart/Music/Tuning

Getting rid of some preconceptions
Shocking as it might seem to some people, the twelve tones you find in an octave on the piano don't actually reflect anything but an approximation of a certain selection of tones, that for some reason during the last 300 years became the backbone of western music.

There is nothing inherently natural about the 12 tone system, and it is a mistake to think that music only can be made in it, or using parts of it (like major and minor scales, or pentatonic scales). In fact, a culture won't develop the 'intonation' that we use until it has figured out quite a bit about how frequencies work, and a certain bit of math. The Chinese are as far as I know the only culture out of Europe to have developed the same scale, and they did it way before us, but didn't use it as extensively. I will explain why, eventually.

In the world, there are several different systems with all kinds of foreign tunings: Indian and Arabic which come quite close to having an additional step between our semitones, Thai which comes quite close to having seven equal steps to the octave, Balinese scales, which have somewhat unequal steps with a twist. But more on those, and the whys and hows of them.

If you want to write songs for your conculture, yet maintain a certain depth and uniqueness, copying the western system may not be a good idea. If you must use our scale, then it's possible to use chords in unusual ways or even constructing unusual chords.

If you are interested in a truly strange scale, take a look at this site which describes the Bohlen Pierce 13 note scale, which is very different from any scale attested in any culture.

title: Conart/Music/Tuning


text:
Tcl Programming/TCL and ADP

Tcl and ADP Reference

This is a reference for using Tcl with ADP pages, for people setting up a site with the ArsDigita Community System (see OpenACS for details). The first half is just a Tcl overview; the second half deals with .adp pages, custom tags, and AOLServer resources and parameters.

Basic Tcl Language Features
 ; or newline statement separator \ statement continuation if last character in line # comment out rest of line (if 1st non−whitespace char) var simple variable var(index) associative array variable var(i,j) multidimensional associative array variable $var variable substitution (also ${var}xyz) [expr 1+2] command substitution \char backslash substitution "hello $a" quoting with substitution {hello $a} quoting with no subst (deferred substitution)  ''The only datatype in Tcl is a string. Some commands interpret arguments as numbers/booleans; those formats are:'''  Integer: 12 0xff(hex) 0377(octal) Floating Pt: 2.1 3. 6e4 7.91e+16 Boolean: true false 0 1 yes no

Backslash Substitutions
 \a audible alert (0x7) \b backspace (0x8) \f form feed (0xC) \n newline (0xA) \r carriage return (0xD) \t horizontal tab (0x9) \v vertical tab (0xB) \space space \newline space \ddd octal value (d=0−7) \xdd hex value (d=0−9,a−f) \c replace ’\c’ with ’c’ \\ backslash

Operators and Math Functions
The expr command recognizes these operators, in decreasing order of precedence: − ~ ! unary minus, bitwise NOT, logical NOT + − add, subtract << >> bitwise shift left, bitwise shift right < > <= >= boolean comparisons == != boolean equals, not equals & bitwise AND ^ bitwise exclusive OR && logical AND x ? y : z if x != 0, then y, else z ''All operators support integers. All support floating point except : ~, %, <<, >>, %, ^, and |. Boolean operators can also be used for string operands, in which case string comparison will be used. This occurs if any of the operands are not valid numbers. The following operators have "lazy evaluation" as in C: &&, ||, ?: The expr command recognizes the following math functions:'' abs hypot int double floor ceil fmod round cos sin tan acos asin atan atan2 cosh sinh tanh log log10 exp pow sqrt
 * / % multiply, divide, remainder
 * bitwise inclusive OR
 * logical OR

Regular Expressions
regex | regex match either expression regex* match zero or more of regex regex+ match one or more of regex regex? Match zero or one of regex . any single character except newline ^ match beginning of string $ match end of string \c match character c c match character c [abc] match set of characters [^abc] match characters not in set [a−z] match range of characters [^a−z] match characters not in range group expressions

Pattern Globbing
? match any single character [abc] match set of characters [a−z] match range of characters \c match character c {a,b,...} match any of string a, b, etc. ~ home directory (for glob command) ~user match user’s home directory (for glob command) Note: for the glob command, a "." at the beginning of a file’s name or just after "/" must be matched explicitly and all "/" characters must be matched explicitly.
 * match zero or more characters

Control Flow
break Abort innermost containing loop command case Obsolete, see switch continue Skip to next iteration of innermost containing loop. exit[returnCode] Terminate the process, return returnCode (an integer which defaults to 0) to the system as the exit status. for start test next body Looping command where start, next, and body are Tcl command strings and test is an expression string to be passed to expr command. foreach varname list body The Tcl command string body is evaluated for each item in the string list where the variable varname is set to the item’s value. if expr1 [then] body1 [elseif expr2 [then] body2...] [[else] bodyN] If expression string expr1 evaluates true, Tcl command string body1 is evaluated. Otherwise if expr2 is true, body2 is evaluated, and so on. If none of the expressions evaluate to true, then bodyN is executed. return [−code code] [−errorinfo info] [−errorcode code] [string] Return immediately from current procedure with string as return value. switch [options] string pattern1 body1 [ pattern2 body2 ...] The string argument is matched against each of the pattern arguments in order. As soon as it finds a pattern that matches string, it evaluates the corresponding Tcl command string body. If no match is found and the last pattern is the keyword default, its command string is evaluated while test body Evaluates the Tcl command string body as long as expression string test evaluates to true.

Lists
Note: list indices start at 0 and the word end may be used to reference the last element in the list. concat [arg arg ...] Returns concatenation of each string join list [joinString] Returns string created by joining all elements of list with joinString. lappend varName [value value ...] Appends each value to the end of the list stored in varName. lindex list index Returns value of element at index in list. linsert list index element [element ...] Returns new list formed by using each arg as an element. llength list Returns number of elements in list. lrange list first last Returns new list from slice of list at indices first through last inclusive. lsearch [mode] list pattern Returns index of first element in list that matches pattern (−1 for no match). Mode may be −exact, −glob(default) or −regexp. lsort [switches] list Returns new list formed by sorting list according to switches. These are: −ascii string comparison (default) −integer integer comparisons −real floating−point comparisons −increasing sort in increasing order (default) −decreasing sort in decreasing order −command cmd Use command which takes two arguments and returns an integer less than, equal to, or greater than zero. split string [splitChars] Returns a list formed by splitting string at each character in splitChars.

Strings
append varName [value value ...] Appends each of the given values to the string stored in varName.

format formatString [arg arg ...] Returns a formatted string generated in the ANSI C sprintf manner.

regexp [switches] exp string [matchVar] [subMatchVar ...] Returns 1 if the regular expression exp matches part or all of string, 0 otherwise. If specified, matchVar will be wet to all the characters in the match and the following subMatchVar’s will be set to matched parenthesized subexpressions. The −nocase switch can be specified to ignore case in matching. The −indices switch can be specified so that matchVar and subMatchVar will be set to the start and ending indice3s in string of their corresponding match.

regsub [switches] exp string subSpec varName Replaces the first portion of string that matches the regular expression exp with subSpec and places results in varName. Returns count of number of replacements made. The −nocase switch can be specified to ignore case in matching. The −all switch will cause all matches to be substituted for.

scan string formatString varName [varName ...] Extracts values into given variables using ANSI C sscanf behavior. string compare string1 string2 Return −1, 0, or 1, depending on whether string1 is lexicographically less than, equal to, or greater than string2. string first string1 string2 Return index in string2 of first occurrence of string1 (−1 if not found).

string index string charIndex Returns the charIndex’th character in string.

string last string1 string2 Return index in string2 of last occurrence of string1 (−1 if not found).

string length string Returns number of characters in string.

string match pattern string Returns 1 if glob pattern matches string, 0 otherwise.

string range string first last Returns characters from string at indices first through last inclusive.

string tolower string Returns new string formed by converting all chars in string to lower case.

string toupper string Returns new string formed by converting all chars in string to upper case.

string trim string [chars] Returns new string formed by removing from string any leading or trailing characters present in the set chars.

string trimleft string [chars] Same as string trim for leading characters only.

string trimright string [chars] Same as string trim for trailing characters only.

string wordend string index Returns index of character just after last one in word at index in string.

string wordstart string index Returns index of first character of word at index in string.

subst [−nobackslashes] [−nocommands] [−novariables] string Returns result of backslash, command, and variable substitutions on string. Each may be turned off by switch.

Including TCL code in ADP pages
Inline replacement: <%= tcl code that evaluates to the text you want embedded %>

State changing Code: <% tcl commands to change tcl environment (set vars, do db queries, etc) %>

Example: <tt>Two plus two is <%= [expr 2+2] %></tt>

Defining custom tags
" }

Using AOLServer Parameters
[ad_parameter UsersCanCreateRoomsP chat]

Resourcing tcl in AOLserver
source−file.tcl − to source a particular file. set_the_usual_form_variables ns_eval [list source $file] ns_return 200 text/html ok wget −O − "http://localhost:8000/source− file.tcl?file=/web/server1/tcl/myfile.tcl" ''Note: this does not work for registered tag changes. To cause a reload of everything:'' <% set dir [ns_info tcllib] set list [exec ls $dir] foreach file $list { source $dir/$file ns_puts "sourced: $file "}%>

Using ns_set
When one queries a database, the variable that is set is an ns_set: set db [ns_db gethandle] set sql_query "select first_names, last_name from users where user_id = $user_id" set selection [ns_db 1row $db $sql_query] Getting information out of an ns_set: set first_names [ns_set get $selection "first_names"] set last_name [ns_set get $selection "last_name"] ns_return 200 text/plain "User #$user_id is $first_names $last_name"
 * 1) ask AOLserver to give us a database connection
 * 1) actually send the query to the RDBMS; tell AOLserver we
 * 2) expect exactly one row back

Dealing with Form Variables
Importing form variables into a tcl or adp page <tt>set_the_usual_form_variables</tt> Manipulating Forms Directly: <tt>ns_getform</tt>

Decode
''Do logic w/o breaking out of an ns_write. Just like SQL !'' <tt>[util_decode unknown val1 res1 val2 res2 valN resN defaultresult]</tt>

Dealing With .ini file Parameters
ad_parameter <tt>ad_parameter name { subsection "" } { default "" }</tt> Returns the value of a configuration parameter set in one of the .ini files in /web/yourdomain/parameters. If the parameter doesn’t exist, returns the default specified as the third argument (or empty string if not default is specified). Note that AOLserver reads these files when the server starts up and stores parameters in an in−memory hash table. The plus side of this is that there is no hit to the file system and no need to memoize a call to ad_parameter. The minus side is that you have to restart the server if you want to test a change made to the .ini file. ad_parameter_section <tt>ad_parameter_section { subsection "" }</tt> Returns all the vars in a parameter section as an ns_set. Relies on undocumented AOLserver Tcl API call ns_configsection (analogous C API call is documented). Differs from the API call in that it returns an empty ns_set if the parameter section does not exist.

Converting tcl to adp
inclusion of sub−files ns_adp_include user−new.adp ns_adp_break
 * 1) Source user−new.adp. We would redirect to it, but we don’t want
 * 2) the password exposed!
 * 3) source "[ns_url2file "/register/user−new.tcl"]"
 * 4) return

title: Tcl Programming/TCL and ADP


text:
Conlang/Intermediate/Irregularities

If you look at any natural language you will quickly find that its grammar is not completely regular. Almost any language will have some words that don't fit in to the usual pattern. Adding irregularities to your conlang is a must if you want it to feel more 'naturalistic'.

Types of irregularities
Despite their name, most kinds of irregularities can be classed into groups.

Sound change
''You should be familiar with sound changes from previous chapters (History and Common sound changes). This section aims to show how well-chosen sound changes can affect the regularity of a conlang.''

This is probably the most common cause of irregularities. Sound changes cause irregularities by changing a word differently depending on what form it is in. For example, if you have a noun ono and its plural is formed by suffixing a t to the end then you have a perfectly regular relationship.

ono > onot

However, if you make a sound change rule which states that o becomes u at the end of a word, then the relationship is no longer so obvious because the o changes into a u in the singular but doesn't in the plural because the o is no longer at the end of the word.

onu > onot

Using the right sound changes for your conlang is a good way of adding irregularity to it.

Suppletion
Suppletion is a slightly rarer phenomenon so if you decide to use it in your conlang then you should do so sparingly. But, of course, before you can use it, you need to know what it is:

Suppletion is when a completely separate word replaces one part of a paradigm. For example, the English word went is completely unrelated (etymologically speaking) to go. Went is actually the past tense of a mostly forgotten verb wend which means more or less the same thing as go. Because the verbs came to mean roughly the same thing, most people stopped using wend and used go instead. However, the past tense of wend survived and was used as the past tense of go.

Thus instead of the paradigm go/goes, is going, "goed" (ging), has/have gone, we now have go/goes, is going, went, has/have gone. Suppletion also affected the English verb to be (am/is/are, am/is/are being, was/were, has/have been).

title: Conlang/Intermediate/Irregularities


text:
Talk:Conlang/Intermediate/Irregularities

Untitled
Okay start, but we really need to sort this out into a more regular format. That is, figure out how to get this information in more of a 'guide' format. -- Maknas 16:27, 10 Aug 2004 (UTC)

 * I've created a draft version but I'm not sure about it. The sound change example would be better if it used a natlang but I couldn't think of a natural example that was simple enough. The original version is available in the history should anyone need to refer to it. --Ingolemo 19:43, 16 Aug 2004 (UTC)


text:
User:Electric goat

I'm e-Goat, see also meta:User:Electric goat and w:ja:利用者:Electric goat. You can leave messages in English or Japanese.

Personal links:
 * Biology - my major.
 * Biology Laboratory Techniques
 * Cell Biology
 * Developmental Biology
 * Genetics
 * Japanese - my mother tongue.

title: User:Electric goat


text:
Electronics/Digital Circuits

Overview
In Digital circuits there are two parts one is Digital the other is circuits.

Digital
 * means a description of system which operates on digits or numbers.
 * The numbers that a digital system operates upon are binary numbers.One binary digit just have two values '0' and '1'. This '0' or '1' are analogous to 'off' and 'on', 'false' and 'true', etc. The Binary digIT is known as 'bit'. In day to day activities we use numbers and every digit of that number can be between 0 - 9. We use combination of such digital to for numbers bigger than 9. Similarly we can use combination of bits, i.e. combination of 1 & 0, to form bigger binary numbers.

Circuit can be any electric circuit and Digital circuit is a circuit which is designed to implement the description of digital circuit.

Digital circuits are developed using a special type of mathematics called 'Boolean Algebra'.

title: Electronics/Digital Circuits


text:
User:Daniel Hooper

I am an electrical engineering student at Vanderbilt Univeristy in Nashville, TN. I have made several contributions already, including creating the School of Engineering and the Electrical Engineering Department. I have made contributions to some of the texts linked at that site.

title: User:Daniel Hooper


text: User:Kupord Maizzed

title: User:Kupord Maizzed


text:
JavaScript/Introduction

JS is a programming language that implements the international standard ECMAScript. It is based on the following concepts.

Dynamic data types
JS knows some primitive data types (Number, String, Boolean, BigInt, Symbol, Undefined, Null) and diverse derivates of the data type object (Array, Date, Error, Function, RegExp). If a variable exists, its type is clearly defined. But the type can be changed at any time by assigning a value of a different type to the variable, e.g.: the code fragment  is perfectly correct. It will not create a compile-time or run-time error. Only the type of the variable  changes from Undefined to String to Number and lastly to Object/Array.

(Note: JSON is a text-based data format, not a data type. As such, it’s language-independent. It uses the JavaSript object syntax.)

Functional programming
Functions are first-class citizens similar to variables. They can be assigned to variables, passed as arguments to other functions, or returned from functions. The code fragment  creates a function sayHello, assigns it to the variable x, and executes it by calling x.

Object-orientated programming
JS supports object-oriented programming and inheritance through prototypes. A prototype is an object which can be cloned and extended. Doing so, a prototype chain arises. This differs from other OO-languages, e.g. Java, which uses classes for object-oriented features like inheritance. Nevertheless, at the syntactical level, classes are available in JS. But this is only 'syntactical sugar'. Under the hood, JS uses the prototype mechanism.

C-like syntax
The JS syntax is very similar to that of C, Java, or other members of the C-family. But we must always consider that the concepts and runtime behavior are distinctly different.

Relation to Java
JS has no relation to Java aside from having a C-like syntax. To avoid possible confusion, we would like to highlight some distinctions between JS and Java clearly.

In the beginning, Netscape developed JavaScript, and Sun Microsystems developed Java. Java includes classes and object instances, whereas JavaScript uses prototypes. In Java, variables must be declared before usage, which is unnecessary (but not recommended) in JS.

In Java, variables have an immutable static type ( or , for example) that remains the same during the complete lifespan of a running program. In JS they also have a type ( or , for example), but this type can change during the lifespan of a running program. The type is detected from the environment. Therefore it's not necessary and not possible to define the type explicitly.

JS engines
JS can run on the client-side as well as on the server-side. First versions of JS have run in Browsers that acted as mere interpreters. Today, the language is handled by just-in-time compilers (JIT). They parse the script, create an Abstract Syntax Tree (AST), optimize the tree, generate a JIT-specific bytecode out of the AST, generate hardware-specific machine code out of the bytecode, and bring the machine code to execution. Such just-in-time compilers exist not only in Browsers. They can also be part of other applications, e.g.: node.js  which is written mainly in C++.

Widely used JS engines are:
 * V8 from Google: Google Chrome, Electron, Chromium, node.js
 * SpiderMonkey from Mozilla, Firefox
 * JavaScriptCore from Apple, Safari
 * ActionScript from Adobe, Flash

title: JavaScript/Introduction


text:
JavaScript/JavaScript within HTML

The language JavasScript was originally introduced to run in browsers and handle the dynamic aspects of user interfaces, e.g., validation of user input, modifications of page content (DOM) or appearance of the user interface (CSS), or any event handling. This implies that an interconnection point from HTML to JS must exist. The HTML element  plays this role. It is a regular HTML element, and its content is JS.

The  element may appear almost anywhere within the HTML file, within   as well as in. There are only a few criteria for choosing an optimal place; see below.

Internal vs. external JavaScript
The  element either contains JS code directly, or it points to an external file resp. URL containing the JS code through its  attribute. The first variant is called Internal JavaScript or Inline JavaScript, the second External JavaScript.

In the case of Internal JavaScript the  element looks like:

Internal scripting has the advantage that both your HTML and your JS are in one file, which is convenient for quick development. This is commonly used for temporarily testing out some ideas, and in situations where the script code is small or specific to that one page.

For the External JavaScript the  element looks like:

Separate Files for Javascript Code
Having your JS in a separate file is recommended for larger programs, especially for such which are used on multiple pages. Furthermore, such splits support the pattern of Separation of Concerns: One specialist works on HTML, and another on JS. Also, it supports the division of the page's content (HTML) from its behavior (JS).

Overall, using External scripting is considered a best practice for software development.

Remote Code Injection vs. Local Library
With the example  you can inject remotely maintained code from the server   in your local web project. Remote code updates may break your local project or unwanted code features may be injected into your web project. On the other hand, centralized maintained and updated libraries serve your project due to bugfixes that are automatically updated in your project when the library is fetched again from the remote server.

Minified vs. Non-Minified Code
Minified Javascript code compresses the source code e.g. by shorting comprehensive variables like vImage into a single character variable a. This reduces significantly the size of the library and therefore reduces network traffic and response time until the web page is ready. For development and learning it might be helpful to have the uncompressed libraries locally available.

External JavaScript
For more detailed information you can refer to MDN.

The attribute
Adding  to the opening   tag means that the JS code will be located in a file called myScript.js in the same directory as the HTML file. If the JS file is located somewhere else, you must change the  attribute to that path. For example, if it is located in a subdirectory called js, it reads.

The attribute
JS is not the only scripting language for Web development, but JS is the most common one on client-side (PHP runs on server-side). Therefore it's considered the default script type for HTML5. The formal notation for the type is:. Older HTML versions know a lot of other script types. Nowadays, all of them are graded as legacy. Some examples are:,  ,  , or.

In HTML5, the spec says that - if you use JS - the  attribute should be omitted from the script element, for Internal Scripting as well as for External Scripting.

The and   attributes
Old browsers use only one or two threads to read and parse HTML, JS, CSS, ... . This may lead to a bad user experience (UX) because of the latency time when loading HTML, JS, CSS, images, ... sequentially one after the next. When the page loads for the first time, the user may have the impression of a slow system.

Current browsers can execute many tasks in parallel. To initiate this parallel execution with regards to JS loading and execution, the  element can be extended with the two attributes   and.

The attribute  leads to asynchronous script loading (in parallel with other tasks), and execution as soon as it is available.

acts similar. It differs from  in that the execution is deferred until the page is fully parsed.

Location of elements
The  element may appear almost anywhere within the HTML file. But there are, however, some best practices for speeding up a website. Some people suggest to locate it just before the closing  tag. This speeds up downloading, and also allows for direct manipulation of the Document Object Model (DOM) while it is rendered. But a similar behavior is initiated by the above-described  and   attributes.

The element
It may happen that people have deactivated JS in their browsers for security or other reasons. Or, they use very old browsers which are not able to run JS at all. To inform users in such cases about the situation, there is the  element. It contains text that will be shown in the browser. The text shall explain that no JS code will be executed.

JavaScript in XHTML files
XHTML uses a stricter syntax than HTML. This leads to small differences.

First, for Internal JavaScript it's necessary that the scripts are introduced and finished with the two additional lines shown in the following example.

Second, for External JavaScript the   attribute is required.

Reference
de:Websiteentwicklung: JavaScript: Der script-Tag JavaScript/Skrypt w przeglądarce

title: JavaScript/JavaScript within HTML


text:
Conart/Music/Difference

So, what is different in these other scales?
Except that the pianos will have different layouts for their keys, there will be certain differences:

 * intervals can sound sweeter or harsher, depending on the characteristics of the scale
 * intervals can be perfectly tuned, or only approximately in tune
 * there can be more or less available chords
 * transposing and modulation can become more or less difficult
 * and of course, different scales lend themselves to different purposes
 * instruments will be slightly different

However, there also is an opposite effect:

 * the available instruments will affect what kind of scales are probable to evolve
 * the kind of music will affect what kind of scales are probable to evolve

title: Conart/Music/Difference


text:
Cookbook:Indonesian Fried Chicken (Ayam Goreng Kuning)

| Cuisine of Indonesia

This is a recipe for ayam goreng kuning, the traditional fried chicken dish popular in Indonesia. As with most Indonesian poultry recipes, free-range chicken gives the best results. Cut the chicken as you would normally cut chicken for frying.

Ingredients

 * Turmeric
 * Ginger (just a little)
 * Galanga
 * Garlic
 * Desiccated (dried) coconut
 * Chicken
 * Salt to taste
 * Pepper to taste
 * Cooking oil, for deep frying
 * Fried shallot for garnish

Procedure

 * 1) Mix the turmeric, ginger, galanga, and garlic together with a small amount of water. Use either a mortar or food processor to make it into a paste.
 * 2) Add the coconut to the spice paste. Do not process any longer.
 * 3) In a pot, boil the chicken along with the spice paste on low heat. Add salt and pepper to taste. Cook until all the water has gone.
 * 4) In a deep fryer, heat the cooking oil. When the oil is hot enough, deep fry the chicken.
 * 5) Remove the chicken and filter the cooking oil. Put the oil back in the deep fryer. Put the chicken along with all filtered spices on top of paper towels.
 * 6) After deep frying all of the chicken, put all spices left in the boiling pot into the deep fryer. Make sure the spice paste is dry enough before frying—excessive water may explode! If everything is correct, you should see brown particles in the cooking oil. Filter the oil, and sprinkle the fried spice paste on top of the chicken.
 * 7) Serve with steamed rice and raw vegetables (e.g. cabbage, Chinese long beans, and sliced cucumbers). Sprinkle the fried shallot over the rice.