C Programming

· Knowledge is produced on the basis of a non-reflexive epistemology (Bateson's "bad" epistemology).

· The knowledge produced is thus assumed to be "objective" and "true" (i.e. independent of the means of its production; ignorant of its genesis).

· This tends to have a psychologically limiting effect with respect to alternative knowledge and especially alternative modes of knowledge production. One's viewpoint becomes ossified.

· The unreflective assumption of the "truth" of the knowledge becomes justification for its projection, often forcefully, onto other people and processes in the environments surrounding the knower. A sense of conviction that the world is "like this" leads to inflexible protocols in our institutions and in our modes of interaction with others. In other words, outer processes are also ossified; they become sclerotic.

To use a term from cybernetics, a linear epistemology is not open to calibration. But this lack of openness to calibration is often not simply passive, but active: attempts at calibration are often either discarded or met with increasing rigidity, with a sort of "doubling-down" on the knowledge already produced by the epistemology, and an increasing unwillingness to change the process by which knowledge is produced. We could therefore describe this kind of epistemology as willfully ignorant. This can actually be quite beneficial in producing new knowledge (within the parameters already accepted by the epistemology), because it minimizes the recursive complexity and is more amenable to simplification. Reductionisms of all types, where all phenomena, regardless of their complexity, are explained only in terms of more simple (and often more abstract) entities, are linear epistemologies. Said differently, a linear epistemology allows one to ignore second-order alternatives. Most of modern scientific thinking rests on the back of linear epistemology, to which it is well-suited.

On the other hand, a self-reflexive epistemology is a second-order epistemology (see Table 1 below for a comparison of qualities). The process allows itself to be changed by the content it produces. It is thus an open epistemology that operates on the basis of a recursion between process and content. It is open to calibration, and not simply in a passive way, but actively: it seeks calibration of its own processes through an active monitoring of what it is generating. Whereas a linear epistemology tends to minimize calibrative influences (changes in the way it operates at a second-order level), a recursive epistemology actively embodies them at its heart; it is not merely open to calibration, but is self-calbrative. The linking of process and content in this recursive way is akin to the creation of a new type of sensitivity; we can metaphorically say that operating with a recursive epistemology is the development of a new type of higher sense-organ for a knowing system. This is another way of saying that what a system distinguishes distinguishes its distinguishing. Recursive epistemology is open to self-revision not only at the content level (which is also true of linear epistemologies, although there may still be a difference in their relative inertia to this change), but also at the process level. This means that the kind of newness it can potentially yield includes radical, as well as technical shifts. Radical shifts restructure the further possibilities that are available to the knowing system; they are paradigmatic shifts.

What is important to consider is that the recursion between knowledge and knowing (between content and process) actually applies to allepistemologies, even first-order epistemologies. It is simply that in the case of a first-order epistemology, the epistemology is not systemically inclusive of this fact; we could say that it is not sensitive to its own sensitivity. A second-order epistemology is sensitive to its sensitivities: it includes processes whose content is other processes. The most tightly recursive epistemologies have processes whose content is itself.

A first-order epistemology meets its boundary only by virtue of the loss of what is seen as its potential content. The unknown is assumed to be a specific content that is just like the known in every way except that has yet to be brought to light, discovered, or found. These metaphors work from the assumption that knowledge is somehow waiting "out there" to be had, and the protocols for knowledge production are thus geared towards the transformation of the unknown into the known, often with forceful manipulation and through maximization of control procedures. The unknown is precisely what needs to be minimized, and processes that generate unknowing are therefore seen as barriers to further knowing, leading only to confusion and unclarity. The unknown is valued only negatively, as the not-yet-known. The not-yet-known is pulled through from the other side of the threshold and brought "down" to re-instance the same reality that the epistemology already operates within, as further proof of its existence. The first-order epistemology focuses on the content of what it produces, and derives from this content the very justification for its truth; it invests its validity in its facts.

A second-order epistemology meets its boundary also by virtue of what is not known, but in addition it values the unknowing as an active and potentially transformative process. What for the first-order epistemology is only a potential new content is for the second-order epistemology a potential new way of being. This is a higher-order content, and is not simply "out there" to be discovered but must be enacted to exist; it must be brought into being. The unknowing is thus taken to be an invitation, a doorway, and instead of taking the unknown and making it known through the same epistemological patterns, it opens the door to more unknowing. Enacting a second-order epistemology is to allow one's way of knowing to change, not just the content of what is known. Unknowing is thus valued as a transformative agent, as a source of not only new knowledge but new ways of living forward. For a second-order epistemology, unknowing is a feature to be actively worked with, even developed, rather than a bug to be squashed. Said another way, a linear epistemology does not know that it does not know, while a recursive epistemology does, and makes of this something new of itself. The active incorporation of processes that yield states of unknowing is a primary way that a recursive epistemology self-calibrates.

Table 1. A comparison of the qualities of linear and recursive epistemologies.

Linear Episetmology

Recursive Epistemology

Non-self-reflexive

Self-reflexive

First-order

Second-order

Process kept independent of content

Process changes in response to content

Truth is objective and "out there"

Truth is a way of relating process and content

Content-focused

Process-focused

Validation reflected by its content

Validation as ongoing content-process recursions

Tends toward technical innovation

Can yield paradigmatic shifts

Knowledge produced as "pieces"

Knowledge produced as "wholes"

Unknown as potentially known content

Unknowing as potentially

transformative process

Observer split from environment

Observer and environment are mutually constituted in one process

You have to correctly identify the type of data, for storage efficiency, but even more important, to have the required flexibility. For example, you may decide to store a telephone number as a number. Later you find out that this is an invitation to trouble: if you define it as a number, you can only store digits, but no hyphens, spaces, or parentheses. So, in this case, some kind of alphanumeric data type (text, string; names vary in different programming languages) is more appropriate.

You should give your variable names so that they can be recognized. In a quick exercise, you may work with 3 or 4 variables, so you won't notice the difference. But in a real-world program, you may have scores, or hundreds, of variables; program maintenance would be a nightmare if you can't figure out what several of the variables are used for.

You have to correctly identify the type of data, for storage efficiency, but even more important, to have the required flexibility. For example, you may decide to store a telephone number as a number. Later you find out that this is an invitation to trouble: if you define it as a number, you can only store digits, but no hyphens, spaces, or parentheses. So, in this case, some kind of alphanumeric data type (text, string; names vary in different programming languages) is more appropriate.

You should give your variable names so that they can be recognized. In a quick exercise, you may work with 3 or 4 variables, so you won't notice the difference. But in a real-world program, you may have scores, or hundreds, of variables; program maintenance would be a nightmare if you can't figure out what several of the variables are used for.

You have to correctly identify the type of data, for storage efficiency, but even more important, to have the required flexibility. For example, you may decide to store a telephone number as a number. Later you find out that this is an invitation to trouble: if you define it as a number, you can only store digits, but no hyphens, spaces, or parentheses. So, in this case, some kind of alphanumeric data type (text, string; names vary in different programming languages) is more appropriate.

You should give your variable names so that they can be recognized. In a quick exercise, you may work with 3 or 4 variables, so you won't notice the difference. But in a real-world program, you may have scores, or hundreds, of variables; program maintenance would be a nightmare if you can't figure out what several of the variables are used for.

You have to correctly identify the type of data, for storage efficiency, but even more important, to have the required flexibility. For example, you may decide to store a telephone number as a number. Later you find out that this is an invitation to trouble: if you define it as a number, you can only store digits, but no hyphens, spaces, or parentheses. So, in this case, some kind of alphanumeric data type (text, string; names vary in different programming languages) is more appropriate.

You should give your variable names so that they can be recognized. In a quick exercise, you may work with 3 or 4 variables, so you won't notice the difference. But in a real-world program, you may have scores, or hundreds, of variables; program maintenance would be a nightmare if you can't figure out what several of the variables are used for.

this the question:

Write a program that will simulate the following situation 10,000 times so we can decide the answer to:

Suppose you're on a game show, and you're given the choice of three doors: Behind one door is a car; behind the others, goats. You pick a door, say No. 1, and the host, who knows what's behind the doors, opens another door, say No. 3, which he knows has a goat. He then says to you, "Do you want to pick door No. 2?" Is it to your advantage to switch your choice?

The pseudocode for this assignment would be:

Run a loop 10,000 times that:

• Randomly picks a door that is the "prize door"
• Randomly picks a door that is the "first choice"
• Removes one of the doors that is both not the "prize door" nor the "first choice"
• Randomly picks one of the remaining doors as your "second choice"
• Compares the "prize door" to the "first choice" and "second choice" and saves it

After the loop is done, output a message that tells how many times the "prize door" was the "first choice" and how many times the "prize door" was the "second choice" so we can know what is the best choice.

The output of the homework should look like:

Number of times staying was the correct strategy: [NUMBER]

Number of times switching was the correct strategy: [NUMBER]

Therefore, the best thing to do is to [STRATEGY].

A pure-virtual method is similar to a virtual method. A virtual method is a method that is expected to be overridden in a derived class while a pure-virtual method must be overridden in a derived class. The base class may provide a default implementation for a pure-virtual method, but it is not a requirement, whereas it must provide an implementation for a virtual method. In addition,

any base class that has a pure-virtual method becomes abstract; you cannot instantiate abstract classes -- you are expectedto derive from them.

#include

class Abstract

{

public:

// Pure-virtual method; note the '=0' to denote pure-virtual.

virtual void Show()=0;

};

class Derived : public Abstract

{

public:

virtual void Show()

{

// Implementation is required here!

std:: cout << "Derived" << std::end;

}

};

void main()

{

// Abstract a; // Compiler error!

Derived d;

d.Show(); // Call pure-virtual method.

return( 0 );

}

C++ begins its execution at int main(...parameters...) or int WINAPI WinMain(...parameters...). WinMain() is used in Win32 programming, for windows, message boxes etc. main() is used in console programming.

int main() either have no parameters ( int main()) or it can have two parameters ( int main(int argc, const char* argv[]) ). int argc is the argument count, and const char* argv[] is the argument vector (the values of the arguments). These parameters are only useful if you need to take arguments from the user when you start up the application.

int WINAPI WinMain() must have four parameters. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdParam, int nCmdShow). WINAPI is a method of passing parameters which comes from the days of Fortran and Pascal. It reverses the order the parameters are passed. Why this is necessary is not important WINAPI is simply required by Windows. HINSTANCE hInstance is a handle (a pointer) to the current application instance. HINSTANCE hPrevInstance is a handle to the previous instance. In theory, if there are multiple copies of an application open, then this would point to the last one created. LPSTR lpCmdParam is a long pointer to the command line calling existence to the application. If you were to open, let's say, "MyWin32App.exe" then this would be what lpCmdParam is pointing to. If you were to open "MyWin32App.exe -StartFullscreen" then that would be what it is pointing to. int nCmdShow is the parameter indicating how the window should be opened. You could start the application minimised, maximised etc.

References:

http://www.directxtutorial.com/Tutorial9/A-Win32/dx9A2.aspx

http://en.wikipedia.org/wiki/Main_function_(programming)#C_and_C.2B.2B