text:
Ada Programming/Object Orientation

Object orientation in Ada
Object oriented programming consists in building the software in terms of "objects". An "object" contains data and has a behavior. The data, normally, consists in constants and variables as seen in the rest of this book but could also, conceivably, reside outside the program entirely, i.e. on disk or on the network. The behavior consists in subprograms that operate on the data. What makes Object Orientation unique, compared to procedural programming, is not a single feature but the combination of several features:

 * encapsulation, i.e. the ability to separate the implementation of an object from its interface; this in turn separates "clients" of the object, who can only use the object in certain predefined ways, from the internals of the object, which have no knowledge of the outside clients.

 * inheritance, the ability for one type of objects to inherit the data and behavior (subprograms) of another, without necessarily needing to break encapsulation;

 * type extension, the ability for an object to add new data components and new subprograms on top of the inherited ones and to replace some inherited subprograms with its own versions; this is called overriding.

 * polymorphism, the ability for a "client" to use the services of an object without knowing the exact type of the object, i.e. in an abstract way. Indeed at run time, the actual objects can have different types from one invocation to the next.

It is possible to do object-oriented programming in any language, even assembly. However, type extension and polymorphism are very difficult to get right without language support.

In Ada, each of these concepts has a matching construct; this is why Ada supports object-oriented programming directly.

 * Packages provide encapsulation;
 * Derived types provide inheritance;
 * Record extensions, described below, provide for type extension;
 * Class-wide types, also described below, provide for polymorphism.

Ada has had encapsulation and derived types since the first version (MIL-STD-1815 in 1980), which led some to qualify the language as "object-oriented" in a very narrow sense. Record extensions and class-wide types were added in Ada 95. Ada 2005 further adds interfaces. The rest of this chapter covers these aspects.

The simplest object: the Singleton
Directory Present (Name_Pattern: String) Boolean; Visit (Full_Name, Phone_Number, Address: String;                           Stop:  Boolean); Iterate (Name_Pattern: String); Directory;

The Directory is an object consisting of data (the telephone numbers and addresses, presumably held in an external file or database) and behavior (it can look an entry up and traverse all the entries matching a Name_Pattern, calling Visit on each).

A simple package provides for encapsulation (the inner workings of the directory are hidden) and a pair of subprograms provide the behavior.

This pattern is appropriate when only one object of a certain type must exist; there is, therefore, no need for type extension or polymorphism.

Primitive operations
In Ada, methods are usually referred to by the technical term primitive subprograms of a tagged type or the equivalent term primitive operations of a tagged type. The primitive operations of a type are those that are always available wherever the type is used. For the tagged types that are used in object oriented programming, they also can be inherited by and overridden by derived types, and can be dynamically dispatched.

Primitive operations of a type need to be declared immediately within the same package as the type (not within a nested package nor a child package). For tagged types, new primitive operations and overrides of inherited primitive operations are further required to be declared before the freezing point of the type. Any subprograms declared after the freezing point will not be considered primitive, and therefore cannot be inherited and are not dynamically dispatched. Freezing points are discussed in more detail below, but the simple practice of declaring all primitive operations immediately following the initial type declaration will ensure that those subprograms are indeed recognized as primitive.

Primitive operations of type T need to have at least one parameter of type  or of type. While most object-oriented languages automatically provide a  or   pointer, Ada requires that you explicitly declare a formal parameter to receive the current object. That typically will be the first parameter in the list, which enables the  call syntax (available since Ada 2005), but it may be at any parameter position. Tagged types are always passed by reference; the parameter passing method has nothing to do with the parameter modes  and , which describe the dataflow. The parameter passing method is identical for  and.

For tagged types, no other directly dispatchable types can be used in the parameter list because Ada doesn't offer multiple dispatching. The following example is illegal.

P     A   ; B  ; Proc (This: B; That: A); P;

When additional dispatchable objects need to be passed in, the parameter list should declare them using their class-wide types,. For example:

P     A   ; B  ; Proc (This: B; That: A'Class); P;

Note, however, that this does not limit the number of parameters of the same tagged type. For example, the following definition is legal.

P     A   ; Proc (This, That: A); P;

Primitive operations of tagged types are dispatching operations. Whether a call to such a primitive operation is in effect dispatching or statically bound, depends on the context (see below). Note that in a dispatching call both actual parameters of the last example must have the same tag (i.e. the same type); Constraint_Error will be called if the tag check fails.

Derived types
Type derivation has been part of Ada since the very start.

P    T ; Create (Data: Boolean) T;      Work (Object :  T); Work (Pointer: T); Acc_T T;    Proc (Pointer: Acc_T); T     Data: Boolean; ; P;

The above example creates a type T that contains data (here just a Boolean but it could be anything) and behavior consisting of some subprograms. It also demonstrates encapsulation by placing the details of the type T in the private part of the package.

The primitive operations of T are the function Create, the overloaded procedures Work, and the predefined "=" operator; Proc is not primitive, since it has an access type on T as parameter — don't confuse this with an access parameter, as used in the second procedure Work. When deriving from T, the primitive operations are inherited.

P; Q     Derived  P.T;  Q;

The type Q.Derived has the same data and the same behavior as P.T; it inherits both the data and the subprograms. Thus it is possible to write:

Q; Main Object: Q.Derived := Q.Create (Data => False); Q.Work (Object); Main;

Inherited operations may be overridden and new operations added, but the rules (Ada 83) unfortunaltely are somewhat different from the rules for tagged types (Ada 95).

Admittedly, the reasons for writing this may seem obscure. The purpose of this kind of code is to have objects of types P.T and Q.Derived, which are not compatible:

Ob1: P.T; Ob2: Q.Derived;

Ob1 := Ob2;             -- illegal Ob1 := P.T (Ob2);       -- but convertible Ob2 := Q.Derived (Ob1); -- in both directions

This feature is not used very often (it's used e.g. for declaring types reflecting physical dimensions) but I present it here to introduce the next step: type extension.

Type extensions
Type extensions are an Ada 95 amendment.

A tagged type provides support for dynamic polymorphism and type extension. A tagged type bears a hidden tag that identifies the type at run-time. Apart from the tag, a tagged record is like any other record, so it can contain arbitrary data.

Person Object Name  : String (1 .. 10); Gender : Gender_Type; ;    Put (O : Object); Person;

As you can see, a  is an object in the sense that it has data and behavior (the procedure  ). However, this object does not hide its data; any program unit that has a  clause can read and write the data in a Person.Object directly. This breaks encapsulation and also illustrates that Ada completely separates the concepts of encapsulation and type. Here is a version of Person.Object that encapsulates its data:

Person Object ; Put (O : Object); Object Name  : String (1 .. 10); Gender : Gender_Type; ; Person;

Because the type Person.Object is tagged, it is possible to create a record extension, which is a derived type with additional data.

Person; Programmer Object  Person.Object ; Object  Person.Object Skilled_In : Language_List; ; Programmer;

The type  inherits the data and behavior, i.e. the type's primitive operations, from  ; it is thus possible to write:

Programmer; Main Me : Programmer.Object; Programmer.Put (Me); Me.Put; Main;

So the declaration of the type, as a record extension of  , implicitly declares a   that applies to a.

Like in the case of untagged types, objects of type Person and Programmer are convertible. However, where untagged objects are convertible in either direction, conversion of tagged types only works in the direction to the root. (Conversion away from the root would have to add components out of the blue.) Such a conversion is called a view conversion, because components are not lost, they only become invisible.

Extension aggregates have to be used if you go away from the root.

Overriding
Now that we have introduced tagged types, record extensions and primitive operations, it becomes possible to understand overriding. In the examples above, we introduced a type  with a primitive operation called. Here is the body of the package:

Ada.Text_IO; Person Put (O : Object) Ada.Text_IO.Put (O.Name); Ada.Text_IO.Put (" is a "); Ada.Text_IO.Put_Line (Gender_Type'Image (O.Gender)); Put; Person;

As you can see, this simple operation prints both data components of the record type to standard output. Now, remember that the record extension  has an additional data member. If we write:

Programmer; Main Me : Programmer.Object; Programmer.Put (Me); Me.Put; Main;

then the program will call the inherited primitive operation, which will print the name and gender but not the additional data. In order to provide this extra behavior, we must override the inherited procedure  like this:

Person; Programmer Object  Person.Object ; Put (O : Object); Object  Person.Object Skilled_In : Language_List; ; Programmer;

Programmer Put (O : Object) Person.Put (Person.Object (O)); Put (O.Skilled_In); Put; Programmer;

overrides ; in other words it replaces it completely. Since the intent is to extend the behavior rather than replace it,  calls   as part of its behavior. It does this by converting its parameter from the type  to its ancestor type. This construct is a view conversion; contrary to a normal type conversion, it does not create a new object and does not incur any run-time cost (and indeed, if the operand of such view conversion was actually a variable, the result can be used when an out parameter is required (eg. procedure call)). Of course, it is optional that an overriding operation call its ancestor; there are cases where the intent is indeed to replace, not extend, the inherited behavior.

(Note that also for untagged types, overriding of inherited operations is possible. The reason why it's discussed here is that derivation of untagged types is done rather seldom.)

Polymorphism, class-wide programming and dynamic dispatching
The full power of object orientation is realized by polymorphism, class-wide programming and dynamic dispatching, which are different words for the same, single concept. To explain this concept, let us extend the example from the previous sections, where we declared a base tagged type  with a primitive operation   and a record extension   with additional data and an overriding primitive operation.

Now, let us imagine a collection of persons. In the collection, some of the persons are programmers. We want to traverse the collection and call  on each person. When the person under consideration is a programmer, we want to call ; when the person is not a programmer, we want to call. This, in essence, is polymorphism, class-wide programming and dynamic dispatching.

With Ada's strong typing, ordinary calls cannot be dynamically dispatched; a call to an operation on a declared type must always be statically bound to go to the operation defined for that specific type. Dynamic dispatching (known as simply dispatching in Ada parlance) is provided through separate class-wide types that are polymorphic. Each tagged type, such as, has a corresponding class of types which is the set of types comprising the type   itself and all types that extend. In our example, this class consists of two types:

Ada 95 defines the  attribute to denote the corresponding class-wide type. In other words:

Someone : Person.Object'Class := ...; Someone.Put; ;

The declaration of Someone denotes an object that may be of either type,  or. Consequently, the call to the primitive operation  dispatches dynamically to either   or.

The only problem is that, since we don't know whether Someone is a programmer or not, we don't know how many data components Someone has, either, and therefore we don't know how many bytes Someone takes in memory. For this reason, the class-wide type  is indefinite. It is impossible to declare an object of this type without giving some constraint. It is, however, possible to:

 * declare an object of a class-wide with an initial value (as above). The object is then constrained by its initial value.
 * declare an access value to such an object (because the access value has a known size);
 * pass objects of a class-wide type as parameters to subprograms
 * assign an object of a specific type (in particular, the result of a function call) to a variable of a class-wide type.

With this knowledge, we can now build a polymorphic collection of persons; in this example we will quite simply create an array of access values to persons:

Person; Main Person_Access Person.Object'Class; Array_Of_Persons  (Positive  <>) of Person_Access; Read_From_Disk Array_Of_Persons ; Everyone : Array_Of_Persons := Read_From_Disk; K Everyone'Range Everyone (K)..Put; ; Main;

The above procedure achieves our desired goal: it traverses the array of Persons and calls the procedure  that is appropriate for each person.

Advanced topic: How dynamic dispatching works
You don't need to know how dynamic dispatching works in order to use it effectively but, in case you are curious, here is an explanation.

The first component of each object in memory is the tag; this is why objects are of a tagged type rather than plain records. The tag really is an access value to a table; there is one table for each specific type. The table contains access values to each primitive operation of the type. In our example, since there are two types  and , there are two tables, each containing a single access value. The table for  contains an access value to   and the table for   contains an access value to. When you compile your program, the compiler constructs both tables and places them in the program executable code.

Each time the program creates a new object of a specific type, it automatically sets its tag to point to the appropriate table.

Each time the program performs a dispatching call of a primitive operation, the compiler inserts object code that:

 * dereferences the tag to find the table of primitive operations for the specific type of the object at hand
 * dereferences the access value to the primitive operation
 * calls the primitive operation.

Conversely, when the program performs a call where the parameter is a view conversion to an ancestor type, the compiler performs these two dereferences at compile time rather than run time: such a call is statically bound; the compiler emits code that directly calls the primitive operation of the ancestor type specified in the view conversion.

Redispatching
Dispatching is controlled by the (hidden) tag of the object. So what happens when a primitive operation  calls another primitive operation   on the same object?

Root  ; Op1 (This: Root); Op2 (This: Root); Derived  Root  ; -- Derived inherits Op1 Op2 (This: Derived); Op1 (This: Root) ...   Op2 (This);               -- not redispatching Op2 (Root'Class (This)); -- redispatching This.Op2;                -- not redispatching (new syntax since Ada 2005) (Root'Class (This)).Op2; -- redispatching (new syntax since Ada 2005) ...  Op1; D: Derived; C: Root'Class := D; Op1 (D);  -- statically bound call Op1 (C); -- dispatching call D.Op1;   -- statically bound call (new syntax since Ada 2005) C.Op1;   -- dispatching call (new syntax since Ada 2005)

In this fragment,  is not overridden, whereas   is overridden. The body of  calls , so which   will be called if   is called for an object of type  ?

The basic rules of dispatching still apply. Calls to  will be dispatched when called using an object of a class-wide type.

The formal parameter lists for the operations specify the type of  to be a specific type, not class-wide. In fact, that parameter must be a specific type so that the operation will be dispatched for objects of that type, and to allow the operation's code to access any additional data items associated with that type. If you want redispatching, you must state that explicitly by converting the parameter of the specific type to the class-wide type again. (Remember: view conversions never lose components, they just hide them. A conversion to a class-wide type can unhide them again.) The first call  (statically bound, i.e., not dispatching) executes the inherited   — and within , the first call to   is also statically bound (there is no redispatching) because parameter   is a view conversion to specific type. However, the second call is dispatching because the parameter  is converted to the class-wide type. That call dispatches to the overriding.

Because the conventional  call is not dispatching, the call will be to   even though the object itself is of type   and the   operation is overridden. This is very different from how other OO languages behave. In other OO languages, a method is either dispatching or not. In Ada, an operation is either available for dispatching or not. Whether or not dispatching is actually used for a given call depends on the way that the object's type is specified at that call point. For programmers accustomed to other OO languages, it can come as quite a surprise that calls from a dispatchable operation to other operations on the same object are, by default, not (dynamically) dispatched.

The default of not redispatching is not an issue if all of the operations have been overridden, because they all will be operating on the expected type of object. However, it has ramifications when writing code for types that might be extended by another type sometime in the future. It's possible that the new type will not work as intended if it doesn't override all of the primitive operations that call other primitive operations. The safest policy is to use a class-wide conversion of the object to force dispatching of calls. One way to accomplish that is to define a class-wide constant in each dispatched method:

Op2 (This: Derived) This_Class: Root'Class := This;

is needed to access data items and to make any non-dispatching calls. is needed to make dispatching calls.

Less commonly encountered and perhaps less surprising, calls from a non-dispatchable (class-wide) routine for a tagged type to other routines on the same object are, by default, dispatched:

Root  ; Op1 (This: Root'Class); Op2 (This: Root); Derived  Root  ; -- Derived does not inherit Op1, rather Op1 is applicable to Derived. Op2 (This: Derived); Op1 (This: Root'Class) ...   Op2 (This);               -- dispatching Op2 (Root (This));       -- static call This.Op2;                -- dispatching (new syntax since Ada 2005) (Root (This)).Op2;       -- static call (new syntax since Ada 2005) ...  Op1; D: Derived; C: Root'Class := D; Op1 (D);  -- static call Op1 (C); -- static call D.Op1;   -- static call (new syntax since Ada 2005) C.Op1;   -- static call (new syntax since Ada 2005)

Note that calls on  are always static, since   is not inherited. Its parameter type is class-wide, so the operation is applicable to all types derived from Root. (Op2 has an entry for each type derived from  in the dispatch table. There is no such dispatch table for  ; rather there is only one such operation for all types in the class.)

Normal calls from  are dispatched because the declared type of   is class-wide. The default to dispatching usually isn't bothersome because class-wide operations are typically used to perform a script involving calls to one or more dispatched operations.

Run-time type identification
Run-time type identification allows the program to (indirectly or directly) query the tag of an object at run time to determine which type the object belongs to. This feature, obviously, makes sense only in the context of polymorphism and dynamic dispatching, so works only on tagged types.

You can determine whether an object belongs to a certain class of types, or to a specific type, by means of the membership test, like this:

Base     ; Derived  Base     ; Leaf     Derived  ; ... Explicit_Dispatch (This :  Base'Class) This Leaf  ... ;    This  Derived'Class  ... ; Explicit_Dispatch;

Thanks to the strong typing rules of Ada, run-time type identification is in fact rarely needed; the distinction between class-wide and specific types usually allows the programmer to ensure objects are of the appropriate type without resorting to this feature.

Additionally, the reference manual defines  (RM 3.9(6/2)), attribute   (RM 3.9(16,18)), and   (RM 3.9(18.2/2)), which enable direct manipulation with tags.

Creating Objects
The Language Reference Manual's section on states when an object is created, and destroyed again. This subsection illustrates how objects are created.

The LRM section starts, "Objects are created at run time and contain a value of a given type. An object can be created and initialized as part of elaborating a declaration, evaluating an allocator, aggregate, or function_call."

For example, assume a typical hierarchy of object oriented types: a top-level type , a  type derived from  , and possibly more kinds of persons. Each person has a name; assume objects to have a  component. Likewise, each  has a   component. The  type inherits the components and the operations of the  type, so   objects have a  and a   component, too. objects may have additional components specific to programmers.

Objects of a tagged type are created the same way as objects of any type. The second LRM sentence says, for example, that an object will be created when you declare a variable or a constant of a type. For the tagged type ,

P Person Text_IOPut_Line"The name is " PName

Nothing special so far. Just like any ordinary variable declaration this O-O one is elaborated. The result of elaboration is an object named of type. However,  has only default name and gender value components. These are likely not useful ones. One way of giving initial values to the object's components is to assign an aggregate.

P Person Name  "Scorsese" Gender  Male Text_IOPut_Line"The name is " PName

The parenthesized expression after := is called an aggregate .

Another way to create an object that is mentioned in the LRM paragraph is to call a function. An object will be created as the return value of a function call. Therefore, instead of using an aggregate of initial values, we might call a function returning an object.

Introducing proper O-O information hiding, we change the package containing the  type so that becomes a private type. To enable clients of the package to construct objects we declare a function that returns them. (The function may do some interesting construction work on the objects. For instance, the aggregate above will most probably raise the exception Constraint_Error depending on the name string supplied; the function can mangle the name so that it matches the declaration of the component.) We also declare a function that returns the name of  objects.

Persons Person Make Name String Sex Gender_Type Person Name P Person String Person Name   String 1  10 Gender Gender_Type Persons

Calling the  function results in an object which can be used for initialization. Since the  type is private we can no longer refer to the component of. But there is a corresponding function  declared with type  making it a socalled primitive operation. (The component and the function in this example are both named However, we can choose a different name for either if we want.)

P Person Make Name  "Orwell" Sex  Male Text_IOPut_Line"The name is " NameP

Objects can be copied into another. The target object is first destroyed. Then the component values of the source object are assigned to the corresponding components of the target object. In the following example, the default initialized  gets a copy of one of the objects created by the  calls.

P Person 2001 1984        P  Make Name  "Kubrick" Sex  Male P Make Name  "Orwell" Sex  Male Text_IOPut_Line"The name is " NameP

So far, there is no mention of the  type derived from. There is no polymorphism yet, and likewise initialization does not yet mention inheritance. Before dealing with  objects and their initialization a few words about class-wide types are in order.

More details on primitive operations
Remember what we said before about "Primitive Operations". Primitive operations are:
 * subprograms taking a parameter of the tagged type;
 * functions returning an object of the tagged type;
 * subprograms taking a parameter of an anonymous access type to the tagged type;
 * In Ada 2005 only, functions returning an anonymous access type to the tagged type;

Additionally, primitive operations must be declared before the type is frozen (the concept of freezing will be explained later):

Examples:

X     Object    ; Primitive_1 (This :     Object); Primitive_2 (That :    Object); Primitive_3 (Me  :   Object); Primitive_4 (Them : Object); Primitive_5 Object; Primitive_6 (Everyone : Boolean)  Object; X;

All of these subprograms are primitive operations.

A primitive operation can also take parameters of the same or other types; also, the controlling operand does not have to be the first parameter:

X     Object    ; Primitive_1 (This : Object; Number :  Integer); Primitive_2 (You :  Boolean; That :  Object); Primitive_3 (Me, Her :  Object); X;

The definition of primitive operations specifically excludes named access types and class-wide types as well as operations not defined immediately in the same declarative region. Counter-examples:

X     Object    ; Object_Access  Object; Object_Class_Access  Object'Class; Not_Primitive_1 (This :     Object'Class); Not_Primitive_2 (This :  Object_Access); Not_Primitive_3 (This :    Object_Class_Access); Not_Primitive_4 Object'Class; Inner Not_Primitive_5 (This : Object); Inner; X;

Advanced topic: Freezing rules
Freezing rules (ARM 13.14) are perhaps the most complex part of the Ada language definition; this is because the standard tries to describe freezing as unambiguously as possible. Also, that part of the language definition deals with freezing of all entities, including complicated situations like generics and objects reached by dereferencing access values. You can, however, get an intuitive understanding of freezing of tagged types if you understand how dynamic dispatching works. In that section, we saw that the compiler emits a table of primitive operations for each tagged type. The point in the program text where this happens is the point where the tagged type is frozen, i.e. the point where the table becomes complete. After the type is frozen, no more primitive operations can be added to it.

This point is the earliest of:
 * the end of the package spec where the tagged type is declared
 * the appearance of the first type derived from the tagged type

Example:

X    Object    ; Primitive_1 (This: Object); -- this declaration freezes Object Derived  Object   ; -- illegal: declared after Object is frozen Primitive_2 (This: Object); X;

Intuitively: at the point where Derived is declared, the compiler starts a new table of primitive operations for the derived type. This new table, initially, is equal to the table of the primitive operations of the parent type,. Hence,  must freeze.

 * the declaration of a variable of the tagged type

Example:

X    Object    ; Primitive_1 (This: Object); V: Object; -- this declaration freezes Object -- illegal: Primitive operation declared after Object is frozen Primitive_2 (This: Object); X;

Intuitively: after the declaration of, it is possible to call any of the primitive operations of the type on. Therefore, the list of primitive operations must be known and complete, i.e. frozen.

 * The completion (not the declaration, if any) of a constant of the tagged type:

X    Object    ; Primitive_1 (This: Object); -- this declaration does NOT freeze Object Deferred_Constant: Object; Primitive_2 (This : Object); -- OK   -- only the completion freezes Object Deferred_Constant: Object := ; -- illegal: declared after Object is frozen Primitive_3 (This: Object); X;

New features of Ada 2005
Ada 2005 adds overriding indicators, allows anonymous access types in more places and offers the object.method notation.

Overriding indicators
The new keyword can be used to indicate whether an operation overrides an inherited subprogram or not. Its use is optional because of upward-compatibility with Ada 95. For example:

X      Object    ; Primitive  Object; Derived_Object  Object   ; Primitive (This : Derived_Object); Primitive Derived_Object; X;

The compiler will check the desired behaviour.

This is a good programming practice because it avoids some nasty bugs like not overriding an inherited subprogram because the programmer spelt the identifier incorrectly, or because a new parameter is added later in the parent type.

It can also be used with abstract operations, with renamings, or when instantiating a generic subprogram:

Primitive_X (This : Object)  ; Primitive_Y Object  Some_Other_Subprogram; Primitive_Z (This : Object) Generic_Procedure (Element => Integer);

Object.Method notation
We have already seen this notation:

X     Object    ; Primitive (This: Object; That:  Boolean); X;

X; Main Obj : X.Object; Obj.Primitive (That => True); Main;

This notation is only available for primitive operations where the controlling parameter is the first parameter.

Abstract types
A tagged type can also be abstract (and thus can have abstract operations):

X     Object    …; One_Class_Member     (This :      Object); Another_Class_Member (This :   Object); Abstract_Class_Member Object   ; X;

An abstract operation cannot have any body, so derived types are forced to override it (unless those derived types are also abstract). See next section about interfaces for more information about this.

The difference with a non-abstract tagged type is that you cannot declare any variable of this type. However, you can declare an access to it, and use it as a parameter of a class-wide operation.

Multiple Inheritance via Interfaces
Interfaces allow for a limited form of multiple inheritance (taken from Java). On a semantic level they are similar to an "abstract tagged null record" as they may have primitive operations but cannot hold any data and thus these operations cannot have a body, they are either declared or. Abstract means the operation has to be overridden, null means the default implementation is a null body, i.e. one that does nothing.

An interface is declared with:

Printable Object ; Class_Member_1 (This :     Object)  ; Class_Member_2 (This :    Object)  ; Printable;

You implement an by adding it to a concrete class:

Person; Programmer Object  Person.Object Printable.Object Skilled_In : Language_List; ;    Class_Member_1   (This :  Object); New_Class_Member (This : Object; That : String); Programmer;

As usual, all inherited abstract operations must be overridden although null subprograms ones need not.

Such a type may implement a list of interfaces (called the progenitors), but can have only one parent. The parent may be a concrete type or also an interface.

Derived  Parent  Progenitor_1  Progenitor_2 ... ...;

Multiple Inheritance via Mix-in
Ada supports multiple inheritance of interfaces (see above), but only single inheritance of implementation. This means that a tagged type can implement multiple interfaces but can only extend a single ancestor tagged type.

This can be problematic if you want to add behavior to a type that already extends another type; for example, suppose you have

Base ; Derived Base ;

and you want to make  controlled, i.e. add the behavior that   controls its initialization, assignment and finalization. Alas you cannot write:

Derived Base  .Controlled ;

since  for historical reasons does not define interfaces   and , but abstract types.

If your base type is not limited, there is no good solution for this; you have to go back to the root of the class and make it controlled. (The reason will become obvious presently.)

For limited types however, another solutions is the use of a mix-in:

Base ; Derived; Controlled_Mix_In (Enclosing: Derived) .Limited_Controlled ; Initialize (This: Controlled_Mix_In); Finalize  (This:  Controlled_Mix_In); Derived Base Mix_In: Controlled_Mix_In (Enclosing => Derived'Access); ;

This special kind of mix-in is an object with an access discriminant that references its enclosing object (also known as Rosen trick). In the declaration of the  type, we initialize this discriminant with a special syntax:   really refers to an access value to the current instance of type. Thus the access discriminant allows the mix-in to see its enclosing object and all its components; therefore it can initialize and finalize its enclosing object:

Initialize (This: Controlled_Mix_In) Enclosing: Derived This.Enclosing.; Initialize;

and similarly for.

The reason why this does not work for non-limited types is the self-referentiality via the discriminant. Imagine you have two variables of such a non-limited type and assign one to the other:

X := Y;

In an assignment statement,  is called only after   of the target   and so cannot provide the new value of the discriminant. Thus  will inevitably reference.

Now let's further extend our hierarchy:

Further Derived ; Initialize (This: Further); Finalize  (This:  Further);

Oops, this does not work because there are no corresponding procedures for, yet – so let's quickly add them.

Base ; Derived; Controlled_Mix_In (Enclosing: Derived) .Limited_Controlled ; Initialize (This: Controlled_Mix_In); Finalize  (This:  Controlled_Mix_In); Derived Base Mix_In: Controlled_Mix_In (Enclosing => Derived'Access); ; Initialize (This:  Derived); Finalize  (This:  Derived); Further Derived ;

Initialize (This: Further); Finalize  (This:  Further);

We have of course to write  for the procedures on   because there is indeed nothing they could override. The bodies are

Initialize (This: Derived) Initialize;

Initialize (This: Controlled_Mix_In) Enclosing: Derived This.Enclosing.; Initialize (Enclosing); Initialize;

To our dismay, we have to learn that  for objects of type   will not be called, instead those for the parent. Why?

X: Further; -- Initialize (Derived (X)) is called here ; ; -- Finalize (Derived (X)) is called here

The reason is that the mix-in defines the local object  to be of type   in the renames-statement above. To cure this, we have necessarily to use the dreaded redispatch (shown in different but equivalent notations):

Initialize (This: Controlled_Mix_In) Enclosing: Derived This.Enclosing.; Initialize (Derived'Class (Enclosing)); Initialize;

Finalize (This: Controlled_Mix_In) Enclosing: Derived'Class Derived'Class (This.Enclosing.); Enclosing.Finalize; Finalize;

X: Further; -- Initialize (X) is called here ; ; -- Finalize (X) is called here

Alternatively (and presumably better still) is to write

Controlled_Mix_In (Enclosing: Derived'Class) .Limited_Controlled ;

Then we automatically get redispatch and can omit the type conversions on.

Class names
Both the class package and the class record need a name. In theory they may have the same name, but in practice this leads to nasty (because of unintuitive error messages) name clashes when you use the  clause. So over time three de facto naming standards have been commonly used.

Classes/Class
The package is named by a plural noun and the record is named by the corresponding singular form.

Persons Person Name  : String (1 .. 10); Gender : Gender_Type; ; Persons;

This convention is the usually used in Ada's built-in libraries.

Disadvantage: Some "multiples" are tricky to spell, especially for those of us who aren't native English speakers.

Class/Object
The package is named after the class, the record is just named Object.

Person Object Name  : String (1 .. 10); Gender : Gender_Type; ; Person;

Most UML and IDL code generators use this technique.

Disadvantage: You can't use the  clause on more than one such class packages at any one time. However you can always use the "type" instead of the package.

Class/Class_Type
The package is named after the class, the record is postfixed with _Type.

Person Person_Type Name  : String (1 .. 10); Gender : Gender_Type; ; Person;

Disadvantage: lots of ugly "_Type" postfixes.

Object-Oriented Ada for C++ programmers
In C++, the construct is strictly equivalent to the following in Ada:

P    C ; V (This : C); W (This : C'Class); U; P;

In C++, member functions implicitly take a parameter  which is of type. In Ada, all parameters are explicit. As a consequence, the fact that  does not take a parameter is implicit in C++ but explicit in Ada.

In C++,  is a pointer. In Ada, the explicit  parameter does not have to be a pointer; all parameters of a tagged type are implicitly passed by reference anyway.

Static dispatching
In C++, function calls dispatch statically in the following cases:

 * the target of the call is an object type
 * the member function is non-virtual

For example: both dispatch statically. In particular, the static dispatch for v may be confusing; this is because object is neither a pointer nor a reference. Ada behaves exactly the same in this respect, except that Ada calls this static binding rather than dispatching:

Object : P.C;   Object.V;     Object.W;  ;

Dynamic dispatching
In C++, a function call dispatches dynamically if the two following conditions are met simultaneously:

 * the target of the call is a pointer or a reference
 * the member function is virtual.

For example: In Ada, a primitive subprogram call dispatches (dynamically) if and only if:

 * the target object is of a class-wide type;

Note: In Ada vernacular, the term dispatching always means dynamic.

For example:

Object : P.C'Class := ...; P.V (Object); P.W (Object); P.U; ;

As can be seen there is no need for access types or pointers to do dispatching in Ada. In Ada, tagged types are always passed by-reference to subprograms without the need for explicit access values.

Also note that in C++, the class serves as:

 * the unit of encapsulation (Ada uses packages and visibility for this)
 * the type, like in Ada.

As a consequence, you call C::u in C++ because u is encapsulated in C, but P.U in Ada since U is encapsulated in the package P, not the type C.

Class-wide and specific types
The most confusing part for C++ programmers is the concept of a "class-wide type". To help you understand:

 * pointers and references in C++ are really, implicitly, class-wide;
 * object types in C++ are really specific;
 * C++ provides no way to declare the equivalent of:

C_Specific_Access C;

 * C++ provides no way to declare the equivalent of:

C_Specific_Access_One C;  C_Specific_Access_Two  C;

which, in Ada, are two different, incompatible types, possibly allocating their memory from different storage pools!

 * In Ada, you do not need access values for dynamic dispatching.
 * In Ada, you use access values for dynamic memory management (only) and class-wide types for dynamic dispatching (only).
 * In C++, you use pointers and references both for dynamic memory management and for dynamic dispatching.
 * In Ada, class-wide types are explicit (with ).
 * In C++, class-wide types are implicit (with  or  ).

Constructors
in C++, a special syntax declares a constructor: A constructor cannot be virtual. A class can have as many constructors, differentiated by their parameters, as necessary.

Ada does not have such constructors. Perhaps they were not deemed necessary since in Ada, any function that returns an object of the tagged type can serve as a kind of constructor. This is however not the same as a real constructor like the C++ one; this difference is most striking in cases of derivation trees (see Finalization below). The Ada constructor subprograms do not have to have a special name and there can be as many constructors as necessary; each function can take parameters as appropriate.

P    T is  ; Make                 T;  -- constructor To_T (From: Integer) T;  -- another constructor Make (This: T);            -- not a constructor ... P;

If an Ada constructor function is also a primitive operation (as in the example above), it becomes abstract upon derivation and has to be overridden if the derived type is not itself abstract. If you do not want this, declare such functions in a nested scope.

In C++, one idiom is the copy constructor and its cousin the assignment operator: This copy constructor is invoked implicitly on initialization, e.g. Ada provides a similar functionality by means of controlled types. A controlled type is one that extends the predefined type :

; P     T   .Controlled  ; Make T;  -- constructor T ... ;    Initialize (This:   T); Adjust    (This:   T); -- copy constructor P;

Note that Initialize is not a constructor; it resembles the C++ constructor in some way, but is also very different. Suppose you have a type T1 derived from T with an appropriate overriding of Initialize. A real constructor (like the C++ one) would automatically first construct the parent components (T), then the child components. In Ada, this is not automatic. In order to mimic this in Ada, we have to write:

Initialize (This:  T1) Initialize (T (This)); -- Don't forget this part! ... -- handle the new components here Initialize;

The compiler inserts a call to Initialize after each object of type T is allocated when no initial value is given. It also inserts a call to Adjust after each assignment to the object. Thus, the declarations:

A: T; B: T := X;

will:

 * allocate memory for A
 * call Initialize (A)
 * allocate memory for B
 * copy the contents of X to B
 * call Adjust (B)

Initialize (B) will not be called because of the explicit initialization.

So, the equivalent of a copy constructor is an overriding of Adjust.

If you would like to provide this functionality to a type that extends another, non-controlled type, see "Multiple Inheritance".

Destructors
In C++, a destructor is a member function with only the implicit  parameter: While a constructor cannot be virtual, a destructor must be virtual if the class is to be used with dynamic dispatch (has virtual methods or derives from a class with virtual methods). C++ classes do not use dynamic dispatch by default, so it can catch some programmers out and wreak havoc in their programs by simply forgetting the keyword.

In Ada, the equivalent functionality is again provided by controlled types, by overriding the procedure Finalize:

; P      T   .Controlled  ; Make T;  -- constructor T ... ;     Finalize (This:   T);  -- destructor P;

Because Finalize is a primitive operation, it is automatically "virtual"; you cannot, in Ada, forget to make a destructor virtual.

Encapsulation: public, private and protected members
In C++, the unit of encapsulation is the class; in Ada, the unit of encapsulation is the package. This has consequences on how an Ada programmer places the various components of an object type. A way to mimic this C++ class in Ada is to define a hierarchy of types, where the base type is the public part, which must be abstract so that no stand-alone objects of this base type can be defined. It looks like so:

; CPP Public_Part     -- no objects of this type A: Integer; ;   Public_Proc (This:   Public_Part); Complete_Type  Public_Part  ; -- procedure Public_Proc (This: in out Complete_Type); -- inherited, implicitly defined -- visible for children Private_Part; -- declaration stub Private_Part_Pointer  Private_Part; Private_Component  .Controlled P: Private_Part_Pointer; record; Initialize (X:  Private_Component); Adjust    (X:   Private_Component); Finalize  (X:   Private_Component); Complete_Type  Public_Part B: Integer; P: Private_Component; -- must be controlled to avoid storage leaks ;     Protected_Proc (This: Complete_Type); CPP;

The private part is defined as a stub only, its completion is hidden in the body. In order to make it a component of the complete type, we have to use a pointer since the size of the component is still unknown (the size of a pointer is known to the compiler). With pointers, unfortunately, we incur the danger of memory leaks, so we have to make the private component controlled.

For a little test, this is the body, where the subprogram bodies are provided with identifying prints:

Ada.Unchecked_Deallocation; Ada.Text_IO; CPP Public_Proc (This:  Public_Part)   -- primitive Ada.Text_IO.Put_Line ("Public_Proc" & Integer'Image (This.A)); Public_Proc; Private_Part   -- complete declaration C: Boolean; ;    Initialize (X:   Private_Component) X.P := new Private_Part'(C => True); Ada.Text_IO.Put_Line ("Initialize " & Boolean'Image (X.P.C)); Initialize; (X:  Private_Component) Ada.Text_IO.Put_Line ("Adjust " & Boolean'Image (X.P.C)); X.P := new Private_Part'(C => X.P.C); -- deep copy Adjust; Finalize (X:  Private_Component) Free  Ada.Unchecked_Deallocation (Private_Part, Private_Part_Pointer); Ada.Text_IO.Put_Line ("Finalize " & Boolean'Image (X.P.C)); Free (X.P); Finalize; Private_Proc (This:  Complete_Type)   -- not primitive Ada.Text_IO.Put_Line ("Private_Proc" & Integer'Image (This.A) & Integer'Image (This.B) & ' ' & Boolean'Image (This.P.P.C)); Private_Proc; Protected_Proc (This: Complete_Type)  -- primitive X: Complete_Type := This; Ada.Text_IO.Put_Line ("Protected_Proc" & Integer'Image (This.A) & Integer'Image (This.B)); Private_Proc (X); Protected_Proc; CPP;

We see that, due to the construction, the private procedure is not a primitive operation.

Let's define a child class so that the protected operation can be reached:

CPP.Child Do_It (X: Complete_Type); -- not primitive CPP.Child;

A child can look inside the private part of the parent and thus can see the protected procedure:

Ada.Text_IO; CPP.Child Do_It (X: Complete_Type) Ada.Text_IO.Put_Line ("Do_It" & Integer'Image (X.A) & Integer'Image (X.B)); Protected_Proc (X); Do_It; CPP.Child;

This is a simple test program, its output is shown below.

CPP.Child; CPP.Child, CPP; Test_CPP X, Y: Complete_Type; X.A := +1; Y.A := -1; Public_Proc (X); Do_It (X); Public_Proc (Y); Do_It (Y); X := Y;  Public_Proc (X);  Do_It (X); Test_CPP;

This is the commented output of the test program:

Initialize TRUE                    Test_CPP: Initialize X Initialize TRUE                                      and Y Public_Proc 1                       |  Public_Proc (X):  A=1 Do_It 1-1073746208                 |  Do_It (X):        B uninitialized Adjust TRUE                        |  |  Protected_Proc (X): Adjust local copy X of This Protected_Proc 1-1073746208        |  |  | Private_Proc 1-1073746208 TRUE     |  |  |  Private_Proc on local copy of This Finalize TRUE                      |  |  Protected_Proc (X): Finalize local copy X Public_Proc-1                       |  ditto for Y Do_It-1 65536                       |  | Adjust TRUE                        |  | Protected_Proc-1 65536             |  | Private_Proc-1 65536 TRUE          |  | Finalize TRUE                      |  | Finalize TRUE                      |  Assignment: Finalize target X.P.C Adjust TRUE                         |  |           Adjust: deep copy Public_Proc-1                      |  again for X, i.e. copy of Y Do_It-1 65536                       |  | Adjust TRUE                        |  | Protected_Proc-1 65536             |  | Private_Proc-1 65536 TRUE          |  | Finalize TRUE                      |  | Finalize TRUE                      Finalize Y Finalize TRUE                            and X

You see that a direct translation of the C++ behaviour into Ada is difficult, if feasible at all. Methinks, the primitive Ada subprograms corresponds more to virtual C++ methods (in the example, they are not). Each language has its own idiosyncrasies which have to be taken into account, so that attempts to directly translate code from one into the other may not be the best approach.

De-encapsulation: friends and stream input-output
In C++, a friend function or class can see all members of the class it is a friend of. Friends break encapsulation and are therefore to be discouraged. In Ada, since packages and not classes are the unit of encapsulation, a "friend" subprogram is simply one that is declared in the same package as the tagged type.

In C++, stream input and output are the particular case where friends are usually necessary: Ada does not need this construct because it defines stream input and output operations by default: The default implementation of the,  ,   and   attributes may be overridden (shown for   as an example). The overriding must occur before the type is frozen, i.e. (in the case of this example) in the package specification.

AdaStreams P     C        C          A B  Integer C Boolean My_Write Stream    AdaStreamsRoot_Stream_Type Item    C     C  My_Write P

By default, the  attribute sends the components to the stream in the same order as given in the declaration, i.e. A, B then C, so we change the order.

P     My_Write Stream     AdaStreamsRoot_Stream_Type Item  C        Boolean Stream ItemC Integer Stream ItemB Integer Stream ItemA My_Write P

Now  calls the overridden version of the package.

AdaText_IOText_Streams P  Main Object PC     PC AdaText_IOText_StreamsStream AdaText_IOStandard_Output Object Main

Note that the stream IO attributes are not primitive operations of the tagged type; this is also the case in C++ where the friend operators are not, in fact, member functions of the type.

Wikibook

 * Ada Programming
 * Ada Programming/Types/record
 * record
 * interface
 * tagged

Wikipedia

 * Object-oriented programming

Ada Quality and Style Guide

|OO

Programación en Ada/Tipos etiquetados

title: Ada Programming/Object Orientation


text:
Ada Programming/Attributes/'Class

The Class attribute denotes the class wide type of the given tagged type.

Wikibook

 * Ada Programming
 * Ada Programming/Object Orientation
 * Ada Programming/OO

Ada Reference Manual

|Class Attributes:Class

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

title: Ada Programming/Attributes/'Class


text:
Cookbook talk:Shortening

Don't be saying that Apple Sauce can replace shortening. You just try that for deep-fat frying, then come back and tell us how it went!

This module uses text originaly published in our sister project, Wikipedia, in the article Shortening. The page history at the time the content was copied is included below.

* (cur) (last) 18:45, 29 Oct 2004 159.83.183.236 (small spacing tweak) * (cur) (last) 19:48, 17 Oct 2004 Bill Thayer m (sharper cat) * (cur) (last) 01:02, 5 Oct 2004 24.85.33.72 * (cur) (last) 01:01, 5 Oct 2004 24.85.33.72 * (cur) (last) 15:30, 6 Aug 2004 Burschik m (added category) * (cur) (last) 07:00, 20 May 2004 4.15.120.30 * (cur) (last) 06:56, 20 May 2004 4.15.120.30 * (cur) (last) 06:50, 20 May 2004 Evil saltine * (cur) (last) 06:49, 20 May 2004 4.15.120.30 * (cur) (last) 06:48, 20 May 2004 4.15.120.30

title: Cookbook talk:Shortening


text:
Category:Fats and oils

For information about fats and oils in general, see Cookbook:Oil and fat.

title: Category:Fats and oils


text:
Category:Cheese recipes

Recipes involving cheese.

es:Categoría:Queso

title: Category:Cheese recipes


text:
Category:Dairy recipes

Recipes involving dairy products.

title: Category:Dairy recipes


text:
Category:Bulgarian recipes

Recipes from Bulgaria.

nl:Categorie:Bulgaarse keuken

title: Category:Bulgarian recipes


text:
Quechua/1/Lesson

Now it is not expected that you'll be able to pronounce Quechua correctly just from reading the last lesson, however as you complete the next lessons it is suggested that you keep going back to the first lesson as a reference. This will hopefully help you internalise the rules.

Conversation
Following is a possible basic conversation in Quechua:

 * Antuku: Yaw! Wawqiy! Mayman richkanki?
 * Joe: Wasiyman richkani. Qanri?
 * Antuku: Qhatuman richkani. Tupananchiskama!
 * Joe: Ratukama.

Translation:

 * Antuku: Hey! Brother! Where are (you) going?
 * Joe: (I) am going to my house. And you?
 * Antuku: (I) am going to the market. 'Till we meet again!
 * Joe: See you later.

Grammar
As you can see in the conversation, the verb form "richkanki" is for second-person singular and "richkani" for first-person.

Here we will give an overview of all persons (yachachiy = to teach)

These are the personal pronouns.

title: Quechua/1/Lesson


text:
Talk:Film History/Discussion

I think there would be some benefit to filling out the topic modules before taking a stab at writing the comprehensive modules, since the comprehensive modules should ideally be based on the information in the major topic modules.

title: Talk:Film History/Discussion


text:
User:Robert Horning

pt:Usuário:Robert Horning I'm a software engineer who thinks that Wikibooks has a huge potential to do some good in this world. There are a few thing that I know about that are not in "common" knowledge, and I intend to write some wikibooks to help people out that are trying to learn these subjects.

 * Here are some opinions that I have regarding what some basic policies for Wikibooks ought to be like.
 * A little area I am using to experiment with various editing styles and minor projects.
 * An entire Wikibook at once WARNING: this Wikibook takes a very long time to load on most browsers.
 * Watch List - This is a list of Wikibooks that need some special attention.
 * /Bookshelf Reorganization/ - This is more my vision on how the bookshelves ought to be revised. Feel free to discuss and rearrange as necessary, but this is only a proposal at the moment.

Because sometimes the stuff I write is quite POV, and perhaps heated, I've started a new blog about the open source textbook movement. If you are interested in reading some of my opinions, please check it out here:

http://bookcraft.blogspot.com/

As this site is definitely not owned by the Wikimedia Foundation, it would be harder to remove content from this blog by the WMF or its board of trustees. Still, I intend to mainly concentrate on Wikibooks and general open textbook issues with this forum. If you want to join the "team" of fellow bloggers to add a post to this blog, please let me know.

Some Wikibooks that I'm currently working on:

 * Programming:Serial Data Communications (something I've started)
 * Wikijunior Solar System
 * MediaWiki Administrator's Handbook
 * AP Computer Science
 * State of the Project/2006
 * History of Wikibooks
 * GBA Development
 * Scratch
 * Colors

Here are some tools that I find useful:

 * Wikibooks maintenance

title: User:Robert Horning


text:
Animal Behavior/Nesting Behavior

Over the course of a turtle’s nesting season, a female sea turtle will leave her homing ground and migrate to nesting grounds to build a nest and lay eggs. One species of turtle, Chelonia mydas, the Green sea turtle, lives off the coasts of Brazil but nests each year on the beaches of Ascension Island, a tiny island in the mid-Atlantic Ocean (Papi et al.). These turtles typically make their way to the island between the months of December and March (Sims).

After migrating to a nesting ground, it is time for the female to choose a nesting site along the beach. Many factors play into this decision and a female will scope out a site for a few days before she actually decides to build a nest. However, once the decision of where to nest has been made, females will most likely nest at the same beach and site for the rest of their reproductive years (CCC&STSL).

All species of sea turtles exhibit similar nesting behavior, possibly differing only in inter-nesting period length (the period of time between two nestings during the same nesting season). On the night of nesting, a sea turtle will emerge from the sea and scope out her surroundings one more time before digging a nest. If there seems to be any unnatural distractions (i.e. lighting or human presence), a female may return to the sea without building a nest (“false crawl”). Most often, however, she will proceed to dig a nest on the beach. To do this, the female turtle first digs a relatively shallow depression, known as a body pit, in the sand using her front flippers and body to push sand out of the way. Then she will excavate a single egg chamber, a deeper cavity opening to the body pit, into which she will oviposit an entire clutch of eggs during nesting. Finally, after constructing this egg chamber, she will begin ovipositing her eggs. It is extremely rare that a sea turtle will stop nesting before laying is complete but will happen if the female senses extreme danger (CCC&STSL).

After laying eggs, the female will camouflage her nest by filling in the body pit with sand and return to the sea only to nest at the same site at a later date in the nesting season. After nesting a second time, the female sea turtle will return to the sea and migrate back to her homing ground (CCC&STSL).

Many nesting grounds, such as that of the Green sea turtle, are extremely far from the species’ homing ground. This migration of sea turtles during the nesting season has led to the development of many different hypotheses of how these adult female turtles continually find the common nesting ground and then how offspring navigate to the homing grounds. First, it has been suggested that sea turtles may use the earth’s magnetic field to aid in navigation between homing grounds and nesting grounds. There have, however, been experiments that have weakened this hypothesis in adult sea turtles. One such experiment involved placing magnets on the back of experimental Green sea turtles in order to disrupt the magnetic field possibly detected by the sea turtles and the courses these turtles followed on the return journey from Ascension Island were tracked. The results show that, although hatchlings may be able to navigate via earth’s magnetic field, it is very possible that this ability is absent in adults (Papi et al.). However, another hypothesis has been suggested and states that turtles may use olfactory cues from the ocean currents and winds to navigate through the ocean to nesting grounds (Sims).

"General Behavior Patterns of Sea Turtles." Caribbean Conservation Corporation and Sea Turtle Survival League (CCC&STSL). Accessed 3 December 2004. http://www.cccturtle.org/behav.htm

Papi, F., P. Luschi, S. Akesson, S. Capogrossi, and G.C. Hays. "Open-sea Migration of     Magnetically Disturbed Sea Turtles." The Journal of Experimental Biology 203:27 (2000): 3435-3443.

Sims, David W. "Homing is a Breeze for Sea Turtles." Nature (London) 423: 6936 (2003): 128.

title: Animal Behavior/Nesting Behavior


text:
User:Mikkalai

This is wikipedia:user:mikkalai This is my future hero.

title: User:Mikkalai


text:
User talk:Mikkalai

Talk to wikipedia:user talk:mikkalai

title: User talk:Mikkalai


text:
User talk:Naryathegreat~enwikibooks

Naryathegreat|(talk) 20:29, 30 Apr 2005 (UTC)

California standards discussion
Narythegreat,

Do you know what happened to the California standards that were up on the site? We have a bunch of professionals who will donate their work to the page if we use the California standards that were up originally. Can you help me find them and put them back up on the page? The person who started the page originally did so with that set of standards, then went off to get professional volunteers. Now that he has the volunteers, the standards are changed and he is understandable upset. We could maybe make two paralell projects, one using the originally specified California standard and another using the AP standard. What do you think. Can you help me out finding the California standard and getting it back online?

Thanks friend, --Karl Wick 21:16, 13 Dec 2004 (UTC)Karl

Narythegreat,

I found the California standards and reinstated them. Please do not be angry with me. I appreciate of course your efforts. I notice that you moved some of the pages from "World History Project" namespaces to "World History" namespaces. What do you think if you develop your contributions in a paralell space that uses the AP standards and uses the namespace of "World History", and we reserve the "World History Project" namespace for the project that uses the California standards. What do you think of the idea? Assuming you come to be in aggreement ... my time to be on the Internet is very limited; would ou be willing and able to help me divide the work into two?

Thank you kind person, --Karl Wick 22:03, 13 Dec 2004 (UTC)

 * Some quotes from the email they sent me: "We'd been setting up the possibility of having a bunch of World History experts contribute to the California-frameworks-based World History project, gratis. ... I was very disturbed to hear that they had been to the Wiki site and seen the California Standards project that we had discussed replaced by something called the 'AP World History Standard'. These are now deciding to beg off the project!" I hope you can understand where I am coming from on this ... --Karl Wick 22:10, 13 Dec 2004 (UTC)

California Standards
Okay, here I go:

1. I really have to say I'm not a fan of changing back the standards. The California standard isn't very good. The AP standard is approved by a much broader range of people. The use of the California standard is a problem regionally also because newbies will think it's a regional project. I don't mean to discourage contribution, but the AP standard is used elsewhere, such as in the European and U.S. history projects with success (also I changed the project out of the title for simplicity and I kind of kept the other ones as a kind of guiding hand -- see World History, but honestly, I don't care if the project part is eliminated altogether). And furthermore, if there are so many willing contributors, where are they? You are wasting my time by saying that these experts won't contribute under the AP World History standard (which I made the title up but it is the standard for AP World History) and anyway, ''what kind of "experts" don't know what AP is?

2. There have been no edits for almost 4 months by anyone but me. It is ridiculous to demand that I bow to the demands of people who do not put forth any contribution for so long. I will not simply start again from scratch. I kept most the original articles and structure anyway, just changed the standard, and the California one isn't very good. It's an overly simplistic and western-centered one.

3. I will be very surprised if we go with the California standard and we see these "expert's" contributions pan out-you of all people must see that people lose focus after a while and abandon projects, like this one's former contributors. I doubt very highly that you will see anyone doing anything substantial for free after such a reversion. (And also, anyone can just copy and paste their research paper into the project anyway). I am avidly adding free material, and I welcome help, but what on earth is wrong with the AP standard anyway? I don't know a soul who after even a casual glance at both would support the California (standard). Also, since Wikibooks is so limited in its contributors anyway, we need to be accepting of other peoples ideas, and honestly the standards thing amounts to a bunch of bull anyway. People are going to add what they want and ignore such things in the first place. Very few of our projects have standards anyway.

4. As for the parallel namespaces idea, there seems to be little point in such a duplication of effort and I oppose it even if I have to bow to these peoples' (whoever they are, it is not clear to me) wishes. Also, I did come back and add to this comment, so I hope we don't cause misunderstandings with each other, and I apologize for the sloppy structure. Yours, kindly--Naryathegreat 03:10, 14 Dec 2004 (UTC)

 * Also, you'll note that I changed the standards on November 14, and actually it was a week before that, so you'll see that it took over a month for any of these "contributors" to notice the change anyway :(. I hope you weigh this fact in your opinion of the merit of the statement that these people are just enthusiastically waiting to contribute.  My personal opinion is that it is a lie designed to get you on the side of reverting the standards, but I may be making a big error in judgement.--Naryathegreat 03:29, 14 Dec 2004 (UTC)

Narythegreat, of course I understand that you are upset. Please try to overcome your emotion and remain polite, as I am sure that we can come to a conclusion that is convenient to everyone involved. Thankfully the wiki system makes reverts and changes relatively painless ... One of the first people to offer his help to the Wikibooks project is someone who has worked in the textbook industry for almost twenty years and has started his own not-for-profit with the goal of bringing open-content textbooks to the community, beginning in his native California. He in fact aggrees with you that the AP standards are superior, but as the person who originally started the World History Project as a trial is understandably upset to feel that other people have come in and taken over the project and changed the rules that were governing it.

I don't accuse you of breaking any rule, of course you put up notice of the proposed change of standards and gave time for any objectives to be brought forward, and neither he nor I objected at the time. I didn't know what he had in mind and I am living in Mexico right now with limited Internet access and am less active on the site for the moment.

What I am asking is for your understanding and help to divide the project into two distinct books, one that follows the line that this individual started, and another that follows the direction and the edits that you have contributed.

For the moment I have to act as the representative for this person, who is on the verge of leaving Wikibooks/Wikipedia permanently and advising all of his many high-level contacts of the very negative experience he has had trying to get a textbook together on Wikibooks. This would be a big blow to Wikibooks and I believe to open source textbooks in general.

All he wants is a place for his team of paid, professional textbook-writing history experts to continue the stub of a book that was begun on the World History Project page time back. At the moment these people were so enraged at the abandonment of the original standard that they refuse to continue with the project. I hope to negotiate with them to convince them to continue.

Narythegreat, I need your help. You have the power in your hands to help make this project and the whole site a greater success that will be used in actual classrooms, or to make things more difficult and set the whole site back. You of course are free to choose your course of action. And helping me does not mean that any of your changes have to be lost, because my plan is to make two books, one for each standard.

Please let me know what you think. Karl

California vs AP standard
Having taken both AP and regular California history classes, AP standards cover considerably more than what is required by the California standard. For that reason, I support the AP standard. I, however, don't understand how can both standards not overlap at least 75% of the way. If there some parts that do not overlap, we should try to meet both standards.--Alsocal 03:43, 14 Feb 2005 (UTC)

a bit lost
Hi, My name is James and I'm registered as totalthinker on normal wikipedia. I think this project is really exciting and would like to take part, time permitting. However, I would like to add a few constructive comments;

1. I'm British and have never heard of Californias or AP's; if this site is for lots of people worldwide then this terminology is a bit restrictive and confusing, although I whink using such a course as a foundation guide is a good idea. Just don't include these names as foundational, or if you do then rename the course; "World History AP guide".

2. The contents summary is a bit cluttered and vague at points, for example combining medieval european and middle eastern cultures etc.

3. A very good site is HyperHistory which has a good but quite partisan history of the world; could provide some guidance.

4. The best overall intro to all this I have read was w.h. Mvneill's "The rise of the West". Don't be put off by the title! This book is simply excellent. I think it should be our guide/model.

Thanks, hope it helps.

James

--Firebird000 03:25, 26 August 2005 (UTC)== Helping with World History book ==

Hi. I just wanted to say that I'm glad you helped save the world history book. It's definetly something I'd like to help with. I'm not a history fanatic so I can't write essays on it, but I'd definetly would like to help with content and some graphics work. Definetly worth it.--Alsocal 10:07, 6 Jan 2005 (UTC)

Sure I'm helping. Just point me in a direction right now. I'm sure I can do that great a job right now, as I am busy with some other projects, but I should still be able to make a contribution.--Alsocal 10:16, 15 Feb 2005 (UTC)

I'll be proofreading mostly and I'll see what I can contribute.--Alsocal 01:17, 17 Feb 2005 (UTC)

I'll help out a bit. I'm a world history buff, so I'm good with most things. I wrote the Middle Eastern empires section (as of now, at least) so I did that. I have pretty good all-around knowledge. I could be an essayist or something, as well as continue working on chapters and what-not.--Constantijn 16:14, 26 Apr 2005 (UTC)

Hi. I'm a former AP World History student myself, and I took the AP exam. I'd be happy to help write for the textbook. I already added an appendix on preping for the exam. --Firebird000 03:25, 26 August 2005 (UTC)

Nice job, and a suggestion
Hi there Naryathegreat. Great job you've done so far. It's a crying shame that this sort of project hasn't exploded, as it rightly should. If I could just make a couple of point

1. I would like to second the opinion offered above - I have never heard of either 'standard' or whatever pedants wish to call them. These 'professionals' clearly do not understand the meaning of Wikibooks as an open system, with communally decided standards etc. I would recommend a fairly loose system based around a constantly evolving and perfecting set of rules, as users discover errors, potential bias or faults and suchlike. I see the current set of standards as fairly good overall. If the individuals commented on above are so unbending, they are unlikely to be suited to the discussive method of editing that goes on around here!

2. This is ONLY a suggestion. Have you considered contacting individuals from Wikipedia who have written authoratative articles on topics such as History/World history/Ancient history/Modern history and so on? This could provide a method of crossover and crosslinking the two sites, and utilising the resources of both. Currently Wikibooks (mostly) is not sufficiently authoritative and peer-reviewed to be useful to Wikipedia, but the opposite could certainly provide the explosive growth you say you need and expect! If I were an historian, I would be very willing to commit myself to this project.

3. When the Project becomes large enough, it may be necessary to define certain areas necessary for various syllabii. Why not create a system of markers that can be added to the content, or even colour coding. If this book does start to grow rapidly, individuals will doubtless add content entirely surplus to the requirements of whichever standard is predominant.

Thanks --Mark Lewis 18:41, 10 Jan 2005 (UTC) (soon to be member Mark Lewis)

C++ Top Note
Oi Naryathegreat, just to explain you why I reverted your change on Prog.:C++

Sorry about it, but I do think that the box is really not needed as there is no real need to call attention to the wikibooks limitations :). The name of the page it is not yet set into stone, (that is why I used the spaces in the name) as you may know this is a fork from a prev. book also on wikibooks so the original name was taken and there shouldn´t be 2 books on the same subject so untill I solve the problem (by restructuring the work, merge etc... there is no solution for it).

Can you make a humm template, macro (cant remember the wiki name, or show me how, links etc...) with no box and a merge of the structure of what you did and I used so there is no loss of information (like that the limitation is due to Wikibooks, that will provide more info if the work is accessed outside of the wikiworld, without the use of the box the size of the line doesn't have so much importance, just the information provided by the notice), txs

PS: If you did not agree with my opinion, please move this post to the Talk section of the book, so we will debate and try to get more input on it, txs again

PPS: Herrr, rembered that I could look up what you did, so now I can TEMPLATE also :), I didn't change it (the template) before talking to you, did you use it on more books (that can be a problem, we can end up with lots of templates in place of local rewrites of the same wording) ? --Panic 07:17, 19 Feb 2005 (UTC)

PC World
This magazine is ad-supported, is it not? Who is the largest advertizer? Riiiight...

No editorial bias there, for sure. :-)

Amazing!
Isn't it amazing that people from across the world can come together to write a textbook, which millions can instantly read? No printing, wasted paper, etc. Wikipedia etc. are one of the best reasons for the internet being available. Charlie123 12:53, 25 May 2005 (UTC)

where is the content for "Microsoft Word User's Manual"?
I just clicked through the the link on the page at:

http://en.wikibooks.org/wiki/Microsoft_Word_User%27s_Manual

with text "click here to begin" which links to:

http://en.wikibooks.org/wiki/Microsoft_Word_User%27s_Manual:Contents

That latter page seems to be entirely empty apart from the wikibooks framework for adding/adding-to/editing/commenting-on the page.

What's up with that project?

Blanking
--Derbeth talk 12:12, 4 December 2005 (UTC)

Macroeconomics
are you planning on working on this wikibook? I have been examining it for a few days now and would like to revamp it. Your macrobar is definately a step in the right direction. DettoAltrimenti 18:50, 14 December 2005 (UTC)

Joining the World History Staff
Hello Narya!

I have been perusing your wikibook for the last few weeks and have noticed that you are in need of assistance. I am a California Public High School Student enrolled in AP World and AP US History over two years and have recieved a 5 on both exams. I also tutor other students in both subjects. I was wondering if I could have the opportunity to join your staff as I love to contribute to others' understanding of this fabulous subject. Thank you!

The Bamboozler

P.S. My email is yuri37@gmail.com. Please contact me there. Thank you.

Image copyright problem with Image:Book.jpg
Thanks for uploading Image:Book.jpg. The Wikimedia Foundation is very careful about the images included in Wikibooks because of copyright law, and requires that we maintain a strict copyright policy. The image that may soon be deleted unless we can determine the copyright holder and status.

The copyright holder is usually the creator, the creator's employer, or the last person who was transferred ownership rights. Copyright information on images is signified using copyright templates. The three basic license types on Wikibooks are open content, public domain, and fair use. Find the appropriate template in Image copyright tags and place it on the image page like this:.

Please signify the copyright information on any other images you have uploaded or will upload. Remember that images without this important information or giving false information can be deleted by an administrator. If you have any questions, feel free to contact me, or ask another Wikibookian at the help desk. Thank you.  – Mike.lifeguard  | talk 01:59, 13 July 2007 (UTC)

Wish to Join World History
Hello. I was looking around at World History and I decided that it is a project that I would like to get involved in. I am a college student who happens to like history and World History is what I am currently studying.

If you have no objections, I would like to start filling in Europe in the Middle Ages. Any suggestions you might have would, of course, be welcome.

I look forward to working together.

---Wanderingshadow

Maps World History
I'd be glad to help with the maps on you World History Book. I've added a few recently. (Red4tribe (talk) 15:22, 20 May 2008 (UTC))

Joining world history
Hello, I'm very interested in the work being done to the history books, and I would love to join the team. I am currently studying world history, and hope to contribute as much as possible. If you don't have any objections, I would like to start adding content about the Ancient Middle East. Thanks!

Saylor.org's Ancient Civilizations of the World
Hi there, I noticed that you have made most of the contributions to the World History textbook. I'm currently working with the Saylor Foundation to create a textbook on ancient civilizations that we can host and use for our course on our website (which we offer for free and to anybody online). If you have time, we would love for you to check out Saylor.org's Ancient Civilizations of the World and give us some feedback or make some contributions! --Azin (discuss • contribs) 21:41, 6 June 2012 (UTC)

Your account will be renamed
Hello,

The developer team at Wikimedia is making some changes to how accounts work, as part of our on-going efforts to provide new and better tools for our users like cross-wiki notifications. These changes will mean you have the same account name everywhere. This will let us give you new features that will help you edit and discuss better, and allow more flexible user permissions for tools. One of the side-effects of this is that user accounts will now have to be unique across all 900 Wikimedia wikis. See the announcement for more information.

Unfortunately, your account clashes with another account also called Naryathegreat. To make sure that both of you can use all Wikimedia projects in future, we have reserved the name Naryathegreat~enwikibooks that only you will have. If you like it, you don't have to do anything. If you do not like it, you can pick out a different name.

Your account will still work as before, and you will be credited for all your edits made so far, but you will have to use the new account name when you log in.

Sorry for the inconvenience.

Yours, Keegan Peterzell Community Liaison, Wikimedia Foundation 23:31, 17 March 2015 (UTC)

Renamed
 This account has been renamed as part of single-user login finalisation. If you own this account you can |log in using your previous username and password for more information. If you do not like this account's new name, you can choose your own using this form after logging in: . -- Keegan (WMF) (talk) 05:17, 19 April 2015 (UTC)

title: User talk:Naryathegreat~enwikibooks


text:
QBasic/Text Output

Your first QBasic program: 1HELLO.BAS
The following paragraph requires a computer with QBasic installed

To begin, write down everything from the program below ("PRINT "Hello World") into a text editor or into the QBasic IDE (Integrated Development Interface) itself and save it as "1HELLO.BAS". Next open the file in QBasic (unless you used QBasic IDE in which case it is already open) and press F5. Optionally you can use the "RUN" menu located on the menu bar at the top of the IDE window.  This will execute (run) the program. The words "Hello World" should appear on the upper left hand side of the screen. You have just executed your first QBasic program. If you press F5 again, another line of text saying "Hello World" will appear on the upper left hand side of the screen pushing the first one down to the second row of the screen.  You can follow the same procedure for the rest of the example programs in this wikibook.

PRINT
PRINT is QBasic's text output function. It is the command that we will be exploring through this section. PRINT is a QBasic function that requires arguments. The argument in the "Hello, World!" program we just ran were the words "Hello, World!". So, PRINT is the function and "Hello, World!" is the argument we pass to the function.

PRINT [Text to screen]

''Note: For a short cut, just use a question mark "?" in place of the command "PRINT". Likewise you can use a single quote "'" in place of the key word REM to insert comments in your code''

PRINT, Commas, Semicolons, tab (n) and CLS
This is what the program output should look like: The first line of 2HELLO.BAS outputs "This line will be erased." to the screen. However, in the second line, the CLS command clears the screen immediately after. So, it will only flash momentarily. The text "Hello Jupiter" should line up with '2' under it. More than one comma can be used consecutively. In this example, after "Good Bye" two commas are used to move "For Now" over two tab columns. "For Now" should line up with '3'.

My final statement on this topic is to play around with it. Try using commas and semicolons in a program.

Variables
Variables are used to store information. They are like containers. You can put information in them and later change the information to something else. In this first example they may not seem very useful but in the next section (Input) they will become very useful.

In this example we use two types of variables: string variables and numeric variables. A string variable holds a string of characters, such as words. (A character is a letter, digit or symbol.) In this case, the characters are letters. A string variable is denoted by ending the name of the variable with a dollar sign. The string variable in this program is hello$. Whatever value you assign to hello$ will be displayed in the PRINT statement. The numeric variable is number. Numeric variables do not have a special ending like string variables.

LOCATE statement
LOCATE allows you to position the cursor for the next piece of text output. Contrary to Cartesian coordinates which read (X,Y), the locate statement is LOCATE Y,X. In this case Y is the distance down from the top of the screen and X is the distance from the left side of the screen. The reason that LOCATE does not follow the standard coordinate system is that it is not necessary to include the X portion; you can use the format LOCATE Y which just specifies the line to start on.

LOCATE[row, column] LOCATE[row]

COLOR statement
The program 5FACE.BAS is broken into many sections to make it easier to read. This is an example of a good programming habit. Each three-line piece of code specifies what the color, location and form of its part of the face. The order of the position and the color is unimportant. The new statement COLOR allows you to change the color of the text. Once changed, all output will be in the new color until COLOR or CLS is used.

COLOR [foreground] COLOR [foreground], [background]

The colors are designated by numbers which will be discussed in the next section.

Color by Number
There are 16 colors (in screen mode 0), numbered from 0 to 15.

If you look carefully at this chart you can see that there are 8 main colors (0 through 7) and then those colors repeat, each in a lighter shade. You may also notice that the colors act as a combination of binary values (where blue=1, green=2, red=4, etc.) This makes it much easier to memorize the color scheme. Blinking colors are also available: at 16, the colors start over again with blinking black and extend through 31 (blinking white). However, the blinking option is not available for the background, only for the text (foreground). Add 16 to the color you wish to blink. e.g.: 2+16=18 - Blinking Green, 4+16=20 - Blinking Red.

It is possible to switch the blinking foreground text with an intense background, but this task is beyond the scope of this QBasic textbook, and may not work when MS Windows displays the console in a windowed mode.

Font
On a VGA compatible video card, you can inspect and change the font used in screen mode 0. OUT &H3CE, 5: OUT &H3CF, 0 'Clear even/odd mode OUT &H3CE, 6: OUT &H3CF, 4 'Map VGA mem A0000-BFFFF OUT &H3C4, 2: OUT &H3C5, 4 'Set bit plane 2 OUT &H3C4, 4: OUT &H3C5, 6 'Clear even/odd mode again You can now use PEEK and POKE to access the character data. It starts at absolute address &HA0000 and every character is 32 bytes, each of which is a row of eight bits. The highest bit of each byte corresponds to the leftmost pixel of each row. Usually only the first 16 or 8 rows are used, depending on the WIDTH setting.

When you're done, it's important to put the memory mapping back to what QBasic expects: OUT &H3CE, 6: OUT &H3CF, 14 'Map VGA mem B8000-BFFFF

Summary
In this section we looked at several methods to manipulate text output. All centered around the PRINT statement. LOCATE and COLOR modified where the text was displayed and how it looked. We used CLS to clear the screen and gave a brief introduction to variables which will be expanded upon in later sections.

title: QBasic/Text Output


text:
Blender 3D: Noob to Pro/Using an empty object for coordinates of the textures

Next page: Basic Animation Previous page: Intermediate Textures and Materials -- Back to Index

So, you've read the tutorials on how to model, or you've used Blender before... Cool. Now what? You've created a nice model, you know how to animate it, but you want your textures in a way that Blender won't let you use by default.

Well, don't despair. Blender's not out of resources for you just yet.

I'll take a simple model, and I'll assume you know how to set the camera, render settings to default and add an object.

I'm going to create a simple representation of our planet Earth. Images for that can be found on the web, and there's a finished blender file ready linked at the bottom of this tutorial which has the textures packed in it.

First you get rid of the cube from the default scene. Keep the light and the camera as is. Next add a sphere, go back to object mode and add an empty from the add menu (screenshot below).

Once you added it, you want to add a material to the sphere. Look at another page on how to do that. Once you have the material added, add a texture to the material. Once added, select the type, image.

Load the image (in this case the image is packed within the example blender file) as the texture. Use whatever options you want for the image to appear correct in the preview window.

Once the texture applies to the material, go back to the materials tab (red sphere). There, look for the Map Input tab, and open it. Select Object, and enter the name of the empty object. In this case it will be "Empty" (it is case sensitive, so watch out).

Now try and animate a rotation on the empty, say 360 degrees in 360 frames. (See another tutorial to learn how to do that). Don't move the sphere, and render the animation.

TADA! The earth seems to rotate, but the object doesn't... Now parent the empty to the sphere, so that when you grab the sphere you don't forget to move the empty accordingly. (alt-p after selecting first the empty then the sphere). You can now create really cool animations, where the earth rotates around the sun and on itself, but you only need to worry about the revolution of the earth, not its own rotation. I haven't done that part of the animation, but give it a try, and admire your skills at making earth go round around the sun... Or not!

Next page: Basic Animation Previous page: Intermediate Textures and Materials -- Back to Index


text:
Blender 3D: Noob to Pro/Intermediate Textures and Materials

Next page: Using an empty object for coordinates of the textures Previous page: Not yet created -- Back to Index

All materials in this tutorial are just applied to a simple sphere in order to easily show the effect the textures have and don't have to worry about how the textures are applied for the most part. For a more complex object you will likely have to worry about uv mapping which is not covered in this tutorial. For more information on uv mapping look at UV Map Basics To start select the sphere and bring up the materials panel (can be found by pressing F5 or the icon in the button bar). It should look like this

Hit Add New to add a new material that will be associated with that object. Once you are looking at the material you will notice under the Texture panel eight blank buttons. These are your texture slots. This means you can have 8 textures mapped to vary properties of your material. From Blender 2.36, you can use 10 slots. These slots are processed in sequence. Which means that if you have a texture that will be computed (for example, an environment map), and you have several texture slots used, you should put the computed slot at the end. A texture describes a design, either an image or one of blender's various different texture types. First thing is to add a texture to the material. Do this by selecting one of the blank texture slots and hit Add New button just to the right. The material now has a texture associated with it, you now have to describe that texture. Do this by selecting the brown brick like button on the header or by pressing F6. You will see the same texture slot list with the texture you have already added. From here you can change the various texture types. Basically just play with the various options and you can see the results for something you like. I am not going to cover how each one looks, its easy to figure out via experimentation by changing texture and modifying its parameters and watching the preview. You can apply images (from files) using the images texture type. Most serious 3D modelers have a large collection of textures. Now I will talk about what you can apply textures for. Go back to the material buttons (F5). Then bring up the Map To panel. Here is a screen shot of what you should be seeing.

The top row of buttons you see there tells how the texture will be applied to the material. Multiple texture slots can be applied to the same attribute, and the same texture can apply to multiple attributes. Any buttons that are pressed down the texture will be applied to. Some buttons have two down states. For these buttons the second down state represents the inverse (if this doesn't make much sense don't worry examples will make it more clear). Its important to understand that when you're modifying the textures themselves in the texture buttons (F6) the preview will always show color. Just because it shows that way in the preview doesn't mean it will show that way when finally applied in the material. It will depend on what you map that texture to and how it interacts with the other textures already on the material. I am now going to describe some of the more common attributes you can map textures to as well as give some examples. To start this is the settings for the texture that I will be using if you want to follow along. To get this all I did was change Texture Type to DistortedNoise. Everything else is at defaults.

Next page: Using an empty object for coordinates of the textures Previous page: Not yet created -- Back to Index


text:
Ada Programming/Platform/VM/dotNET

There are two ports of GNAT to the Microsoft .NET platform:
 * A# is an open-source port under GNU General Public License terms developed at the Department of Computer Science at the US Air Force Academy.
 * AdaCore provides a port of their GNAT compiler for the .NET platform. The port is available for their customers, or in the public version (libre).

Wikipedia

 * A#
 * Microsoft .NET

|DotNET DotNET

title: Ada Programming/Platform/VM/dotNET


text:
User:Stellertony/PediaBackup

This page is for backing up important data while the Wikipedia server is not functioning properly. See Wikipedia Status

Do we all go through a metamorphosis? I believe that we are constantly metamorphosing as individuals as well as a society. Our success as a culture is dependent on change. One might argue that change and metamorphosis are completely different ideas. I do not see them as such, but merely as different levels of the same thing. Change is defined by Wiktionary as "the process of becoming different." Metamorphosis is defined by The American Heritage® Dictionary of the English Language, Fourth Edition as "A marked change in appearance, character, condition, or function."

title: User:Stellertony/PediaBackup


text:
Persian/Lesson 14

 * درس 14 - les 14

 * [[Media:fa-سگ.ogg|سگ]] - hond
 * [[Media:fa-حيوان.ogg|حيوان]] - dieren
 * [[Media:fa-مهربان.ogg|مهربان]] - aardig
 * [[Media:fa-گوسسفند.ogg|گوسسفند]] - schaap
 * [[Media:fa-گرگ.ogg|گرگ]] - wolf
 * [[Media:fa-رفتن.ogg|رفتن]] - gaan
 * [[Media:fa-آمدن.ogg|آمدن]] - komen
 * [[Media:fa-برگشتن.ogg|برگشتن]] - terugkomen
 * [[Media:fa-ديدن.ogg|ديدن]] - zien
 * [[Media:fa-ترس.ogg|ترس]] - bang
 * [[Media:fa-ترسيدن.ogg|ترسيدن]] - bang zijn
 * [[Media:fa-گفتن.ogg|گفتن]] - zeggen
 * [[Media:fa-گردش.ogg|گردش]] - picknick, wandeling
 * [[Media:fa-گردش كردن.ogg|گردش كردن]] - picknicken
 * [[Media:fa-نزديك.ogg|نزديك]] - dichtbij
 * [[Media:fa-پدر بزرگ.ogg|پدر بزرگ]] - opa
 * [[Media:fa-زري.ogg|زري]] - Zari meisjesnaam
 * [[Media:fa-نزديك شدن.ogg|نزديك شدن]] - dichtbij komen
 * [[Media:fa-نگهداري.ogg|نگهداري]] - oppas
 * [[Media:fa-نگهداري كردن.ogg|نگهداري كردن]] - oppassen
 * [[Media:fa-چوپان.ogg|چوپان]] - herder
 * [[Media:fa-يك روز اكرم و زري با پدر بزرگ به گردش رفتند.ogg|يك روز اكرم و زري با پدر بزرگ به گردش رفتند]] - Akram en Zari gingen met opa wandelen
 * [[Media:fa-در راه يك سگ چوپان ديدند.ogg|در راه يك سگ چوپان ديدند]] - Onderweg zagen zij een herdershond
 * [[Media:Fa-كه_از_گوسفندان_نگهداري_مي_كرد.ogg|كه از گوسفندان نگهداري مي كرد]] - Zij pasten op de schapen
 * [[Media:fa-گرگ اجازه نداشت به گوسفندان نزديك شود.ogg|گرگ اجازه نداشت به گوسفندان نزديك شود]] - Een wolf mag niet bij de schapen komen
 * [[Media:fa-گرگ از سگ چوپان مي ترسدو به آنها نزديك نمي شود.ogg|گرگ از سگ چوپان مي ترسدو به آنها نزديك نمي شود]] - Een wolf is bang voor de herdershond en komt niet dichtbij hen
 * [[Media:fa-پدر بزرگ گفت سگ حيوان خوب و با وفا است.ogg|پدر بزرگ گفت: سگ حيوان خوب و با وفا است]] - Opa zegt dat het een trouwe hond is

 * تكليف شب .  جمله بسازيد - huiswerk
 * چوپان .  ترس . سك  گوسفند - zin maken
 * فعل بسازيد .  گردش كردن  .  ترسيدن   .  رفتن werkwoord vervoegen

Light verbs
Most verbs in Persian are light verbs. There are relatively few simple verbs still in use.

 * (“to have work”), e.g.
 * (“to have work”), e.g.

Some light verbs are active vs. passive in pairs with کردن vs. شدن (e.g. تلفن کردن, تمیر کردن, گریه کردن, فراموش کردن, فکر کردن)

title: Persian/Lesson 14