Wikia

Psychology Wiki

Computer programming languages

Talk0
34,139pages on
this wiki

Redirected from FORTRAN

Assessment | Biopsychology | Comparative | Cognitive | Developmental | Language | Individual differences | Personality | Philosophy | Social |
Methods | Statistics | Clinical | Educational | Industrial | Professional items | World psychology |

Other fields of psychology: AI · Computer · Consulting · Consumer · Engineering · Environmental · Forensic · Military · Sport · Transpersonal · Index


A programming language is an artificial language that can be used to control the behavior of a machine, particularly a computer.[1] Programming languages, like natural languages, are defined by syntactic and semantic rules which describe their structure and meaning respectively. Many programming languages have some form of written specification of their syntax and semantics; some are defined only by an official implementation.

Programming languages are used to facilitate communication about the task of organizing and manipulating information, and to express algorithms precisely. Some authors restrict the term "programming language" to those languages that can express all possible algorithms;[2] sometimes the term "computer language" is used for more limited artificial languages.

Thousands of different programming languages[3] have been created, and new languages are created every year.

DefinitionsEdit

Traits often considered important for constituting a programming language:

  • Target: Programming languages differ from natural languages in that natural languages are only used for interaction between people, while programming languages also allow humans to communicate instructions to machines. Some programming languages are used by one device to control another. For example PostScript programs are frequently created by another program to control a computer printer or display.

Non-computational languages, such as markup languages like HTML or formal grammars like BNF, are usually not considered programming languages. Often a programming language is embedded in the non-computational (host) language.

PurposeEdit

A prominent purpose of programming languages is to provide instructions to a computer. As such, programming languages differ from most other forms of human expression in that they require a greater degree of precision and completeness. When using a natural language to communicate with other people, human authors and speakers can be ambiguous and make small errors, and still expect their intent to be understood. However, computers do exactly what they are told to do, and cannot understand the code the programmer "intended" to write. The combination of the language definition, the program, and the program's inputs must fully specify the external behavior that occurs when the program is executed.

Many languages have been designed from scratch, altered to meet new needs, combined with other languages, and eventually fallen into disuse. Although there have been attempts to design one "universal" computer language that serves all purposes, all of them have failed to be accepted in this role.[8] The need for diverse computer languages arises from the diversity of contexts in which languages are used:

  • Programs range from tiny scripts written by individual hobbyists to huge systems written by hundreds of programmers.
  • Programmers range in expertise from novices who need simplicity above all else, to experts who may be comfortable with considerable complexity.
  • Programs must balance speed, size, and simplicity on systems ranging from microcontrollers to supercomputers.
  • Programs may be written once and not change for generations, or they may undergo nearly constant modification.
  • Finally, programmers may simply differ in their tastes: they may be accustomed to discussing problems and expressing them in a particular language.

One common trend in the development of programming languages has been to add more ability to solve problems using a higher level of abstraction. The earliest programming languages were tied very closely to the underlying hardware of the computer. As new programming languages have developed, features have been added that let programmers express ideas that are more removed from simple translation into underlying hardware instructions. Because programmers are less tied to the needs of the computer, their programs can do more computing with less effort from the programmer. This lets them write more programs in the same amount of time.[9]

Natural language processors have been proposed as a way to eliminate the need for a specialized language for programming. However, this goal remains distant and its benefits are open to debate. Edsger Dijkstra took the position that the use of a formal language is essential to prevent the introduction of meaningless constructs, and dismissed natural language programming as "foolish."[10] Alan Perlis was similarly dismissive of the idea.[11]

ElementsEdit

SyntaxEdit

File:Python add5 parse.png
File:Python add5 syntax.svg

A programming language's surface form is known as its syntax. Most programming languages are purely textual; they use sequences of text including words, numbers, and punctuation, much like written natural languages. On the other hand, there are some programming languages which are more graphical in nature, using spatial relationships between symbols to specify a program.

The syntax of a language describes the possible combinations of symbols that form a syntactically correct program. The meaning given to a combination of symbols is handled by semantics. Since most languages are textual, this article discusses textual syntax.

Programming language syntax is usually defined using a combination of regular expressions (for lexical structure) and Backus-Naur Form (for grammatical structure). Below is a simple grammar, based on Lisp:

expression ::= atom | list
atom  ::= number | symbol
number  ::= [+-]?['0'-'9']+
symbol  ::= ['A'-'Z''a'-'z'].*
list  ::= '(' expression* ')'

This grammar specifies the following:

  • an expression is either an atom or a list;
  • an atom is either a number or a symbol;
  • a number is an unbroken sequence of one or more decimal digits, optionally preceded by a plus or minus sign;
  • a symbol is a letter followed by zero or more of any characters (excluding whitespace); and
  • a list is a matched pair of parentheses, with zero or more expressions inside it.

The following are examples of well-formed token sequences in this grammar: '12345', '()', '(a b c232 (1))'

Not all syntactically correct programs are semantically correct. Many syntactically correct programs are nonetheless ill-formed, per the language's rules; and may (depending on the language specification and the soundness of the implementation) result in an error on translation or execution. In some cases, such programs may exhibit undefined behavior. Even when a program is well-defined within a language, it may still have a meaning that is not intended by the person who wrote it.

Using natural language as an example, it may not be possible to assign a meaning to a grammatically correct sentence or the sentence may be false:

  • "Colorless green ideas sleep furiously." is grammatically well-formed but has no generally accepted meaning.
  • "John is a married bachelor." is grammatically well-formed but expresses a meaning that cannot be true.

The following C language fragment is syntactically correct, but performs an operation that is not semantically defined (because p is a null pointer, the operations p->real and p->im have no meaning):

complex *p = NULL;
complex abs_p = sqrt (p->real * p->real + p->im * p->im);

The grammar needed to specify a programming language can be classified by its position in the Chomsky hierarchy. The syntax of most programming languages can be specified using a Type-2 grammar, i.e., they are context-free grammars.[12]

Type systemEdit

For more details on this topic, see Type system.
For more details on this topic, see Type safety.

A type system defines how a programming language classifies values and expressions into types, how it can manipulate those types and how they interact. This generally includes a description of the data structures that can be constructed in the language. The design and study of type systems using formal mathematics is known as type theory.

Internally, all data in modern digital computers are stored simply as zeros or ones (binary).

Typed versus untyped languagesEdit

A language is typed if operations defined for one data type cannot be performed on values of another data type.[13] For example, "this text between the quotes" is a string. In most programming languages, dividing a number by a string has no meaning. Most modern programming languages will therefore reject any program attempting to perform such an operation. In some languages, the meaningless operation will be detected when the program is compiled ("static" type checking), and rejected by the compiler, while in others, it will be detected when the program is run ("dynamic" type checking), resulting in a runtime exception.

A special case of typed languages are the single-type languages. These are often scripting or markup languages, such as Rexx or SGML, and have only one data type — most commonly character strings which are used for both symbolic and numeric data.

In contrast, an untyped language, such as most assembly languages, allows any operation to be performed on any data, which are generally considered to be sequences of bits of various lengths.[13] High-level languages which are untyped include BCPL and some varieties of Forth.

In practice, while few languages are considered typed from the point of view of type theory (verifying or rejecting all operations), most modern languages offer a degree of typing.[13] Many production languages provide means to bypass or subvert the type system.

Static versus dynamic typingEdit

In static typing all expressions have their types determined prior to the program being run (typically at compile-time). For example, 1 and (2+2) are integer expressions; they cannot be passed to a function that expects a string, or stored in a variable that is defined to hold dates.[13]

Statically-typed languages can be manifestly typed or type-inferred. In the first case, the programmer must explicitly write types at certain textual positions (for example, at variable declarations). In the second case, the compiler infers the types of expressions and declarations based on context. Most mainstream statically-typed languages, such as C++ and Java, are manifestly typed. Complete type inference has traditionally been associated with less mainstream languages, such as Haskell and ML. However, many manifestly typed languages support partial type inference; for example, Java and C# both infer types in certain limited cases.[14] Dynamic typing, also called latent typing, determines the type-safety of operations at runtime; in other words, types are associated with runtime values rather than textual expressions.[13] As with type-inferred languages, dynamically typed languages do not require the programmer to write explicit type annotations on expressions. Among other things, this may permit a single variable to refer to values of different types at different points in the program execution. However, type errors cannot be automatically detected until a piece of code is actually executed, making debugging more difficult. Ruby, Lisp, JavaScript, and Python are dynamically typed.

Weak and strong typingEdit

Weak typing allows a value of one type to be treated as another, for example treating a string as a number.[13] This can occasionally be useful, but it can also allow some kinds of program faults to go undetected at compile time.

Strong typing prevents the above. Attempting to mix types raises an error.[13] Strongly-typed languages are often termed type-safe or safe. Type safety can prevent particular kinds of program faults occurring (because constructs containing them are flagged at compile time).

An alternative definition for "weakly typed" refers to languages, such as Perl, JavaScript, and C++ which permit a large number of implicit type conversions; Perl in particular can be characterized as a dynamically typed programming language in which type checking can take place at runtime. See type system. This capability is often useful, but occasionally dangerous; as it would permit operations whose objects can change type on demand.

Strong and static are generally considered orthogonal concepts, but usage in the literature differs. Some use the term strongly typed to mean strongly, statically typed, or, even more confusingly, to mean simply statically typed. Thus C has been called both strongly typed and weakly, statically typed.[15][16]

Execution semanticsEdit

Once data has been specified, the machine must be instructed to perform operations on the data. The execution semantics of a language defines how and when the various constructs of a language should produce a program behavior.

For example, the semantics may define the strategy by which expressions are evaluated to values, or the manner in which control structures conditionally execute statements.

Core libraryEdit

For more details on this topic, see Standard library.

Most programming languages have an associated core library (sometimes known as the 'Standard library', especially if it is included as part of the published language standard), which is conventionally made available by all implementations of the language. Core libraries typically include definitions for commonly used algorithms, data structures, and mechanisms for input and output.

A language's core library is often treated as part of the language by its users, although the designers may have treated it as a separate entity. Many language specifications define a core that must be made available in all implementations, and in the case of standardized languages this core library may be required. The line between a language and its core library therefore differs from language to language. Indeed, some languages are designed so that the meanings of certain syntactic constructs cannot even be described without referring to the core library. For example, in Java, a string literal is defined as an instance of the java.lang.String class; similarly, in Smalltalk, an anonymous function expression (a "block") constructs an instance of the library's BlockContext class. Conversely, Scheme contains multiple coherent subsets that suffice to construct the rest of the language as library macros, and so the language designers do not even bother to say which portions of the language must be implemented as language constructs, and which must be implemented as parts of a library.

PracticeEdit

A language's designers and users must construct a number of artifacts that govern and enable the practice of programming. The most important of these artifacts are the language specification and implementation.

SpecificationEdit

For more details on this topic, see Programming language specification.

The specification of a programming language is intended to provide a definition that language users and implementors can use to determine the behavior of a program, given its source code.

A programming language specification can take several forms, including the following:

  • An explicit definition of the syntax and semantics of the language. While syntax is commonly specified using a formal grammar, semantic definitions may be written in natural language (e.g., the C language), or a formal semantics (e.g., the Standard ML[17] and Scheme[18] specifications).
  • A description of the behavior of a translator for the language (e.g., the C++ and Fortran specifications). The syntax and semantics of the language have to be inferred from this description, which may be written in natural or a formal language.
  • A reference or model implementation, sometimes written in the language being specified (e.g., Prolog or ANSI REXX[19]). The syntax and semantics of the language are explicit in the behavior of the reference implementation.

ImplementationEdit

For more details on this topic, see Programming language implementation.

An implementation of a programming language provides a way to execute that program on one or more configurations of hardware and software. There are, broadly, two approaches to programming language implementation: compilation and interpretation. It is generally possible to implement a language using either technique.

The output of a compiler may be executed by hardware or a program called an interpreter. In some implementations that make use of the interpreter approach there is no distinct boundary between compiling and interpreting. For instance, some implementations of the BASIC programming language compile and then execute the source a line at a time.

Programs that are executed directly on the hardware usually run several orders of magnitude faster than those that are interpreted in software.

One technique for improving the performance of interpreted programs is just-in-time compilation. Here the virtual machine monitors which sequences of bytecode are frequently executed and translates them to machine code for direct execution on the hardware.

HistoryEdit

File:Programming language textbooks.jpg
For more details on this topic, see History of programming languages.

Early developmentsEdit

The first programming languages predate the modern computer. The 19th century had "programmable" looms and player piano scrolls which implemented what are today recognized as examples of domain-specific programming languages. By the beginning of the twentieth century, punch cards encoded data and directed mechanical processing. In the 1930s and 1940s, the formalisms of Alonzo Church's lambda calculus and Alan Turing's Turing machines provided mathematical abstractions for expressing algorithms; the lambda calculus remains influential in language design.[20]

In the 1940s, the first electrically powered digital computers were created. The computers of the early 1950s, notably the UNIVAC I and the IBM 701 used machine language programs. First generation machine language programming was quickly superseded by a second generation of programming languages known as Assembly languages. Later in the 1950s, assembly language programming, which had evolved to include the use of macro instructions, was followed by the development of three higher-level programming languages: FORTRAN, LISP, and COBOL. Updated versions of all of these are still in general use, and importantly, each has strongly influenced the development of later languages.[21] At the end of the 1950s, the language formalized as Algol 60 was introduced, and most later programming languages are, in many respects, descendants of Algol.[21] The format and use of the early programming languages was heavily influenced by the constraints of the interface.[22]

RefinementEdit

The period from the 1960s to the late 1970s brought the development of the major language paradigms now in use, though many aspects were refinements of ideas in the very first Third-generation programming languages:

Each of these languages spawned an entire family of descendants, and most modern languages count at least one of them in their ancestry.

The 1960s and 1970s also saw considerable debate over the merits of structured programming, and whether programming languages should be designed to support it.[25] Edsger Dijkstra, in a famous 1968 letter published in the Communications of the ACM, argued that GOTO statements should be eliminated from all "higher level" programming languages.[26]

The 1960s and 1970s also saw expansion of techniques that reduced the footprint of a program as well as improved productivity of the programmer and user. The card deck for an early 4GL was a lot smaller for the same functionality expressed in a 3GL deck.

Consolidation and growthEdit

The 1980s were years of relative consolidation. C++ combined object-oriented and systems programming. The United States government standardized Ada, a systems programming language intended for use by defense contractors. In Japan and elsewhere, vast sums were spent investigating so-called "fifth generation" languages that incorporated logic programming constructs.[27] The functional languages community moved to standardize ML and Lisp. Rather than inventing new paradigms, all of these movements elaborated upon the ideas invented in the previous decade.

One important trend in language design during the 1980s was an increased focus on programming for large-scale systems through the use of modules, or large-scale organizational units of code. Modula-2, Ada, and ML all developed notable module systems in the 1980s, although other languages, such as PL/I, already had extensive support for modular programming. Module systems were often wedded to generic programming constructs.[28]

The rapid growth of the Internet in the mid-1990's created opportunities for new languages. Perl, originally a Unix scripting tool first released in 1987, became common in dynamic Web sites. Java came to be used for server-side programming. These developments were not fundamentally novel, rather they were refinements to existing languages and paradigms, and largely based on the C family of programming languages.

Programming language evolution continues, in both industry and research. Current directions include security and reliability verification, new kinds of modularity (mixins, delegates, aspects), and database integration. [How to reference and link to summary or text]

The 4GLs are examples of languages which are domain-specific, such as SQL, which manipulates and returns sets of data rather than the scalar values which are canonical to most programming languages. Perl, for example, with its 'here document' can hold multiple 4GL programs, as well as multiple JavaScript programs, in part of its own perl code and use variable interpolation in the 'here document' to support multi-language programming.[29]

Measuring language usage Edit

It is difficult to determine which programming languages are most widely used, and what usage means varies by context. One language may occupy the greater number of programmer hours, a different one have more lines of code, and a third utilize the most CPU time. Some languages are very popular for particular kinds of applications. For example, COBOL is still strong in the corporate data center, often on large mainframes; FORTRAN in engineering applications; C in embedded applications and operating systems; and other languages are regularly used to write many different kinds of applications.

Various methods of measuring language popularity, each subject to a different bias over what is measured, have been proposed:

  • counting the number of job advertisements that mention the language[30]
  • the number of books sold that teach or describe the language[31]
  • estimates of the number of existing lines of code written in the language—which may underestimate languages not often found in public searches[32]
  • counts of language references found using a web search engine.

TaxonomiesEdit

For more details on this topic, see Categorical list of programming languages.

There is no overarching classification scheme for programming languages. A given programming language does not usually have a single ancestor language. Languages commonly arise by combining the elements of several predecessor languages with new ideas in circulation at the time. Ideas that originate in one language will diffuse throughout a family of related languages, and then leap suddenly across familial gaps to appear in an entirely different family.

The task is further complicated by the fact that languages can be classified along multiple axes. For example, Java is both an object-oriented language (because it encourages object-oriented organization) and a concurrent language (because it contains built-in constructs for running multiple threads in parallel). Python is an object-oriented scripting language.

In broad strokes, programming languages divide into programming paradigms and a classification by intended domain of use. Paradigms include procedural programming, object-oriented programming, functional programming, and logic programming; some languages are hybrids of paradigms or multi-paradigmatic. An assembly language is not so much a paradigm as a direct model of an underlying machine architecture. By purpose, programming languages might be considered general purpose, system programming languages, scripting languages, domain-specific languages, or concurrent/distributed languages (or a combination of these).[33] Some general purpose languages were designed largely with educational goals.[34]

A programming language may also be classified by factors unrelated to programming paradigm. For instance, most programming languages use English language keywords, while a minority do not. Other languages may be classified as being esoteric or not.

See alsoEdit


ReferencesEdit

  1. ISO 5127—Information and documentation—Vocabulary, clause 01.05.10, defines a programming language as: an artificial language for expressing programs
  2. In mathematical terms, this means the programming language is Turing-complete MacLennan, Bruce J. (1987). Principles of Programming Languages, Oxford University Press. ISBN 0-19-511306-3.
  3. As of May 2006 The Encyclopedia of Computer Languages by Murdoch University, Australia lists 8512 computer languages.
  4. ACM SIGPLAN (2003). Bylaws of the Special Interest Group on Programming Languages of the Association for Computing Machinery. URL accessed on 2006-06-19., The scope of SIGPLAN is the theory, design, implementation, description, and application of computer programming languages - languages that permit the specification of a variety of different computations, thereby providing the user with significant control (immediate or delayed) over the computer's operation.
  5. Dean, Tom (2002). Programming Robots. Building Intelligent Robots. Brown University Department of Computer Science. URL accessed on 2006-09-23.
  6. Digital Equipment Corporation. Information Technology - Database Language SQL (Proposed revised text of DIS 9075). ISO/IEC 9075:1992, Database Language SQL.
  7. The Charity Development Group (1996). The CHARITY Home Page. URL accessed on 2006-06-29., Charity is a categorical programming language..., All Charity computations terminate.
  8. IBM in first publishing PL/I, for example, rather ambitiously titled its manual The universal programming language PL/I (IBM Library; 1966). The title reflected IBM's goals for unlimited subsetting capability: PL/I is designed in such a way that one can isolate subsets from it satisfying the requirements of particular applications. ( Encyclopaedia of Mathematics » P  » PL/I. SpringerLink.). Ada and UNCOL had similar early goals.
  9. Frederick P. Brooks, Jr.: The Mythical Man-Month, Addison-Wesley, 1982, pp. 93-94
  10. Dijkstra, Edsger W. On the foolishness of "natural language programming." EWD667.
  11. Perlis, Alan, Epigrams on Programming. SIGPLAN Notices Vol. 17, No. 9, September 1982, pp. 7-13
  12. Michael Sipser (1997). Introduction to the Theory of Computation, PWS Publishing. ISBN 0-534-94728-X. Section 2.2: Pushdown Automata, pp.101–114.
  13. 13.0 13.1 13.2 13.3 13.4 13.5 13.6 Andrew Cooke. An Introduction to Programming Languages.
  14. Specifically, instantiations of generic types are inferred for certain expression forms. Type inference in Generic Java—the research language that provided the basis for Java 1.5's bounded parametric polymorphism extensions—is discussed in two informal manuscripts from the Types mailing list: Generic Java type inference is unsound (Alan Jeffrey, 17 December 2001) and Sound Generic Java type inference (Martin Odersky, 15 January 2002). C#'s type system is similar to Java's, and uses a similar partial type inference scheme.
  15. Revised Report on the Algorithmic Language Scheme (February 20, 1998).
  16. Luca Cardelli and Peter Wegner. On Understanding Types, Data Abstraction, and Polymorphism. Manuscript (1985).
  17. Milner, R.; M. Tofte, R. Harper and D. MacQueen. (1997). The Definition of Standard ML (Revised), MIT Press. ISBN 0-262-63181-4.
  18. Kelsey, Richard, William Clinger and Jonathan Rees (1998). Section 7.2 Formal semantics. Revised5 Report on the Algorithmic Language Scheme. URL accessed on 2006-06-09.
  19. ANSI — Programming Language Rexx, X3-274.1996
  20. Benjamin C. Pierce writes:
    "... the lambda calculus has seen widespread use in the specification of programming language features, in language design and implementation, and in the study of type systems."
    Pierce, Benjamin C. (2002). Types and Programming Languages, 52, MIT Press. ISBN 0-262-16209-1.
  21. 21.0 21.1 O'Reilly Media. History of programming languages.
  22. Frank da Cruz. IBM Punch Cards Columbia University Computing History.
  23. Richard L. Wexelblat: History of Programming Languages, Academic Press, 1981, chapter XIV.
  24. François Labelle. Programming Language Usage Graph. Sourceforge.. This comparison analyzes trends in number of projects hosted by a popular community programming repository. During most years of the comparison, C leads by a considerable margin; in 2006, Java overtakes C, but the combination of C/C++ still leads considerably.
  25. Hayes, Brian (2006), "The Semicolon Wars", American Scientist 94 (4): pp. 299-303 
  26. Dijkstra, Edsger W. (March 1968). Go To Statement Considered Harmful. Communications of the ACM 11 (3): 147–148.
  27. Tetsuro Fujise, Takashi Chikayama Kazuaki Rokusawa, Akihiko Nakase (December 1994). "KLIC: A Portable Implementation of KL1" Proc. of FGCS '94, ICOT Tokyo, December 1994. KLIC is a portable implementation of a concurrent logic programming language KL1.
  28. Jim Bender. Mini-Bibliography on Modules for Functional Programming Languages. ReadScheme.org. URL accessed on 2006-09-27.
  29. Wall, Programming Perl ISBN 0-596-00027-8 p.66
  30. Survey of Job advertisements mentioning a given language
  31. Counting programming languages by book sales
  32. Bieman, J.M.; Murdock, V., Finding code on the World Wide Web: a preliminary investigation, Proceedings First IEEE International Workshop on Source Code Analysis and Manipulation, 2001
  33. TUNES: Programming Languages.
  34. Wirth, Niklaus (1993). Recollections about the development of Pascal. Proc. 2nd ACM SIGPLAN conference on history of programming languages: 333–342.
  • Aaronson, D., & Grupsmith, E. (1978). The SIMPLE T-scope: Behavior Research Methods & Instrumentation Vol 10(6) Dec 1978, 761-763.
  • Abdulla, A. M., Watkins, L. O., & Henke, J. S. (1984). The use of natural language entry and laser videodisk technology in CAI: Journal of Medical Education Vol 59(9) Sep 1984, 739-745.
  • Adams, F., Aizawa, K., & Fuller, G. (1992). Rules in programming languages and networks. Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Adams, J., Richards, J. H., & Brav-Langer, B. (1980). Data storage and retrieval system for use in a learning disabilities diagnostic clinic: Journal of Learning Disabilities Vol 13(10) Dec 1980, 539-541.
  • Adams, S. T., & DiSessa, A. A. (1991). Learning by "cheating": Students' inventive ways of using a Boxer motion microworld: The Journal of Mathematical Behavior Vol 10(1) Apr 1991, 79-89.
  • Agalianos, A., Noss, R., & Whitty, G. (2001). Logo in mainstream schools: The struggle over the soul of an educational innovation: British Journal of Sociology of Education Vol 22(4) Dec 2001, 479-500.
  • Aho, A. V. (2004). Software and the Future of Programming Languages: Science Vol 304(5662) Apr 2004, 1331-1333.
  • Albers, G., Brand, H., & Cellerier, G. (1991). A microworld for genetic artificial intelligence. Westport, CT: Ablex Publishing.
  • Aldridge, J. W. (1987). Cautions regarding random number generation on the Apple II: Behavior Research Methods, Instruments & Computers Vol 19(4) Nov 1987, 397-399.
  • Alexander, H. (1990). Structuring dialogues using CSP. New York, NY: Cambridge University Press.
  • Algarabel, S. (1983). MEMORIA: A computer program for experimental control of verbal learning and memory experiments with the Apple II microcomputer: Behavior Research Methods & Instrumentation Vol 15(3) Jun 1983, 394.
  • Allan, G. B. (1978). IPA1: A BASIC program to conduct an interactive path analysis: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 415-416.
  • Allen, J. D. (1993). Effects of representation on programming behavior: Dissertation Abstracts International.
  • Allen, R. B. (1982). Cognitive factors in human interaction with computers: Behaviour & Information Technology Vol 1(3) Jul-Sep 1982, 257-278.
  • Allwood, C. M., & Bjorhag, C.-G. (1991). Training of Pascal novices' error handling ability: Acta Psychologica Vol 78(1-3) Dec 1991, 137-150.
  • Allwood, C. M., & Wikstrom, T. (1986). Learning complex computer programs: Behaviour & Information Technology Vol 5(3) Jul-Sep 1986, 217-225.
  • Alonso, A. O. L., & Del Rey, M. H. (2004). Essaying the prolog language to obtain the computational evaluation of the coherence of reasoning: Interdisciplinaria Revista de Psicologia y Ciencias Afines Vol 21(Suppl) 2004, 183-192.
  • Amigues, R., & Ginestie, J. (1991). Representations and strategies of students learning the GRAFCET command language: Le Travail Humain Vol 54(1) Mar 1991, 1-19.
  • Amon, B., Ekenberg, L., Johannesson, P., Munguanaze, M., Njabili, U., & Tesha, R. M. (2003). From first-order logic to automated word generation for Lyee: Knowledge-Based Systems Vol 16(7-8) Nov 2003, 413-429.
  • Anderson, J. R., Conrad, F. G., & Corbett, A. T. (1989). Skill acquisition and the LISP tutor: Cognitive Science: A Multidisciplinary Journal Vol 13(4) Oct-Dec 1989, 467-505.
  • Anderson, J. R., Farrell, R., & Sauers, R. (1984). Learning to program in LISP: Cognitive Science: A Multidisciplinary Journal Vol 8(2) Apr-Jun 1984, 87-129.
  • Anderson, R. E., & Magnan, S. (1995). The Questionnaire Programming Language: Social Science Computer Review Vol 13(3) Fal 1995, 291-303.
  • Angeles, M., & Pickin, S. (2002). Describing generic expertise models as object-oriented analysis patterns: The heuristic multi-attribute decision pattern: Expert Systems: International Journal of Knowledge Engineering and Neural Networks Vol 19(3) Jul 2002, 142-169.
  • Angle, H. V., & Carroll, J. (1979). A computer interview language: Programming the on-line interactive computer: Behavior Research Methods & Instrumentation Vol 11(3) Jun 1979, 379-383.
  • Angrilli, A. (1995). PSAAL: A LabVIEW 3 program for data acquisition and analysis in psychophysiological experiments: Behavior Research Methods, Instruments & Computers Vol 27(3) Aug 1995, 367-374.
  • Anstis, S., & Paradiso, M. A. (1989). Programs for visual psychophysics on the Amiga: A tutorial: Behavior Research Methods, Instruments & Computers Vol 21(5) Oct 1989, 548-563.
  • Anutariya, C., Wuwongse, V., & Akama, K. (2005). XML Declarative Description With First-Order Logical Constraints: Computational Intelligence Vol 21(2) May 2005, 130-156.
  • Apostel, L. (1991). Elusive recursiveness: The necessity of a dynamic and pragmatic approach: A response to Vitale: New Ideas in Psychology Vol 9(3) 1991, 367-373.
  • Arblaster, A. (1982). Human factors in the design and use of computing languages: International Journal of Man-Machine Studies Vol 17(2) Aug 1982, 211-224.
  • Armitage, N., & Bowerman, C. (2002). Knowledge pooling in CALL: Programming an online language learning system for reusability, maintainability and extensibility: Computer Assisted Language Learning Vol 15(1) Feb 2002, 27-53.
  • Arthur, W., Jr., Bennett, W., Jr., & Huffcutt, A. I. (2001). Conducting meta-analysis using SAS. Mahwah, NJ: Lawrence Erlbaum Associates Publishers.
  • Aschersleben, G., & Weber, G. (1988). The analysis of tutorial strategies in individual learning sessions: Psychologie in Erziehung und Unterricht Vol 35(4) 1988, 283-288.
  • Attema, J., & Van der Veer, G. C. (1992). Design of the currency exchange interface: Task action grammar used to check consistency: Zeitschrift fur Psychologie mit Zeitschrift fur angewandte Psychologie Vol 200(2) 1992, 121-133.
  • Au, W. K., & Leung, J. P. (1991). Problem solving, instructional methods and Logo programming: Journal of Educational Computing Research Vol 7(4) 1991, 455-467.
  • Austin, H. S. (1986). Associations of student characteristics to measures of introductory PASCAL computer programming achievement for suburban community college students: Dissertation Abstracts International.
  • Azzedine, A. (1987). The relationship of cognitive development, cognitive style and experience to performance on selected computer programming tasks: An exploration: Dissertation Abstracts International.
  • Baier, J. A., & Pinto, J. A. (2003). Planning under uncertainty as GOLOG programs: Journal of Experimental & Theoretical Artificial Intelligence Vol 15(4) Oct-Dec 2003, 383-405.
  • Bakeman, R. (1983). Computing lag sequential statistics: The ELAG program: Behavior Research Methods & Instrumentation Vol 15(5) Oct 1983, 530-535.
  • Bamberger, H. J. (1985). The effect of Logo (Turtle Graphics) on the problem solving strategies used by fourth grade children: Dissertation Abstracts International.
  • Baptista da Silva, P. V., & Faria Moro, M. L. (1998). The interaction of street teenagers with Logo language: Psicologia: Reflexao e Critica Vol 11(1) 1998, 35-58.
  • Barker, P. M. (1986). Cognitive correlates of performance in computer programming by children and adolescents: Dissertation Abstracts International.
  • Barr, A., Beard, M., & Atkinson, R. C. (1975). A rationale and description of a CAI program to teach the BASIC programming language: Instructional Science Vol 4(1) Apr 1975, 1-31.
  • Bartram, D. (1984). Using Microsoft Basic for statistical analysis: Some cautionary notes: Bulletin of the British Psychological Society Vol 37 Sep 1984, 297-300.
  • Basden, A. (2006). Aspects of knowledge representation. New York, NY: Springer Science + Business Media.
  • Bashaw, W. L. (1965). A FORTRAN program for a central prediction system: Educational and Psychological Measurement 25(1) 1965, 201-204.
  • Bates, T. C., & D'Oliveiro, L. (2003). PsyScript: A Macintosh application for scripting experiments: Behavior Research Methods, Instruments & Computers Vol 35(4) Nov 2003, 565-576.
  • Battista, M., & Clements, D. H. (1986). The effects of Logo and CAI problem-solving environments on problem-solving abilities and mathematics achievement: Computers in Human Behavior Vol 2(3) 1986, 183-193.
  • Bauer, D. W., & Eddy, J. K. (1986). The representation of command language syntax: Human Factors Vol 28(1) Feb 1986, 1-10.
  • Bautista Garcia-Vera, A. (1986). An introduction to vector spaces and the LOGO programming language using the computer: Infancia y Aprendizaje Vol 33(1) 1986, 99-117.
  • Bayman, P. (1984). Effects of instructional procedures on learning a first programming language: Dissertation Abstracts International.
  • Bayman, P., & Mayer, R. E. (1988). Using conceptual models to teach BASIC computer programming: Journal of Educational Psychology Vol 80(3) Sep 1988, 291-298.
  • Beard, D. V., Mantei, M. M., & Teorey, T. J. (1987). Metaform: Updatable form screens and their application to the use of office metaphors in query language instruction: Behaviour & Information Technology Vol 6(2) Apr-Jun 1987, 135-157.
  • Beisser, S., & Gillespie, C. (2003). Kindergarteners can do it--so can you: A case study of a constructionist technology-rich first year seminar for undergraduate college students: Information Technology in Childhood Education Annual Vol 15 2003, 243-260.
  • Berdonneau, C. (1985). The construction of conceptual schemes in 5- to 12-year-old children: Enfance No 2-3 1985, 183-190.
  • Bergantz, D., & Hassell, J. (1991). Information relationships in PROLOG programs: How do programmers comprehend functionality? : International Journal of Man-Machine Studies Vol 35(3) Sep 1991, 313-328.
  • Berry, K. J., & Mielke Jr, P. W. (1997). Agreement measure comparisons between two independent sets of raters: Educational and Psychological Measurement Vol 57(2) Apr 1997, 360-364.
  • Berry, K. J., & Mielke, P. W. (1986). An APL function for computing measures of association for nominal-by-ordinal and ordinal-by-ordinal cross classifications: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 399-402.
  • Berry, K. J., & Mielke, P. W. (1995). Exact cumulative probabilities for the multinomial distribution: Educational and Psychological Measurement Vol 55(5) Oct 1995, 769-772.
  • Berry, K. J., & Mielke, P. W. (1996). Nonasymptotic probability values for Cochran's Q statistic: A FORTRAN 77 program: Perceptual and Motor Skills Vol 82(1) Feb 1996, 303-306.
  • Berry, K. J., & Mielke, P. W., Jr. (1998). A FORTRAN program for permutation covariate analyses of residuals based on Euclidean distance: Psychological Reports Vol 82(2) Apr 1998, 371-375.
  • Bideault, A. (1985). Procedures of CE-2 children in a route construction task: LOGO experiences: Enfance No 2-3 1985, 201-212.
  • Biggs, T. C., Pulham, D., & Bleasdale, F. A. (1988). Apple slide tachistoscope: Behavior Research Methods, Instruments & Computers Vol 20(1) Feb 1988, 49-53.
  • Billings, L. J. (1987). Development of mathematical task persistence and problem-solving ability in fifth and sixth grade students through the use of LOGO and heuristic methodologies: Dissertation Abstracts International.
  • Birnbaum, M. H., & Wakcher, S. V. (2002). Web-based experiments controlled by JavaScript: An example from probability learning: Behavior Research Methods, Instruments & Computers Vol 34(2) May 2002, 189-199.
  • Bishop-Clark, C. (1998). Comparing understanding of programming design concepts using visual basic and traditional basic: Journal of Educational Computing Research Vol 18(1) 1998, 37-47.
  • Bitter, G. G., & Lu, M.-y. (1988). Factors influencing success in a junior high computer programming course: Journal of Educational Computing Research Vol 4(1) 1988, 71-78.
  • Bjork, L.-E. (1974). BASIC programming in the tenth-grade mathematics course and its effects on students' numerical ability and attitudes towards mathematics: Pedagogisk-Psykologiska Problem No 246 Jul 1974, 22.
  • Black, J. B., Kay, D. S., & Soloway, E. M. (1987). Goal and plan knowledge representations: From stories to text editors and programs. Cambridge, MA: The MIT Press.
  • Black, J. B., & Sebrechts, M. M. (1981). Facilitating human-computer communication: Applied Psycholinguistics Vol 2(2) May 1981, 149-177.
  • Blackwelder, C. K. (1987). Logo: A possible aid in the development of Piagetian formal reasoning: Dissertation Abstracts International.
  • Blackwell, A. F., Whitley, K. N., Good, J., & Petre, M. (2001). Cognitive factors in programming with diagrams: Artificial Intelligence Review Vol 15(1-2) Mar 2001, 95-114.
  • Blume, G. W., & Schoen, H. L. (1988). Mathematical problem-solving performance of eighth-grade programmers and nonprogrammers: Journal for Research in Mathematics Education Vol 19(2) Mar 1988, 142-156.
  • Bodrow, W., & Bodrow, l. (2006). Didactical aspects of content production in codewitz: Communication & Cognition Vol 39(1-2) 2006, 51-60.
  • Boecker, H.-D., Eden, H., & Fischer, G. (1991). Interactive problem solving using LOGO. Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Boies, S. J., & Spiegel, M. F. (1973). A behavioral analysis of programming on the use of interactive debugging facilities. Oxford, England: Ibm.
  • Bonar, J. G. (1985). Understanding the bugs of novice programmers: Dissertation Abstracts International.
  • Boomsma, A. (1985). Nonconvergence, improper solutions, and starting values in LISREL maximum likelihood estimation: Psychometrika Vol 50(2) Jun 1985, 229-242.
  • Booth, S. (1993). A study of learning to program from an experiential perspective: Computers in Human Behavior Vol 9(2-3) Sum-Fal 1993, 185-202.
  • Borthick, A. F., Bowen, P. L., Jones, D. R., & Tse, M. H. K. (2001). The effects of information request ambiguity and construct incongruence on query development: Decision Support Systems Vol 32(1) Nov 2001, 3-25.
  • Bottoni, P., Costabile, M. F., Levialdi, S., & Mussio, P. (1997). Defining visual languages for interactive computing: IEEE Transactions on Systems, Man, & Cybernetics Part A: Systems & Humans Vol 27(6) Nov 1997, 773-782.
  • Bouckaert, A., & de Leval, N. (1985). Information and neurolinguistics: Bulletin de Psychologie Scolaire et d'Orientation Vol 34(3) Jul-Sep 1985, 125-132.
  • Bovet, P. (1975). The language problem in programming automized experiments: Cahiers de Psychologie Vol 18(1-3) 1975, 5-17.
  • Bowden, E. M., Douglas, S. A., & Stanford, C. A. (1989). Testing the principle of orthogonality in language design: Human-Computer Interaction Vol 4(2) 1989, 95-120.
  • Brady, M. (1989). Logic programming: Irish Journal of Psychology Vol 10(2) 1989, 304-316.
  • Brent, E. E. (1978). PLA-3: A FORTRAN program for prediction logic analysis for three-dimensional contingency tables: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 454.
  • Briggs, N. E., & Sheu, C.-F. (1998). Using Java in introductory statistics: Behavior Research Methods, Instruments & Computers Vol 30(2) May 1998, 246-249.
  • Briggs, P. (1989). Consistent benefits for the system designer and the end-user: Applied Ergonomics Vol 20(3) Sep 1989, 160-167.
  • Brinkley, V. M. (1990). Pointing behaviors of preschoolers during Logo mastery: Dissertation Abstracts International.
  • Brous, M. T. (1986). LOGO and the learning disabled child: Observation and documentation of LOGO in practice: Dissertation Abstracts International.
  • Brousentsova, T. y. N. (1989). The estimation of didactic effectiveness of instructional courses in the automated instructional system "The Mentor." Voprosy Psychologii No 1 Jan-Feb 1989, 62-72.
  • Brown, R. L. (1986). A comparison of the LISREL and EQS programs for obtaining parameter estimates in confirmatory factor analysis studies: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 382-388.
  • Buendia-Garcia, F., & Diaz, P. (2003). A Framework for the Specification of the Semantics and the Dynamics of Instructional Applications: Journal of Educational Multimedia and Hypermedia Vol 12(4) 2003, 399-424.
  • Burger, D., & Liard, C. (1984). GRIBOL, a computer language: Eta Evolutiva No 18 Jun 1984, 91-98.
  • Burkhardt, K. J. (1976). EMPP: An extensible multiprogramming system for experimental psychology: Behavior Research Methods & Instrumentation Vol 8(2) Apr 1976, 239-244.
  • Burkhardt, K. J. (1979). The design of a real-time operating system for experimental psychology: Behavior Research Methods & Instrumentation Vol 11(5) Oct 1979, 507-511.
  • Burns, B., & Coon, H. (1990). Logo programming and peer interactions: An analysis of process- and product-oriented collaborations: Journal of Educational Computing Research Vol 6(4) 1990, 393-410.
  • Burns, B., & Hagerman, A. (1989). Computer experience, self-concept and problem-solving: The effects of LOGO on children's ideas of themselves as learners: Journal of Educational Computing Research Vol 5(2) 1989, 199-212.
  • Cafolla, R. (1987). The relationship of Piagetian formal operations and other cognitive factors to computer programming ability: Dissertation Abstracts International.
  • Calani Baranauskas, M. C. (1995). Observational studies about novices interacting in a Prolog environment based on tools: Instructional Science Vol 23(1-3) May 1995, 89-109.
  • Calder, B. J., & Rowland, K. M. (1974). A FORTRAN IV program for presenting optimally ordered paired comparison stimuli: Behavior Research Methods & Instrumentation Vol 6(5) Sep 1974, 506.
  • Camerini, G. B. (1984). Children's world, computers, and Piagetian theories: LOGO--toward a new education? : Eta Evolutiva No 18 Jun 1984, 102-110.
  • Campbell, D. J. (1983). Machine language programs for high-speed transfer of data between the KIM-1 and the CBM/PET microcomputers: Behavior Research Methods & Instrumentation Vol 15(5) Oct 1983, 547-548.
  • Campbell, D. J., & Loher, W. (1983). A microcomputer-based modulator for simulating insect songs and the response of crickets to an artificial calling song: Behavior Research Methods & Instrumentation Vol 15(5) Oct 1983, 538-541.
  • Campbell, P. B. (1988). To Author or Not to Author: That is the Question: PsycCRITIQUES Vol 33 (7), Jul, 1988.
  • Campbell, P. F., Fein, G. G., & Schwartz, S. S. (1991). The effects of Logo experience on first-grade children's ability to estimate distance: Journal of Educational Computing Research Vol 7(3) 1991, 331-349.
  • Cannara, A. B. (1976). Experiments in teaching children computer programming: Dissertation Abstracts International.
  • Cannon, F. R. (1977). The transferability of learning of syntax between COBOL and FORTRAN: Dissertation Abstracts International.
  • Carlson, V. R., & Knight, J. (1973). SCV: A general subroutine for the selection of combinations of variables: Behavior Research Methods & Instrumentation Vol 5(5) Sep 1973, 425-427.
  • Carter, J. H. (1992). Comparison of a problem-solving approach to computer programming curriculum with a syntax-oriented approach: Dissertation Abstracts International.
  • Carver, D. L. (1989). Programmer variations in software debugging approaches: International Journal of Man-Machine Studies Vol 31(3) Sep 1989, 315-322.
  • Carver, S. M. (1987). Transfer of LOGO debugging skill: Analysis, instruction, and assessment: Dissertation Abstracts International.
  • Carver, S. M., & Klahr, D. (1986). Assessing children's LOGO debugging skills with a formal model: Journal of Educational Computing Research Vol 2(4) 1986, 487-525.
  • Carver, S. M., & Risinger, S. C. (1987). Improving children's debugging skills. Westport, CT: Ablex Publishing.
  • Castellan, N. J. (1973). Laboratory programming languages and standardization: Behavior Research Methods & Instrumentation Vol 5(2) Mar 1973, 249-252.
  • Cathcart, W. G. (1990). Effects of Logo instruction on cognitive style: Journal of Educational Computing Research Vol 6(2) 1990, 231-242.
  • Chambres, P. (1985). Exploratory research on the capacity for "piloting" in 4- to 6-year-old children: LOGO experiences: Enfance No 2-3 1985, 191-199.
  • Chan, J. S., & Spence, C. (2003). Presenting multiple auditory signals using multiple sound cards in Visual Basic 6.0: Behavior Research Methods, Instruments & Computers Vol 35(1) Apr 2003, 125-128.
  • Chang, W.-C., Hsu, H.-H., Smith, T. K., & Wang, C.-C. (2004). Enhancing SCORM metadata for assessment authoring in e-Learning: Journal of Computer Assisted Learning Vol 20(4) Aug 2004, 305-316.
  • Chapman, J., Hu, L.-t., & Mullen, B. (1986). GROUP1 and GROUP2: BASIC programs for laboratory research on the commons dilemma and group persuasion: Behavior Research Methods, Instruments & Computers Vol 18(5) Oct 1986, 466-467.
  • Charniak, E., Riesbeck, C. K., & Meehan, J. R. (1987). Artificial intelligence programming (2nd ed.). Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Chen, H., & Dong, Y. (2006). Facilitating formal specification acquisition by using recursive functions on context-free languages: Knowledge-Based Systems Vol 19(2) Jun 2006, 141-151.
  • Cherry, J. M. (1986). An experimenting evaluation of prefix and postfix notation in command language syntax: International Journal of Man-Machine Studies Vol 24(4) Apr 1986, 365-374.
  • Chiang, B., Thorpe, H. W., & Lubke, M. (1984). LD students tackle the LOGO language: Strategies and implications: Journal of Learning Disabilities Vol 17(5) May 1984, 303-304.
  • Choi, I., Kim, K., & Jang, M. (2007). An XML-based process repository and process query language for Integrated Process Management: Knowledge & Process Management Vol 14(4) Oct-Dec 2007, 303-316.
  • Choi, W. S. (1991). Effect of Pascal and FORTRAN programming instruction on the problem-solving cognitive ability in formal operational stage students: Dissertation Abstracts International.
  • Chow, A. C. (1991). A generic user interface for hierarchical knowledge-based simulation and control systems: Dissertation Abstracts International.
  • Chubb, G. P., Laughery, K. R., Jr., & Pritsker, A. A. B. (1987). Simulating manned systems. Oxford, England: John Wiley & Sons.
  • Clark, J. A., Jacob, J. L., Maitra, S., & Stanica, P. (2004). Almost Boolean Functions: The Design of Boolean Functions by Spectral Inversion: Computational Intelligence Vol 20(3) Aug 2004, 450-462.
  • Clark, K. L., & McCabe, F. G. (2006). Ontology oriented programming in Go! : Applied Intelligence Vol 24(3) Jun 2006, 189-204.
  • Claveau, V., Sebillot, P., Fabre, C., Bouillon, P., Cussens, J., & Frisch, A. M. (2004). Learning Semantic Lexicons from a Part-of-Speech and Semantically Tagged Corpus Using Inductive Logic Programming: Journal of Machine Learning Research Vol 4(4) May 2004, 493-525.
  • Clement, C. A., Kurland, D. M., Mawby, R., & Pea, R. D. (1986). Analogical reasoning and computer programming: Journal of Educational Computing Research Vol 2(4) 1986, 473-486.
  • Clements, D. H. (1986). Developmental differences in the learning of computer programming: Achievement and relationships to cognitive abilities: Journal of Applied Developmental Psychology Vol 7(3) Jul-Sep 1986, 251-266.
  • Clements, D. H. (1986). Logo and cognition: A theoretical foundation: Computers in Human Behavior Vol 2(2) 1986, 95-110.
  • Clements, D. H. (1987). Longitudinal study of the effects of Logo programming on cognitive abilities and achievement: Journal of Educational Computing Research Vol 3(1) 1987, 73-94.
  • Clements, D. H., & Battista, M. T. (1989). Learning of geometric concepts in a Logo environment: Journal for Research in Mathematics Education Vol 20(5) Nov 1989, 450-467.
  • Clements, D. H., & Battista, M. T. (1990). The effects of Logo on children's conceptualizations of angle and polygons: Journal for Research in Mathematics Education Vol 21(5) Nov 1990, 356-371.
  • Clements, D. H., & Gullo, D. F. (1984). Effects of computer programming on young children's cognition: Journal of Educational Psychology Vol 76(6) Dec 1984, 1051-1058.
  • Clements, D. H., & Merriman, S. (1988). Componential developments in LOGO programming environments. Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Coates, L., & Stephens, L. (1990). Relationship of computer science aptitude with selected achievement measures among junior high students: Journal of Research & Development in Education Vol 23(3) Spr 1990, 162-164.
  • Cody, R. P., & Smith, J. K. (1987). Applied statistics and the SAS programming language (2nd ed.). Oxford, England: North-Holland.
  • Cohen, A. J., & Foley, J. E. (1984). Conjunction of a programming language and text formatter for generating randomized questionnaires: Behavior Research Methods, Instruments & Computers Vol 16(6) Dec 1984, 545-547.
  • Cohen, R. (1987). Implementing Logo in the Grade Two classroom: Acquisition of basic programming concepts: Journal of Computer-Based Instruction Vol 14(4) Fal 1987, 124-132.
  • Cohen, R., & Geva, E. (1989). Designing Logo-like environments for young children: The interaction between theory and practice: Journal of Educational Computing Research Vol 5(3) 1989, 349-377.
  • Collett, M. J. (1989). Using the Proforma PROGRAM command: Behaviour & Information Technology Vol 8(1) Jan-Feb 1989, 65-74.
  • Comrey, A. L., & Ahumada, A. (1965). Note and Fortran IV program for minimum residual factor analysis: Psychological Reports 17(2) 1965, 446.
  • Coney, J. (1989). FORTRAN control of graphics on the Amiga microcomputer: Current Psychology: Research & Reviews Vol 8(2) Sum 1989, 151-154.
  • Cook, D. W. (1987). The effect of computer use and Logo instruction in third and fourth grade students' perceived control: Dissertation Abstracts International.
  • Coombs, M. J., Gibson, R., & Alty, J. L. (1982). Learning a first computer language: Strategies for making sense: International Journal of Man-Machine Studies Vol 16(4) May 1982, 449-486.
  • Corbett, A. T., & Anderson, J. R. (1992). LISP Intelligent Tutoring System: Research in skill acquisition. Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Corte, E. D., Verschaffel, L., & Schrooten, H. (1990). Cognitive effects of learning to program in LOGO: A one-year study with sixth graders: Pedagogische Studien Vol 67(7) Sep 1990, 293-305.
  • Cortes, M. (1997). DCWPL: A coordination language for the development of collaborative applications. Dissertation Abstracts International: Section B: The Sciences and Engineering.
  • Cramer, M. (1990). Structure and mnemonics in computer and command languages: International Journal of Man-Machine Studies Vol 32(6) Jun 1990, 707-722.
  • Cramer, S. E. (1985). Cognitive processing variables as predictors of student performance in learning a computer programming language: Dissertation Abstracts International.
  • Creeger, C. P., Miller, K. F., & Paredes, D. R. (1990). Micromanaging time: Measuring and controlling timing errors in computer-controlled experiments: Behavior Research Methods, Instruments & Computers Vol 22(1) Feb 1990, 34-79.
  • Crook, C. L. (1987). The effects of computer programming on seventh-grade students' use and understanding of variable: Dissertation Abstracts International.
  • Crosby, M. E. (1986). Natural versus computer languages: A reading comparison: Dissertation Abstracts International.
  • Cudeck, R., Klebe, K. J., & Henly, S. J. (1993). A simple Gauss-Newton procedure for covariance structure analysis with high-level computer languages: Psychometrika Vol 58(2) Jun 1993, 211-232.
  • Curtis, B. (1995). Objects of our desire: Empirical research on object-oriented development: Human-Computer Interaction Vol 10(2-3) 1995, 337-344.
  • Daelemans, W., & De Smedt, K. (1994). Default inheritance in an object-oriented representation of linguistic categories: International Journal of Human-Computer Studies Vol 41(1-2) Jul-Aug 1994, 149-177.
  • Dalbey, J., & Linn, M. C. (1986). Cognitive consequences of programming: Augmentations to basic instruction: Journal of Educational Computing Research Vol 2(1) 1986, 75-93.
  • Dalbey, J., Tourniaire, F., & Linn, M. C. (1986). Making programming instruction cognitively demanding: An intervention study: Journal of Research in Science Teaching Vol 23(5) May 1986, 427-436.
  • Dambrot, F. H., Silling, S. M., & Zook, A. (1988). Psychology of computer use: II. Sex differences in prediction of course grades in a computer language course: Perceptual and Motor Skills Vol 66(2) Apr 1988, 627-636.
  • Davies, S. P. (1993). The structure and content of programming knowledge: Disentangling training and language effects in theories of skill development: International Journal of Human-Computer Interaction Vol 5(4) Oct-Dec 1993, 325-346.
  • Davies, S. P., Gilmore, D. J., & Green, T. R. G. (1995). Are objects that important? Effects of expertise and familiarity on classification of object-oriented code: Human-Computer Interaction Vol 10(2-3) 1995, 227-248.
  • Davis, E. A., Linn, M. C., & Clancy, M. J. (1995). Students' off-line and on-line experiences: Journal of Educational Computing Research Vol 12(2) 1995, 109-134.
  • Davis, J. S. (1989). Usability of SQL and menus for database query: International Journal of Man-Machine Studies Vol 30(4) Apr 1989, 447-455.
  • Davis, J. S. (1995). A guessing measure of program comprehension: International Journal of Human-Computer Studies Vol 42(3) Mar 1995, 245-263.
  • Davues, S. P. (1991). The role of notation and knowledge representation in the determination of programming strategy: A framework for integrating models of programming behavior: Cognitive Science: A Multidisciplinary Journal Vol 15(4) Oct-Dec 1991, 547-572.
  • de Haan, G., & Muradin, N. (1992). A case study on applying Extended Task-Action Grammar (ETAG): Zeitschrift fur Psychologie mit Zeitschrift fur angewandte Psychologie Vol 200(2) 1992, 135-156.
  • de Haan, T., & den Brinker, B. P. L. M. (1991). Modula-2 as an introduction to computer science for psychology students. Lisse, Netherlands: Swets & Zeitlinger Publishers.
  • de Moura, M. L., & Acunzo, I. M. (1985). The roots of Logo: An analysis of its psychological bases: Arquivos Brasileiros de Psicologia Vol 37(4) Oct-Dec 1985, 27-33.
  • Dean, D. J., & Segall, M. H. (1978). An APL program for minimum-error Guttman scaling: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 421-425.
  • Detienne, F. (1988). Applying schema theory to program understanding: Le Travail Humain Vol 51(4) Dec 1988, 335-350.
  • Detienne, F. (1995). Design strategies and knowledge in object-oriented programming: Effects of experience: Human-Computer Interaction Vol 10(2-3) 1995, 129-169.
  • di Persio, T., Isbister, D., & Shneiderman, B. (1980). An experiment using memorization/reconstruction as a measure of programmer ability: International Journal of Man-Machine Studies Vol 13(3) Oct 1980, 339-354.
  • Dingler, R., Kadden, R. M., & Snapper, A. G. (1976). An introduction to state notation and SKED: Behavior Research Methods & Instrumentation Vol 8(2) Apr 1976, 69-72.
  • Dixon, M. R. (2003). Creating a portable data-collection system with MicrosoftReg. embedded visual tools for the pocket PC: Journal of Applied Behavior Analysis Vol 36(2) Sum 2003, 271-284.
  • Dlhopolsky, J. G. (1983). Machine language millisecond timers for the Z-80 microprocessor: Behavior Research Methods & Instrumentation Vol 15(5) Oct 1983, 511-520.
  • Dlhopolsky, J. G. (1988). C language functions for millisecond timing on the IBM PC: Behavior Research Methods, Instruments & Computers Vol 20(6) Dec 1988, 560-565.
  • Dlhopolsky, J. G. (1989). Synchronizing stimulus displays with millisecond timer software for the IBM PC: Behavior Research Methods, Instruments & Computers Vol 21(4) Aug 1989, 441-446.
  • Dolker, M., & Halperin, S. (1982). Comparing inverse, polar, and rectangle-wedge-tail FORTRAN routines for pseudo-random normal number generation: Educational and Psychological Measurement Vol 42(1) Spr 1982, 223-226.
  • Domingue, J., & Mulholland, P. (1997). Teaching programming at a distance: The Internet Software Visualization Laboratory: Journal of Interactive Media in Education No 97(1) 1997, No Pagination Specified.
  • Donoghue, J. R., & Collins, L. M. (1990). A note on the unbiased estimation of the intraclass correlation: Psychometrika Vol 55(1) Mar 1990, 159-164.
  • Donzelli, C. A. F., Croisfelts, H., & Bueno, J. L. O. (1998). CONTREXP software for experiment control of animal learning research: Psicologia: Teoria e Pesquisa Vol 14(3) Sep-Dec 1998, 267-269.
  • Dorfman, D. D., & Berbaum, K. S. (1986). RSCORE-J: Pooled rating-method data: A computer program for analyzing pooled ROC curves: Behavior Research Methods, Instruments & Computers Vol 18(5) Oct 1986, 452-462.
  • Doyle, J. R., & Stretch, D. D. (1987). The classification of programming languages by usage: International Journal of Man-Machine Studies Vol 26(3) Mar 1987, 343-360.
  • Drescher, G. L. (1987). Object-oriented logo. Westport, CT: Ablex Publishing.
  • Driver, J., & Louvieris, P. (2002). Integrating the enterprise: The role of a language system for a marketing conception: Qualitative Market Research: An International Journal Vol 5(3) 2002, 172-187.
  • Duncan, S. C., & Tweney, R. D. (1997). Mathematica: A flexible design environment for neural networks: Behavior Research Methods, Instruments & Computers Vol 29(2) May 1997, 194-199.
  • Dunlap, W. P., & Brown, S. G. (1983). FORTRAN IV functions to compute expected normal scores: Behavior Research Methods & Instrumentation Vol 15(3) Jun 1983, 395-397.
  • Dunlap, W. P., & Duffy, J. A. (1975). FORTRAN IV functions for calculating exact probabilities associated with z, x2, t, and F values: Behavior Research Methods & Instrumentation Vol 7(1) Jan 1975, 59-60.
  • Dvarskas, D. P. (1984). The effects of introductory computer programming lessons on the learners' ability to analyze mathematical word problems: Dissertation Abstracts International.
  • Dyck, J. L. (1988). Learning and comprehension of BASIC and Natural Language computer programming by novices: Dissertation Abstracts International.
  • Dyck, J. L., & Mayer, R. E. (1989). Teaching for transfer of computer program comprehension skill: Journal of Educational Psychology Vol 81(1) Mar 1989, 16-24.
  • Eckes, T. (1986). A BASIC program package for the analysis of sorting data: Behavior Research Methods, Instruments & Computers Vol 18(5) Oct 1986, 472-474.
  • Edgell, S. E., & Hertel, S. A. (1989). Running laboratory experiments using the RSX operating system and FORTRAN on the PDP-11: Behavior Research Methods, Instruments & Computers Vol 21(2) Apr 1989, 303-306.
  • Ehrenreich, S. L. (1981). Query languages: Design recommendations derived from the human factors literature: Human Factors Vol 23(6) Dec 1981, 709-725.
  • Eisenstadt, M., Keane, M. T., & Rajan, T. (1992). Novice programming environments: Explorations in human-computer interaction and artificial intelligence. Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Eklundh, K. S., Marmolin, H., & Hedin, C.-E. (1985). Experimental evaluation of dialogue types for data entry: International Journal of Man-Machine Studies Vol 22(6) Jun 1985, 651-661.
  • Ellis, S. R., & Hitchcock, R. J. (1986). The emergence of Zipf's law: Spontaneous encoding optimization by users of a command language: IEEE Transactions on Systems, Man, & Cybernetics Vol SMC-16(3) May-Jun 1986, 423-427.
  • Emerson, P. L. (1965). A FORTRAN generator of polynomials orthonormal over unequally spaced and weighted abscissas: Educational and Psychological Measurement 25(3) 1965, 867-871.
  • Emerson, P. L. (1984). 8080 port addressing with the C/80 compiler: Behavior Research Methods, Instruments & Computers Vol 16(5) Oct 1984, 468-470.
  • Emerson, P. L. (1988). TIMEX: A simple IBM AT C language timer with extended resolution: Behavior Research Methods, Instruments & Computers Vol 20(6) Dec 1988, 566-572.
  • Emerson, P. L. (1988). Using serial interfaces and the C language for real-time experiments: Behavior Research Methods, Instruments & Computers Vol 20(3) Jun 1988, 330-336.
  • Er, M. C. (1984). On the complexity of recursion in problem-solving: International Journal of Man-Machine Studies Vol 20(6) Jun 1984, 537-544.
  • Evans, H. R. (1985). Some effects of Logo programming instruction with fourth grade children: Dissertation Abstracts International.
  • Evans, S., Neideffer, J. D., & Gage, F. H. (1980). APL functions for interactive data analysis: Graphics and labels: Behavior Research Methods & Instrumentation Vol 12(5) Oct 1980, 541-545.
  • Farquhar, A., Fikes, R., & Rice, J. (1997). The Ontolingua Server: A tool for collaborative ontology construction: International Journal of Human-Computer Studies Vol 46(6) Jun 1997, 707-727.
  • Fay, A. L. (1991). Computer programming instruction: The acquisition and transfer of design skills: Dissertation Abstracts International.
  • Fay, A. L., & Mayer, R. E. (1987). Children's naive conceptions and confusions about Logo graphics commands: Journal of Educational Psychology Vol 79(3) Sep 1987, 254-268.
  • Fay, A. L., & Mayer, R. E. (1994). Benefits of teaching design skills before teaching Logo computer programming: Evidence for syntax-independent learning: Journal of Educational Computing Research Vol 11(3) 1994, 187-210.
  • Feghali, A. A. (1992). A study of engineering college students' use of computer-based semantic networks in a computer programming language class: Dissertation Abstracts International.
  • Femano, P. A., & Pfaff, D. W. (1983). Time-interval acquisition on a 6502-based microcomputer: Behavior Research Methods & Instrumentation Vol 15(5) Oct 1983, 521-529.
  • Ferber, J., & Carle, P. (1991). Actors and agents as reflecting concurrent objects: A MERING IV perspective: IEEE Transactions on Systems, Man, & Cybernetics Vol 21(6) Nov-Dec 1991, 1420-1436.
  • Feurzeig, W. (1987). Algebra slaves and agents in a Logo-based mathematics curriculum. Westport, CT: Ablex Publishing.
  • Fickel, M. G. (1986). The effects of Logo study on problem-solving cognitive abilities of sixth-grade students: Dissertation Abstracts International.
  • Fink, P. K., Sigmon, A. H., & Biermann, A. W. (1985). Computer control via limited natural language: IEEE Transactions on Systems, Man, & Cybernetics Vol SMC-15(1) Jan-Feb 1985, 54-68.
  • Finley, G. (1985). Laboratory functions for the Tecmar Lab Tender and IBM PC: Behavior Research Methods, Instruments & Computers Vol 17(3) Jun 1985, 397-398.
  • Finstuen, K., & Wenzel, D. (1977). 3-D PLOT, a FORTRAN IV program for projecting a triplex of factor loadings: Behavior Research Methods & Instrumentation Vol 9(3) Jun 1977, 300.
  • Firth, C., & Thomas, R. C. (1991). The use of command language grammar in a design tool: International Journal of Man-Machine Studies Vol 34(4) Apr 1991, 479-496.
  • Folk, M. J. (1973). Influences of developmental level on a child's ability to learn concepts of computer programming: Dissertation Abstracts International.
  • Ford, M. S. (1985). The effects of computer programming on the problem solving abilities of sixth grade students: Dissertation Abstracts International.
  • Forrest, D. V. (1996). Mind, brain, machine: Language: Journal of the American Academy of Psychoanalysis & Dynamic Psychiatry Vol 24(3) Fal 1996, 409-430.
  • Francuz, P., & Bednarski, P. (1993). Micro-Experimental Laboratory (MEL) language programming in psychological laboratory research: Przeglad Psychologiczny Vol 36(1) 1993, 99-108.
  • Franks, R. D. (1992). Effectiveness of training on algorithms versus notation for indirect addressing comprehension: Dissertation Abstracts International.
  • Fu, F. L. (1994). An empirical investigation of the influence a Chinese language computer interface has on user performance and satisfaction. Dissertation Abstracts International: Section B: The Sciences and Engineering.
  • Fujita, H., Ktari, B., & Mejri, M. (2006). Implementing Lyee-Calculus in Java: Knowledge-Based Systems Vol 19(2) Jun 2006, 116-129.
  • Gaffney, C. R. (1985). Computer languages: Tools for problem-solving? : Dissertation Abstracts International.
  • Gagliardi, M., & Spera, C. (1997). BLOOMS: A prototype modeling language with object oriented features: Decision Support Systems Vol 19(1) Jan 1997, 1-21.
  • Gallo, A., Esposito, R., Meo, R., & Botta, M. (2007). Incremental extraction of association rules in applicative domains: Applied Artificial Intelligence Vol 21(4-5) Apr-May 2007, 297-315.
  • Games, P. A. (1965). Scorit: A FORTRAN program for scoring and item analysis of portapunch test cards: Educational and Psychological Measurement 25(3) 1965, 881-884.
  • Garcia, A. M. F., & Gallinas, R. B. (2007). Business information integration from XML and relational databases sources. Hershey, PA: Idea Group Reference/IGI Global.
  • Garcia, M., Badre, A. N., & Stasko, J. T. (1994). Development and validation of icons varying in their abstractness: Interacting with Computers Vol 6(2) Jun 1994, 191-211.
  • Garon, R. (1988). Introducing adolescents at risk of becoming school dropouts to computers: Apprentissage et Socialisation Vol 11(4) Dec 1988, 221-224.
  • Gegg-Harrison, T. S. (1991). Learning Prolog in a schema-based environment: Instructional Science Vol 20(2-3) 1991, 173-192.
  • Geva, E., & Cohen, R. (1987). Understanding turn commands in LOGO: A cognitive perspective: Instructional Science Vol 16(4) 1987, 337-350.
  • Gilbert, J., Wilson, D.-M., & Gupta, P. (2005). Learning C With Adam: International Journal on E-Learning Vol 4(3) Jul-Sep 2005, 337-350.
  • Gilbert, S. G., & Rice, D. C. (1978). NOVA SKED: A behavioral notation language for Data General minicomputers: Behavior Research Methods & Instrumentation Vol 10(5) Oct 1978, 705-709.
  • Gillespie, C. W., & Beisser, S. (2001). Developmentally appropriate LOGO computer programming with young children: Information Technology in Childhood Education Annual Vol 13 2001, 229-245.
  • Gilmore, D. J. (1991). Models of debugging: Acta Psychologica Vol 78(1-3) Dec 1991, 151-172.
  • Gilmore, D. J., & Green, T. R. (1984). Comprehension and recall of miniature programs: International Journal of Man-Machine Studies Vol 21(1) Jul 1984, 31-48.
  • Gilmore, D. J., & Green, T. R. (1988). Programming plans and programming expertise: The Quarterly Journal of Experimental Psychology A: Human Experimental Psychology Vol 40(3-A) Aug 1988, 423-442.
  • Glass, G. V. (1986). Review of BASIC Meta-Analysis: Procedures and Programs: PsycCRITIQUES Vol 31 (12), Dec, 1986.
  • Goldsamt, M. R. (1974). A FORTRAN program for evaluating the extent of missing data in multivariate observations (program BLANKS): Behavior Research Methods & Instrumentation Vol 6(3) May 1974, 351.
  • Goldstein, L., & Moore, T. (1983). Mechanical deductive techniques: Three microcomputer packages: Behavior Research Methods & Instrumentation Vol 15(5) Oct 1983, 545-546.
  • Goldstein, S. G., & et al. (1966). A 7094 Fortran program for the computation of tetrachoric correlations: Educational and Psychological Measurement 26(1) 1966, 189-191.
  • Gomez, F., & Wingate, V. (1991). TQ: A language for specifying programming problems: International Journal of Man-Machine Studies Vol 35(5) Nov 1991, 633-656.
  • Gong, B. T. (1988). Problem decomposition by computer programmers: Dissertation Abstracts International.
  • Good, J., & Brna, P. (2004). Program comprehension and authentic measurement: A scheme for analysing descriptions of programs: International Journal of Human-Computer Studies Vol 61(2) Aug 2004, 169-185.
  • Good, J., & Oberlander, J. (2002). Verbal effects of visual programs: Information type, structure and error in program summaries: Document Design Vol 3(2) 2002, 121-134.
  • Goodman, D. M. (1983). VT125 graphics hardcopy on an Epson MX-80 serial printer for RT-11 and TSX-Plus: Behavior Research Methods & Instrumentation Vol 15(3) Jun 1983, 374-376.
  • Goodwin, L., & Sanati, M. (1986). Learning computer programming through dynamic representation of computer functioning: Evaluation of a new learning package for Pascal: International Journal of Man-Machine Studies Vol 25(3) Sep 1986, 327-341.
  • Gordon, H. W. (1990). Cognitive asymmetry, computer science students, and professional programmers: Journal of Educational Computing Research Vol 6(2) 1990, 135-146.
  • Goritz, A. S., & Birnbaum, M. H. (2005). Generic HTML Form Processor: A versatile PHP script to save Web-collected data into a MySQL database: Behavior Research Methods Vol 37(4) Nov 2005, 703-710.
  • Gorsuch, R. L. (1966). A Fortran item analysis program for items scored on a categorical or interval basis: Educational and Psychological Measurement 26(1) 1966, 179-183.
  • Gould, J. D. (1975). Some psychological evidence on how people debug computer programs: International Journal of Man-Machine Studies Vol 7(2) Mar 1975, 151-182.
  • Gould, J. D., & Ascher, R. N. (1975). Use of an IQF-like query language by non-programmers. Oxford, England: Ibm.
  • Gould, J. D., Lewis, C., & Becker, C. A. (1976). Writing and following procedural, descriptive, and restricted syntax language instructions. Oxford, England: Ibm.
  • Govier, H. (1985). LOGO--a language for children (and their teachersp): Gifted Education International Vol 3(2) 1985, 109-114.
  • Gow, D. J. (1978). OBLICON: A FORTRAN IV program for oblique confactor rotation: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 429-430.
  • Green, T. R. (1977). Conditional program statements and their comprehensibility to professional programmers: Journal of Occupational Psychology Vol 50(2) Jun 1977, 93-109.
  • Green, T. R., & Guest, D. J. (1974). An easily-implemented language for computer control of complex experiments: International Journal of Man-Machine Studies Vol 6(3) May 1974, 335-359.
  • Green, T. R., & Payne, S. J. (1984). Organization and learnability in computer languages: International Journal of Man-Machine Studies Vol 21(1) Jul 1984, 7-18.
  • Green, T. R., Sime, M. E., & Fitter, M. J. (1980). The problems the programmer faces: Ergonomics Vol 23(9) Sep 1980, 893-907.
  • Greene, S., Ratcliff, R., & McKoon, G. (1988). A flexible programming language for generating stimulus lists for cognitive psychology experiments: Behavior Research Methods, Instruments & Computers Vol 20(2) Apr 1988, 119-128.
  • Gregg, L. W. (1973). APCOL: An example: Behavior Research Methods & Instrumentation Vol 5(2) Mar 1973, 248.
  • Grime, A. R. (1987). Recommendations for teacher-oriented computer authoring languages and systems: Dissertation Abstracts International.
  • Guntermann, E., & Tovar, M. (1987). Collaborative problem-solving with LOGO: Effects of group size and group composition: Journal of Educational Computing Research Vol 3(3) 1987, 313-334.
  • Gurtner, J.-L., Gex, C., Gobet, F., Nunez, R., & et al. (1990). Is recursion making intelligence artificial? : Schweizersche Zeitschrift fur Psychologie/ Revue suisse de psychologie Vol 49(1) 1990, 17-26.
  • Hagendorf, H., & Krause, B. (1987). Problem solving in human-computer systems: Zeitschrift fur Psychologie mit Zeitschrift fur angewandte Psychologie Vol 195(4) 1987, 371-384.
  • Hahn, U., Schacht, S., & Broker, N. (1994). Concurrent, object-oriented natural language parsing: The ParseTalk model: International Journal of Human-Computer Studies Vol 41(1-2) Jul-Aug 1994, 179-222.
  • Hale, D. (1981). Special purpose languages for behavioural experiments: International Journal of Man-Machine Studies Vol 14(3) Apr 1981, 317-339.
  • Halewood, K., & Woodward, M. R. (1993). A uniform graphical view of the program construction process: GRIPSE: International Journal of Man-Machine Studies Vol 38(5) May 1993, 805-837.
  • Hamada, R. M. (1987). The relationship between learning Logo and proficiency in mathematics: Dissertation Abstracts International.
  • Hammond, N. V., Barnard, P. J., Morton, J., Long, J. B., & et al. (1987). Characterizing user performance in command-driven dialogue: Behaviour & Information Technology Vol 6(2) Apr-Jun 1987, 159-205.
  • Hannan, T. E. (1986). CBASIC programs for nonparametric statistical analysis: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 403-404.
  • Hannum, W. (1986). Techniques for creating computer-based instructional text: Programming languages, authoring languages, and authoring systems: Educational Psychologist Vol 21(4) Fal 1986, 293-314.
  • Hanson, S. J. (1978). Confidence intervals for nonlinear regression: A BASIC program: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 437-441.
  • Harris, G. J., Gavurin, E. I., & Gordon, M. L. (1978). A FORTRAN IV program for generating anagrams and for computing several indices in anagram research: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 431-432.
  • Harris, G. S., Swanson, J. M., & Duerr, J. L. (1974). OMNI-SHRIMP: An interpretive language which mimics OMNITAB: Behavior Research Methods & Instrumentation Vol 6(2) Mar 1974, 200-204.
  • Harvey, L., & Anderson, J. (1996). Transfer of declarative knowledge in complex information-processing domains: Human-Computer Interaction Vol 11(1) 1996, 69-96.
  • Hatcher, M. E., Oakes, T. W., & Kaiser, E. (1976). Information retrieval: Program for personalized article retrieval system: Behavior Research Methods & Instrumentation Vol 8(6) Dec 1976, 514.
  • Hauptmann, A. G., & Green, B. F. (1983). A comparison of command, menu-selection and natural-language computer programs: Behaviour & Information Technology Vol 2(2) Apr-Jun 1983, 163-178.
  • Haussmann, R. E. (1992). Tachistoscopic presentation and millisecond timing on the IBM PC/XT/AT and PS/2: A Turbo Pascal unit to provide general-purpose routines for CGA, Hercules, EGA, and VGA monitors: Behavior Research Methods, Instruments & Computers Vol 24(2) May 1992, 303-310.
  • Hays, J. E. (1976). A FORTRAN procedure for plotting two-dimensional barycentric simplicia: Behavior Research Methods & Instrumentation Vol 8(6) Dec 1976, 515-516.
  • Heil, G. H., & White, H. C. (1976). An algorithm for finding simultaneous homomorphic correspondences between graphs and their image graphs: Behavioral Science Vol 21(1) Jan 1976, 26-35.
  • Heller, R. S. (1987). The effect of MECC and Papert teaching styles on the level of Logo learning and the conceptual tempo of fourth grade students: Dissertation Abstracts International.
  • Heller, R. S. (1991). Toward a student workstation: Extensions to the LOGO environment: Journal of Educational Computing Research Vol 7(1) 1991, 77-88.
  • Hendry, D. P., & Lennon, W. J. (1973). A FORTRAN-based control and data-analysis system for behavioral experiments. East Norwalk, CT: Appleton-Century-Crofts.
  • Henry, R. D., & Howard, J. A. (1977). SAL: A simple author language for a minicomputer assisted instruction system: Journal of Computer-Based Instruction Vol 3(4) May 1977, 107-114.
  • Herbsleb, J. D., Klein, H., Olson, G. M., Brunner, H., & et al. (1995). Object-oriented analysis and design in software project teams: Human-Computer Interaction Vol 10(2-3) 1995, 249-292.
  • Herman, T. G. (1987). Teaching the Logo computer language: A motivational perspective: Dissertation Abstracts International.
  • Hiraishi, K. (1995). A constraint logic programming language keyed CLP and its applications to decision making problems in OR/MS: Decision Support Systems Vol 14(3) Jul 1995, 269-281.
  • Hirsh-Pasek, K., Nudelman, S., & Schneider, M. L. (1982). An experimental evaluation of abbreviation schemes in limited lexicons: Behaviour & Information Technology Vol 1(4) Oct-Dec 1982, 359-369.
  • Hittner, J. B., Finger, M. S., Mancuso, J. P., & Silver, N. C. (1995). A Microsoft FORTRAN 77 program for contrasting part correlations and related statistics: Educational and Psychological Measurement Vol 55(5) Oct 1995, 777-784.
  • Ho, T.-p. (1984). The Dialogue Designing Dialogue System: Dissertation Abstracts International.
  • Hoc, J.-M. (1987). Learning the use of computerized devices by analogy with familiar situations: Psychologie Francaise Vol 32(4) Dec 1987, 217-226.
  • Hoc, J. M. (1977). Role of mental representation in learning a programming language: International Journal of Man-Machine Studies Vol 9(1) Jan 1977, 87-105.
  • Hoc, J. M. (1988). Planning aids in program design: Le Travail Humain Vol 51(4) Dec 1988, 321-333.
  • Hoc, J. M., & Visser, W. (1988). Introduction: Cognitive approach to computer programming: Le Travail Humain Vol 51(4) Dec 1988, 289-296.
  • Holtgraves, T. M., Ross, S. J., Weywadt, C. R., & Han, T. L. (2007). Perceiving artificial social agents: Computers in Human Behavior Vol 23(5) Sep 2007, 2163-2174.
  • Honarvar, H. (1992). Sequencing as a factor associated with students' ability to learn programming: Dissertation Abstracts International.
  • Hooper, E. J. (1987). Using programming protocols to investigate the effects of manipulative computer models on student learning: Dissertation Abstracts International.
  • Hooper, R. W. (1986). The Tennessee computer literacy pilot project: A descriptive and evaluative study: Dissertation Abstracts International.
  • Horner, C. M. (1984). The effects of Logo on problem solving, locus of control, attitudes toward mathematics, and angle recognition in learning disabled children: Dissertation Abstracts International.
  • Howard, J. (1976). Microprogramming in psychology: Behavior Research Methods & Instrumentation Vol 8(2) Apr 1976, 118-122.
  • Howat, G. M. (1965). Variables affecting the graduate assistant in a computer training position: Educational and Psychological Measurement 25(3) 1965, 887-892.
  • Howell, R. D., Scott, P. B., & Diamond, J. (1987). The effects of "instant" Logo computing language on the cognitive development of very young children: Journal of Educational Computing Research Vol 3(2) 1987, 249-260.
  • Howes, A., & Young, R. M. (1996). Learning consistent, interactive, and meaningful task-action mappings: A computational model: Cognitive Science: A Multidisciplinary Journal Vol 20(3) Jul-Sep 1996, 301-356.
  • Hoyles, C. (1995). "An investigation of Year 7 pupils learning CONTROL LOGO": Comment: Journal of Computer Assisted Learning Vol 11(3) Sep 1995, 192.
  • Hsu, J. (2000). The learning and use of markup languages: An experimental investigation of the impacts of user interface, help system, and user background on learning a markup language. Dissertation Abstracts International: Section B: The Sciences and Engineering.
  • Hubert, L. J., Arabie, P., & Meulman, J. J. (2002). Linear unidimensional scaling in the L-sub-2-norm: Basic optimization methods using MATLAB: Journal of Classification Vol 19(2) 2002, 303-328.
  • Huenerfauth, M. (2006). Representing coordination and non-coordination in American Sign Language animations: Behaviour & Information Technology Vol 25(4) Jul-Aug 2006, 285-295.
  • Hughes, M., & Greenhough, P. (1995). Feedback, adult intervention, and peer collaboration in initial logo learning: Cognition and Instruction Vol 13(4) 1995, 525-539.
  • Hunt, E. (1969). A Statistics Gatherer's Primer in Computing: PsycCRITIQUES Vol 14 (9), Sep, 1969.
  • Husic, F. T., Linn, M. C., & Sloane, K. D. (1989). Adapting instruction to the cognitive demands of learning to program: Journal of Educational Psychology Vol 81(4) Dec 1989, 570-583.
  • Hwang, Y.-f. (1990). The effectiveness of computer simulation in training programmers for computer numerical control machining: Dissertation Abstracts International.
  • Ignatuk, N. (1986). An analysis of the effects of computer programming on analytical and mathematical skills of high school students: Dissertation Abstracts International.
  • Inder, R. (2000). CAPE: Extending CLIPS for the internet: Knowledge-Based Systems Vol 13(2-3) Apr 2000, 151-157.
  • Isa, B. S., Evey, R. J., McVey, B. W., & Neal, A. S. (1985). An empirical comparison of two metalanguages: International Journal of Man-Machine Studies Vol 23(3) Sep 1985, 215-229.
  • Iselin, E. R. (1988). Conditional statements, looping constructs, and program comprehension: An experimental study: International Journal of Man-Machine Studies Vol 28(1) Jan 1988, 45-66.
  • Jain, S. K. (1996). The effects of individual cognitive learning styles and troubleshooting experience on the development of mental models in teaching a database query language to novices. Dissertation Abstracts International Section A: Humanities and Social Sciences.
  • Jankowicz, A. Z. (1986). Local Irish norms for the Computer Programmer Aptitude Battery: Irish Journal of Psychology Vol 7(2) Fal 1986, 115-122.
  • Jaspen, N. (1965). The calculation of probabilities corresponding to values of z, t, F, and chi-square: Educational and Psychological Measurement 25(3) 1965, 877-880.
  • Jaspen, N. (1965). Polyserial correlations programs in FORTRAN: Educational and Psychological Measurement 25(1) 1965, 229-233.
  • Jehng, J. C. J., Tung, S. H. S., & Chang, C. T. (1999). A visualisation approach to learning the concept of recursion: Journal of Computer Assisted Learning Vol 15(4) Dec 1999, 279-290.
  • Jeusfeld, M. A., & Bui, T. X. (1997). Distributed decision support and organizational connectivity: A case study: Decision Support Systems Vol 19(3) Mar 1997, 215-225.
  • Jih, W. K., Bradbard, D. A., Snyder, C. A., & Thompson, N. G. (1989). The effects of relational and entity-relationship data models on query performance of end users: International Journal of Man-Machine Studies Vol 31(3) Sep 1989, 257-267.
  • Jo, M. L. (1991). Metacognitive and cognitive effects of different loci of instructional control in computer-assisted LOGO instruction: Dissertation Abstracts International.
  • Johnston, J. E., Berry, K. J., & Mielke, P. W., Jr. (2007). Resampling permutation probability values for six measures of qualitative variation: Perceptual and Motor Skills Vol 104(3, Pt 1) Jun 2007, 773-776.
  • Jonker, C. M., Treur, J., & Wijngaards, W. C. A. (2002). Reductionist and anti-reductionist perspectives on dynamics: Philosophical Psychology Vol 15(4) Dec 2002, 381-409.
  • Juttner, M., & Strasburger, H. (1997). FORPXL: A Fortran interface to PXL, the Psychological Experiments Library: Spatial Vision Vol 10(4) 1997, 491-493.
  • Kadden, R. M. (1974). State notation and SKED: A general system for control and recording of behavioral experiments: Behavior Research Methods & Instrumentation Vol 6(2) Mar 1974, 167-170.
  • Kagan, D. M., & Douthat, J. M. (1985). Personality and learning FORTRAN: International Journal of Man-Machine Studies Vol 22(4) Apr 1985, 395-402.
  • Kagan, D. M., & Esquerra, R. L. (1984). Personality and learning BASIC: Journal of Instructional Psychology Vol 11(1) Mar 1984, 10-16.
  • Kahan, J. P., & et al. (1976). A PDP-11/45 program for playing n-person characteristic function games: Behavior Research Methods & Instrumentation Vol 8(2) Apr 1976, 165-169.
  • Kahn, K. M. (1984). A prototype grammar kit in PROLOG: Instructional Science Vol 13(1) May 1984, 37-45.
  • Kang, J., & Lee, J. K. (2005). Rule identification from Web pages by the XRML approach: Decision Support Systems Vol 41(1) Nov 2005, 205-227.
  • Kaplan, H. L. (1977). Clock-driven FORTRAN task scheduling in a multiprogramming environment: Behavior Research Methods & Instrumentation Vol 9(2) Apr 1977, 176-183.
  • Kaplan, H. L. (1985). Design decisions in a Pascal-based operant conditioning system: Behavior Research Methods, Instruments & Computers Vol 17(2) Apr 1985, 307-318.
  • Kaplan, H. L. (1985). When do professional psychologists need professional programmers' tools? : Behavior Research Methods, Instruments & Computers Vol 17(5) Oct 1985, 546-550.
  • Katz, I. R. (1989). Transfer of knowledge in programming: Dissertation Abstracts International.
  • Katzeff, C. (1986). Dealing with a database query language in a new situation: International Journal of Man-Machine Studies Vol 25(1) Jul 1986, 1-17.
  • Katzeff, C. (1988). The effect of different conceptual models upon reasoning in a database query writing task: International Journal of Man-Machine Studies Vol 29(1) Jul 1988, 37-62.
  • Kawash, J. (2004). Complex Quantification in Structured Query Language (SQL): A Tutorial Using Relational Calculus: Journal of Computers in Mathematics and Science Teaching Vol 23(2) 2004, 169-190.
  • Kelley, J. F. (1983). Natural language and computers: Six empirical steps for writing an easy-to-use computer application: Dissertation Abstracts International.
  • Kelley, K. (2007). Methods for the Behavioral, Educational, and Social Sciences: An R package: Behavior Research Methods Vol 39(4) Nov 2007, 979-984.
  • Kessler, C. M. (1989). Transfer of programming skills in novice LISP learners: Dissertation Abstracts International.
  • Ketler, K. J. (1990). Transition from third to fourth generation languages: A human factor analysis of programmers: Dissertation Abstracts International.
  • Khalil, O. E. (1986). An empirical investigation of the impact of cognitive complexity and experience of programmers, and program complexity on program comprehension and modification: Dissertation Abstracts International.
  • Khayrallah, M. A., & Van den Meiraker, M. (1987). LOGO programming and the acquisition of cognitive skills: Journal of Computer-Based Instruction Vol 14(4) Fal 1987, 133-137.
  • Khazaei, B. (1992). The determinants of program designer behaviour: An empirical study: Dissertation Abstracts International.
  • Kieras, D. (1973). A general experiment programming system for the IBM 1800: Behavior Research Methods & Instrumentation Vol 5(2) Mar 1973, 235-239.
  • Kieren, T. E. (1989). Observation and recursion in LOGO mathematics: A response to Vitale: New Ideas in Psychology Vol 7(3) 1989, 277-281.
  • Kingma, J., & Taerum, T. (1988). A FORTRAN 77 program for a nonparametric item response model: The Mokken scale analysis: Behavior Research Methods, Instruments & Computers Vol 20(5) Oct 1988, 471-480.
  • Kirkland, C. E. (1986). Effects of manipulating program function keys, readability of instructions, and illustrations in learning to use text editing software: Dissertation Abstracts International.
  • Kiser, S. S. (1991). Logo programming, metacognitive skills in mathematical problem-solving, and mathematics achievement: Dissertation Abstracts International.
  • Klerer, M. (1984). Experimental study of a two-dimensional language vs Fortran for first-course programmers: International Journal of Man-Machine Studies Vol 20(5) May 1984, 445-467.
  • Knoblauch, K. (1986). TVR: A BASIC implementation of Stiles's analysis of the two-color increment-threshold paradigm: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 393-394.
  • Koman, J. J. (1988). An evolutionary history of the natural language English and the artificial language FORTRAN: Psychology: A Journal of Human Behavior Vol 25(2) 1988, 14-22.
  • Korn, P., & Walker, W. (2001). Accessibility in the Java-super(TM ) platform. Mahwah, NJ: Lawrence Erlbaum Associates Publishers.
  • Krasnor, L. R., & Mitterer, J. O. (1984). Logo and the development of general problem-solving skills: Alberta Journal of Educational Research Vol 30(2) Jun 1984, 133-144.
  • Krasucki, P. J. (1989). Knowledge, consensus and communication: Dissertation Abstracts International.
  • Krems, J., & Pfeiffer, T. (1992). Understanding and recognition of short sequences of commands: Advantages of pattern or of more efficient domain-specific skills: Zeitschrift fur Psychologie mit Zeitschrift fur angewandte Psychologie Vol 200(1) 1992, 45-60.
  • Krus, D. J., & Lu, M.-y. (1987). Bias in computer languages comparisons: A FORTRAN phobic cabal? : Educational and Psychological Measurement Vol 47(3) Fal 1987, 643-647.
  • Kull, J. A. (1988). Children learning Logo: A collaborative, qualitative study in first grade: Journal of Research in Childhood Education Vol 3(1) Spr-Sum 1988, 55-75.
  • Kurland, D. M., Pea, R. D., Clement, C. A., & Mawby, R. (1986). A study of the development of programming ability and thinking skills in high school students: Journal of Educational Computing Research Vol 2(4) 1986, 429-458.
  • Lambert, K. (2001). From predication to programming: Minds and Machines Vol 11(2) May 2001, 257-265.
  • Lanza, A., & Roselli, T. (1991). Effects of the hypertextual approach versus the structured approach on students' achievement: Journal of Computer-Based Instruction Vol 18(2) Spr 1991, 48-50.
  • Lapouchnian, A., & Lesperance, Y. (2002). Interfacing INDIGOLOG and OAA: A toolkit for advanced multiagent applications: Applied Artificial Intelligence Vol 16(9-10) Oct-Dec 2002, 813-829.
  • Larson, J. R., Jr. (1997). Modeling the entry of shared and unshared information into group discussion: A review and BASIC language computer program: Small Group Research Vol 28(3) Aug 1997, 454-479.
  • Lasoff, E. M. (1981). The effects of feedback in both computer-assisted and programmed instruction on achievement and attitude: Dissertation Abstracts International.
  • Laverty, J. P. (1994). The interaction of computer program debugging tools, field dependence, and computer programming languages in higher education computer language courses. Dissertation Abstracts International Section A: Humanities and Social Sciences.
  • Ledesma, R., Molina, J. G., & Young, F. W. (2005). Enhancing dynamic graphical analysis wlth the Lisp-Stat language and the ViSta statistical program: Behavior Research Methods Vol 37(4) Nov 2005, 684-690.
  • Lee, T. W. (1986). The effects of library-based computer assisted instruction on student programming performance and an implementation of the Grading Support System in Fortran language courses at the university: Dissertation Abstracts International.
  • Legewie, H., Dirlich, G., & Gerster, F. (1975). Computer software: An application language for psychophysiological experimentation: Psychophysiology Vol 12(6) Nov 1975, 713-716.
  • Lehman, R. S. (1986). Programming for the social sciences: Algorithms and Fortran77 coding. Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Lehman, R. S. (1988). The languages we use: Behavior Research Methods, Instruments & Computers Vol 20(2) Apr 1988, 236-242.
  • Lehrer, R. (1986). Logo as a strategy for developing thinking? : Educational Psychologist Vol 21(1-2) Win-Spr 1986, 121-137.
  • Lehrer, R., & DeBernard, A. (1987). Language of learning and language of computing: The perceptual-language model: Journal of Educational Psychology Vol 79(1) Mar 1987, 41-48.
  • Lehrer, R., Guckenberg, T., & Lee, O. (1988). Comparative study of the cognitive consequences of inquiry-based Logo instruction: Journal of Educational Psychology Vol 80(4) Dec 1988, 543-553.
  • Lehrer, R., Lee, M., & Jeong, A. (1999). Reflective teaching of logo: Journal of the Learning Sciences Vol 8(2) 1999, 245-289.
  • Lehrer, R., & Littlefield, J. (1993). Relationships among cognitive components in Logo learning and transfer: Journal of Educational Psychology Vol 85(2) Jun 1993, 317-330.
  • Leitman, S. I. (1986). Effects of computer programming on mathematics problem solving with ninth-grade students using a unit on flowcharting: Dissertation Abstracts International.
  • Lelouche, R., & Dion, P. (1988). A multi-expert system to teach structured programming. New York, NY ; Ashurst Hants, England: Elsevier Science; Computational Mechanics Publications.
  • Lemoyne, G., Van Grunderbeeck, N., & Bolduc, J. (1985). Interaction between the "teaching" computer and the student in several teaching situations: Enfance No 2-3 1985, 133-146.
  • Leonard, M. (1991). Learning the structure of recursive programs in Boxer: The Journal of Mathematical Behavior Vol 10(1) Apr 1991, 17-53.
  • Leslie, J. C. (1981). State notation programming languages in psychology: International Journal of Man-Machine Studies Vol 14(3) Apr 1981, 341-354.
  • Leso, T., & Peck, K. L. (1992). Computer anxiety and different types of computer courses: Journal of Educational Computing Research Vol 8(4) 1992, 469-478.
  • Levonian, E. (1964). A fortran program for test analysis: Educational and Psychological Measurement 24(3) 1964, 655-657.
  • Lewis, M. F., & Elsmore, T. F. (1973). Revision of SKED: Needs and desires: Behavior Research Methods & Instrumentation Vol 5(2) Mar 1973, 178-179.
  • Lewit, A. F. (1985). An investigation of the common difficulties students encounter programming in BASIC: Dissertation Abstracts International.
  • Lhermenier-Marinho, I., & Chiva, M. (1985). The practice of LOGO, cognitive processes, cognitive styles: Enfance No 2-3 1985, 159-163.
  • Li, S.-C., & Frensch, P. A. (2004). Revisiting Symbolic Approaches to Cognition in a New Visual Programming Environment: PsycCRITIQUES Vol 49 (4), Aug, 2004.
  • Liao, S. Y., Wang, H. Q., & Liao, L. J. (2002). An extended formalism to constraint logic programming for decision analysis: Knowledge-Based Systems Vol 15(3) Mar 2002, 189-202.
  • Liao, Y.-k. C., & Bright, G. W. (1991). Effects of computer programming on cognitive outcomes: A meta-analysis: Journal of Educational Computing Research Vol 7(3) 1991, 251-268.
  • Lieberman, H. (1987). An example-based environment for beginning programmers. Westport, CT: Ablex Publishing.
  • Lin, T., & Goldstein, J. L. (1997). Implementation of the MBPNL nonlinear cochlear I/O model in the C programming language, and applications for modeling impaired auditory function. Mahwah, NJ: Lawrence Erlbaum Associates Publishers.
  • Linn, M. C., & Clancy, M. J. (1992). Can experts' explanations help students develop program design skills? : International Journal of Man-Machine Studies Vol 36(4) Apr 1992, 511-551.
  • Linn, M. C., & Dalbey, J. (1985). Cognitive consequences of programming instruction: Instruction, access, and ability: Educational Psychologist Vol 20(4) Fal 1985, 191-206.
  • Linn, M. C., Sloane, K. D., & Clancy, M. J. (1987). Ideal and actual outcomes from precollege Pascal instruction: Journal of Research in Science Teaching Vol 24(5) May 1987, 467-490.
  • Littlefield, J., Delclos, V. R., Bransford, J. D., Clayton, K. N., & et al. (1989). Some prerequisites for teaching thinking: Methodological issues in the study of LOGO programming: Cognition and Instruction Vol 6(4) 1989, 331-366.
  • Loehlin, J. C. (1967). Review of Basic FORTRAN for Statistical Analysis: PsycCRITIQUES Vol 12 (9), Sep, 1967.
  • Loftin, R. D. (1987). The evaluation of selected variables as predictors of achievement in computer programming: Dissertation Abstracts International.
  • Lopez Sanchez, R. (1994). FRA3: A Pascal application for reading-comprehension research: Psicothema Vol 6(1) Mar 1994, 105-118.
  • Lorig, T. S., & Urbach, T. P. (1995). Event-related potential analysis using Mathematica: Behavior Research Methods, Instruments & Computers Vol 27(3) Aug 1995, 358-366.
  • Lower, S. K. (1977). Maxi authoring languages in the era of the mini: Journal of Computer-Based Instruction Vol 3(4) May 1977, 115-122.
  • Lunt, P. K., & Tiller, D. K. (1986). INTRACLUS: A FORTRAN 77 program for elucidating intracluster structure: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 398.
  • Ma, Q. (2007). From monitoring users to controlling user actions: A new perspective on the user-centred approach to CALL: Computer Assisted Language Learning Vol 20(4) Oct 2007, 297-321.
  • MacDonald, R. N. (1974). A two-dimensional programming language for data acquisition and control: Behavior Research Methods & Instrumentation Vol 6(2) Mar 1974, 274-280.
  • Machanick, P. (2007). Teaching Java backwards: Computers & Education Vol 48(3) Apr 2007, 396-408.
  • MacIntosh, R. (1997). A program implementing Mardia's multivariate normality test for use in structural equation modeling with latent variables: Educational and Psychological Measurement Vol 57(2) Apr 1997, 357-359.
  • Mackenzie, A. (2006). JavaTM: The practical virtuality of internet programming: New Media & Society Vol 8(3) Jun 2006, 441-465.
  • Maddux, C. D., & Johnson, D. L. (1984). LOGO: Putting the child in charge: Academic Therapy Vol 20(1) Sep 1984, 93-99.
  • Maffei, A. C. (1986). Classroom computers: A practical guide for effective teaching. New York, NY: Human Sciences Press.
  • Mahling, D. E. (1990). A visual language for knowledge acquisition, display and animation by domain experts and novices: Dissertation Abstracts International.
  • Malcolm, D. S. (1989). A BASIC program for exploratory data analysis: Behavior Research Methods, Instruments & Computers Vol 21(4) Aug 1989, 463-464.
  • Manaris, B. Z., & Dominick, W. D. (1993). NALIGE: A user interface management system for the development of natural language interfaces: International Journal of Man-Machine Studies Vol 38(6) Jun 1993, 891-921.
  • Mandinach, E. B., & Linn, M. C. (1987). Cognitive consequences of programming: Achievements of experienced and talented programmers: Journal of Educational Computing Research Vol 3(1) 1987, 53-72.
  • Mange, A. P. (1964). Fortran programs for computing Wright's coefficient of inbreeding in human and non-human pedigrees: American Journal of Human Genetics 16(4) 1964, 484.
  • Mann, R. J. (1986). The effects of LOGO computer programming on problem solving abilities of eighth grade students: Dissertation Abstracts International.
  • Many, W. A., Lockard, J., Abrams, P. D., & Friker, W. (1988). The effect of learning to program in Logo on reasoning skills of junior high school students: Journal of Educational Computing Research Vol 4(2) 1988, 203-213.
  • Marco, R. (1991). Instruction in programming languages and knowledge structures: Revista de Psicologia Vol 13(1) 1991, 87-103.
  • Martin, N. J. (1990). The effects of computer programming on students problem-solving skills: Dissertation Abstracts International.
  • Martin, S. A., & Toothaker, L. E. (1989). PERITZ: A FORTRAN program for performing multiple comparisons of means using the Peritz Q method: Behavior Research Methods, Instruments & Computers Vol 21(4) Aug 1989, 465-472.
  • Masin, S. C. (1988). PSESE: A program for computations regarding the constant stimuli method: Giornale Italiano di Psicologia Vol 15(3) Sep 1988, 517-518.
  • Mathinos, D. A. (1990). LOGO programming and the refinement of problem-solving skills in disabled and nondisabled children: Journal of Educational Computing Research Vol 6(4) 1990, 429-446.
  • Matsushita, M., Maeda, E., & Kato, T. (2004). An interactive visualization method of numerical data based on natural language requirements: International Journal of Human-Computer Studies Vol 60(4) Apr 2004, 469-488.
  • Mawby, R. (1985). The importance of research for Logo: American Annals of the Deaf Vol 130(5) Nov 1985, 470-478.
  • Mayer, L. S., & Pichotta, P. J. (1974). A FORTRAN program for linear log odds analysis: Behavior Research Methods & Instrumentation Vol 6(3) May 1974, 351.
  • Mayer, R. E. (1975). Different problem-solving competencies established in learning computer programming with and without meaningful models: Journal of Educational Psychology Vol 67(6) Dec 1975, 725-734.
  • Mayer, R. E. (1976). Comprehension as affected by structure of problem representation: Memory & Cognition Vol 4(3) May 1976, 249-255.
  • Mayer, R. E. (1976). Some conditions of meaningful learning for computer programming: Advance organizers and subject control of frame order: Journal of Educational Psychology Vol 68(2) Apr 1976, 143-150.
  • Mayer, R. E. (1978). Advance organizers that compensate for the organization of text: Journal of Educational Psychology Vol 70(6) Dec 1978, 880-886.
  • Mayer, R. E. (1986). Making Computer Systems for People: A Role for Psychologists: PsycCRITIQUES Vol 31 (1), Jan, 1986.
  • Mayer, R. E. (1987). Cognitive aspects of learning and using a programming language. Cambridge, MA: The MIT Press.
  • Mayer, R. E., Bayman, P., & Dyck, J. L. (1987). Learning programming languages: Research and applications. Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Mayer, R. E., & Fay, A. L. (1987). A chain of cognitive changes with learning to program in Logo: Journal of Educational Psychology Vol 79(3) Sep 1987, 269-279.
  • Mays, R. (1978). Correlation coefficients corrected for missing data: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 420.
  • Mbarki, M., Mejri, M., & Ktari, B. (2006). Converting an imperative program to a declarative one: Knowledge-Based Systems Vol 19(2) Jun 2006, 130-140.
  • McCormick, D., & Ross, S. M. (1990). Effects of computer access and flowcharting on students' attitudes and performance in learning computer programming: Journal of Educational Computing Research Vol 6(2) 1990, 203-213.
  • McCormick, D. L. (1987). Effects of computer access and flowcharting on students' attitudes and performance in learning computer programming: Dissertation Abstracts International.
  • McGlone, J. J., Miller, E. A., & Hayden, S. L. (1985). A description of micro- and mainframe-computer programs to summarize frequency, duration and sequences of behavior: Applied Animal Behaviour Science Vol 13(3) Jan 1985, 219-226.
  • McGowan, W. T. (1978). EMATS: An interactive computer program (APL) for generating ANOVA model equations and error terms: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 442-450.
  • McGrath, D. (1988). Programming and problem solving: Will two languages do it? : Journal of Educational Computing Research Vol 4(4) 1988, 467-484.
  • McIntosh, P. G. (2000). Knowledge acquisition using VRML and the unified modelling language: The case of the RGB computer room: Knowledge-Based Systems Vol 13(1) Feb 2000, 21-26.
  • McKendree, J., & Anderson, J. R. (1987). Effect of practice on knowledge and use of basic Lisp. Cambridge, MA: The MIT Press.
  • McKenzie, J. C. (1986). Occupational and educational interests of adults in basic computer courses: Dissertation Abstracts International.
  • McKinley, R. L., & Reckase, M. D. (1983). MAXLOG: A computer program for the estimation of the parameters of a multidimensional logistic model: Behavior Research Methods & Instrumentation Vol 15(3) Jun 1983, 389-390.
  • McLean, R. S. (1973). A PSYCHOL example: Behavior Research Methods & Instrumentation Vol 5(2) Mar 1973, 240-241.
  • McLeod, D., & McLeod, S. (1994). Empowering language-impaired children through Logo: Child Language Teaching & Therapy Vol 10(1) Feb 1994, 107-114.
  • McNemar, Q. (1969). Review of Introduction to Statistical Procedures: With Computer Exercises: PsycCRITIQUES Vol 14 (5), May, 1969.
  • Mendelsohn, P. (1985). The psychological analysis of programming activities in the CM-1 and CM-2 child: Enfance No 2-3 1985, 213-221.
  • Merbler, J. B. (1990). Teachers and artificial intelligence: The Logo connection: American Annals of the Deaf Vol 135(5) Dec 1990, 379-383.
  • Meredith, M. E. (1987). Seek-Whence: A model of pattern perception: Dissertation Abstracts International.
  • Mevarech, Z. R., & Kramarski, B. (1993). Vygotsky and Papert: Social-cognitive interactions within Logo environments: British Journal of Educational Psychology Vol 63(1) Feb 1993, 96-109.
  • Meyer, J. A. (1974). CONSTEL: A FORTRAN IV program for factor and cluster analysis of mixed data: Behavior Research Methods & Instrumentation Vol 6(5) Sep 1974, 506.
  • Meyer, R. G. (1969). Language requirement and the computer: American Psychologist Vol 24(7) Jul 1969, 682-683.
  • Miclea, M., & Radu, I. (1988). The use of formal languages of psychology: Revue Roumaine des Sciences Sociales - Serie de Psychologie Vol 32(2) Jul-Dec 1988, 119-128.
  • Mielke, P. W., Jr., & Berry, K. J. (1996). Exact probabilities for first-order and second-order interactions in 2*2*2 contingency tables: Educational and Psychological Measurement Vol 56(5) Oct 1996, 843-847.
  • Mielke, P. W., Jr., Berry, K. J., & Johnston, J. E. (2005). A FORTRAN program for computing the exact variance of weighted kappa: Perceptual and Motor Skills Vol 101(2) Oct 2005, 468-472.
  • Mient, L. E. (1989). A validation of selected logical and infralogical operations in adults using LOGO as an interactive computer language: Dissertation Abstracts International.
  • Mihalca, R., Uta, A., Andreescu, A., Intorsureanu, I., & Kovacs, S. (2007). Overview of tutorial systems based on information technology: Communication & Cognition Vol 40(1-2) 2007, 25-36.
  • Millenson, J. R. (1973). On-line sequential control of experiments by an automated contingency translator. East Norwalk, CT: Appleton-Century-Crofts.
  • Miller, R. B., Kelly, G. N., & Kelly, J. T. (1988). Effects of Logo computer programming experience on problem solving and spatial relations ability: Contemporary Educational Psychology Vol 13(4) Oct 1988, 348-357.
  • Milojkovic, J. D. (1984). Children learning computer programming: Cognitive and motivational consequences: Dissertation Abstracts International.
  • Mitchell, M. (1984). The effects of learning the Logo computer language on the mathematical achievement and attitudes of preservice elementary teachers: Dissertation Abstracts International.
  • Mohamed, M. A. (1986). The effects of learning LOGO computer language upon the higher cognitive processes and the analytic/global cognitive styles of elementary school students: Dissertation Abstracts International.
  • Montessoro, P. L., Pierattoni, D., & Cicuttini, R. (2003). MTeach: A Simple Production Framework for Context-Based Educational Hypermedia: Journal of Educational Multimedia and Hypermedia Vol 12(4) 2003, 335-359.
  • Morey, J. (2006). Programming in Polygon R&D: Explorations with a spatial language II: International Journal of Computers for Mathematical Learning Vol 11(2) Oct 2006, 147-175.
  • Morey, J. (2007). "Programming in Polygon R&D: Explorations with a spatial language": Erratum: International Journal of Computers for Mathematical Learning Vol 12(1) Apr 2007, 85.
  • Mosca, P. R., & Fagundes, L. D. (1986). Children's conceptualizations when programming in Logo: The construction and composition of modules of mental images and programming: Arquivos Brasileiros de Psicologia Vol 38(3) Jul-Sep 1986, 58-70.
  • Mosemann, R. J. (2000). Navigation and comprehension of procedural language programs. Dissertation Abstracts International: Section B: The Sciences and Engineering.
  • Mullen, B. (1983). A BASIC program for metaanalysis of effect sizes using r, BESD, and d: Behavior Research Methods & Instrumentation Vol 15(3) Jun 1983, 392-393.
  • Mullen, S. (1976). FOCLAB: A language for computer-controlled psychology research: Behavior Research Methods & Instrumentation Vol 8(2) Apr 1976, 229-232.
  • Murphy, S. C. (1985). Adult processing characteristics when using the logo computer programming language: Dissertation Abstracts International.
  • Navarro-Prieto, R., & Canas, J. J. (2001). Are visual programming languages better? The role of imagery in program comprehension: International Journal of Human-Computer Studies Vol 54(6) Jun 2001, 799-829.
  • Neber, H. (1993). Acquisition of computer-programming knowledge: Exploratory vs problem-oriented learning: Zeitschrift fur Entwicklungspsychologie und Padagogische Psychologie Vol 25(3) 1993, 206-224.
  • Nichol, J. (1991). Knowledge-based tools, children, and the curriculum. Westport, CT: Ablex Publishing.
  • Nichol, J., Dean, J., & Briggs, J. (1987). Computers and cognition in the classroom. Oxford, England: John Wiley & Sons.
  • Nichols, L. M. (1992). The influence of student computer-ownership and in-home use on achievement in an elementary school computer programming curriculum: Journal of Educational Computing Research Vol 8(4) 1992, 407-421.
  • Nichols, R. C., & Tetzlaff, W. (1965). Test scoring and item analysis programs: Educational and Psychological Measurement 25(1) 1965, 205-210.
  • No authorship, i. (1989). Review of Computer-Assisted Psychological Evaluations: How To Create Testing Programs in BASIC: PsycCRITIQUES Vol 34 (11), Nov, 1989.
  • Nogueira, I. (1987). LOGO: Cognition and personality: Arquivos Brasileiros de Psicologia Vol 39(4) Oct-Dec 1987, 71-75.
  • Noot, H., & Ruttkay, Z. (2005). Variations in gesturing and speech by GESTYLE: International Journal of Human-Computer Studies Vol 62(2) Feb 2005, 211-229.
  • Noss, R. (1987). How do children do mathematics with LOGO? : Journal of Computer Assisted Learning Vol 3(1) Mar 1987, 2-12.
  • Oberweis, A. (1996). An integrated approach for the specification of processes and related complex structured objects in business applications: Decision Support Systems Vol 17(1) Apr 1996, 31-53.
  • Olivers, C. N. L., & Watson, D. G. (1999). On the efficiency of drawing computer-generated line stimuli: Rectangles can be faster than lines: Behavior Research Methods, Instruments & Computers Vol 31(3) Aug 1999, 416-422.
  • Olson, D. M. (1987). The validity of programming ability tests used in the introductory computer science course: Dissertation Abstracts International.
  • Olson, J. K. (1986). Using Logo to supplement the teaching of geometric concepts in the elementary school classroom: Dissertation Abstracts International.
  • Oprea, J. M. (1988). Computer programming and mathematical thinking: The Journal of Mathematical Behavior Vol 7(2) Aug 1988, 175-190.
  • Ormerod, T. C., Manktelow, K. I., Robson, E. H., & Steward, A. P. (1986). Content and representation effects with reasoning tasks in PROLOG form: Behaviour & Information Technology Vol 5(2) Apr-Jun 1986, 157-168.
  • Orr, J. L. (1984). Going FORTH in the laboratory: Behavior Research Methods, Instruments & Computers Vol 16(2) Apr 1984, 193-198.
  • Ortiz, E., & MacGregor, S. K. (1991). Effects of LOGO programming on understanding variables: Journal of Educational Computing Research Vol 7(1) 1991, 37-50.
  • Otto, J. R., Cook, J. H., & Chung, Q. B. (2001). Extensible markup language and knowledge management: Journal of Knowledge Management Vol 5(3) 2001, 278-284.
  • Owens, B. B. (1978). An interaction study of reasoning aptitudes, model presence and methods of approach in the learning of a computer programming language: Dissertation Abstracts International.
  • Pair, C. (1971). The formalization of programming languages: Mathe1matiques et Sciences Humaines Vol 9(34) Sum 1971, 71-86.
  • Pair, C. (1988). Programming, programming languages and methods: Le Travail Humain Vol 51(4) Dec 1988, 297-307.
  • Palumbo, D. B. (1990). The effects of BASIC programming instruction on high school students' problem-solving ability and computer anxiety: Dissertation Abstracts International.
  • Palumbo, D. B. (1990). Programming language/problem-solving research: A review of relevant issues: Review of Educational Research Vol 60(1) Spr 1990, 65-89.
  • Palya, W. L., & Walter, D. E. (1993). A powerful, inexpensive experiment controller or IBM PC interface and experiment control language: Behavior Research Methods, Instruments & Computers Vol 25(2) May 1993, 127-136.
  • Payne, S. J., & Green, T. R. (1989). The structure of command languages: An experiment on task-action grammar: International Journal of Man-Machine Studies Vol 30(2) Feb 1989, 213-234.
  • Payne, S. J., Sime, M. E., & Green, T. R. (1984). Perceptual structure cueing in a simple command language: International Journal of Man-Machine Studies Vol 21(1) Jul 1984, 19-29.
  • Pellon, R., & Mas, B. (1985). ONLIBASIC: A computer language for animal conditioning experiments: Revista de Psicologia General y Aplicada Vol 40(6) 1985, 1199-1217.
  • Pennington, N., Lee, A. Y., & Rehder, B. (1995). Cognitive activities and levels of abstraction in procedural and object-oriented design: Human-Computer Interaction Vol 10(2-3) 1995, 171-226.
  • Penzkofer, T., Pfeiffer, T., & Krems, J. F. (1995). Analysis of program text: The influence of experience and context on understanding command sequences: Zeitschrift fur Psychologie mit Zeitschrift fur angewandte Psychologie Vol 203(2) 1995, 139-152.
  • Perkins, D. N., & Simmons, R. (1988). Patterns of misunderstanding: An integrative model for science, math, and programming: Review of Educational Research Vol 58(3) Fal 1988, 303-326.
  • Perlman, G. (1984). Natural artificial languages: Low level processes: International Journal of Man-Machine Studies Vol 20(4) Apr 1984, 373-419.
  • Perlman, G. (1985). Electronic surveys: Behavior Research Methods, Instruments & Computers Vol 17(2) Apr 1985, 203-205.
  • Perpignano, P. A. (1986). The effects of learning computer programming on demographically similar high school students' verbal and nonverbal reasoning and perceptions of school life quality: Dissertation Abstracts International.
  • Petre, M. (1991). What experts want from programming languages: Ergonomics Vol 34(8) Aug 1991, 1113-1127.
  • Petre, M., & Blackwell, A. F. (1999). Mental imagery in program design and visual programming: International Journal of Human-Computer Studies Vol 51(1) Jul 1999, 7-30.
  • Philippides, A. (2006). Statistical software review: MatLab 7 (Service Pack 2): British Journal of Mathematical and Statistical Psychology Vol 59(1) May 2006, 221-222.
  • Picciotto, H., & Ploger, D. (1991). Learning about sampling with Boxer: The Journal of Mathematical Behavior Vol 10(1) Apr 1991, 91-113.
  • Pinkus, A. L., & Gregg, L. W. (1973). APCOL: A programming system for computer-controlled psychology laboratories: Behavior Research Methods & Instrumentation Vol 5(2) Mar 1973, 165-172.
  • Pintrich, P. R., Berger, C. F., & Stemmer, P. M. (1987). Students' programming behavior in a Pascal course: Journal of Research in Science Teaching Vol 24(5) May 1987, 451-466.
  • Pirolli, P. L. (1986). Problem solving by analogy and skill acquisition in the domain of programming: Dissertation Abstracts International.
  • Pirolli, P. L., & Anderson, J. R. (1985). The role of learning from examples in the acquisition of recursive programming skills: Canadian Journal of Psychology/Revue Canadienne de Psychologie Vol 39(2) Jun 1985, 240-272.
  • Pitz, G. F. (1975). Building a programming language for a small computer: Reinventing the wheel: Behavior Research Methods & Instrumentation Vol 7(1) Jan 1975, 42-46.
  • Ploger, D. (1991). Learning about the genetic code via programming: Representing the process of translation: The Journal of Mathematical Behavior Vol 10(1) Apr 1991, 55-77.
  • Ploger, D., & Lay, E. (1992). The structure of programs and molecules: Journal of Educational Computing Research Vol 8(3) 1992, 347-364.
  • Polson, P. G. (1973). SCAT: Design criteria and software: Behavior Research Methods & Instrumentation Vol 5(2) Mar 1973, 241-244.
  • Polzella, D. J., & Gouse, A. S. (1978). PSYCHIC: A BASIC game to test ESP as d': Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 426-428.
  • Postner, L. E. (2003). What's so hard about learning to program? A cognitive and ethnographic analysis of beginning programming students. Dissertation Abstracts International Section A: Humanities and Social Sciences.
  • Poulin-Dubois, D., McGilly, C. A., & Shultz, T. R. (1989). Psychology of computer use: X. Effect of learning Logo on children's problem-solving skills: Psychological Reports Vol 64(3, Pt 2) Jun 1989, 1327-1337.
  • Purchase, H. C., Welland, R., McGill, M., & Colpoys, L. (2004). Comprehension of diagram syntax: An empirical study of entity relationship notations: International Journal of Human-Computer Studies Vol 61(2) Aug 2004, 187-203.
  • Putnam, R. T., Sleeman, D., Baxter, J. A., & Kuspa, L. K. (1986). A summary of misconceptions of high school basic programmers: Journal of Educational Computing Research Vol 2(4) 1986, 459-472.
  • Pynte, J. (1988). Conceptual models and task representation in using a command language: The Quarterly Journal of Experimental Psychology A: Human Experimental Psychology Vol 40(3-A) Aug 1988, 443-467.
  • Rae, G. (1996). Exact probabilities for the general matching problem: Educational and Psychological Measurement Vol 56(5) Oct 1996, 839-842.
  • Rajan, T. (1991). An evaluation of APT: An animated program tracer for novice Prolog programmers: Instructional Science Vol 20(2-3) 1991, 89-110.
  • Ramadhan, H. A. (2000). Programming by discovery: Journal of Computer Assisted Learning Vol 16(1) Mar 2000, 83-93.
  • Ramsey, J. O. (1990). MATFIT: A FORTRAN subroutine for comparing two matrices in a subspace: Psychometrika Vol 55(3) Sep 1990, 551-553.
  • Recker, M. M. (1993). Students' strategies for learning programming from a computational environment: A design, evaluation, and model: Dissertation Abstracts International.
  • Redmond, R. T., & Gasen, J. B. (1988). PAST: Viewing the programming process: Behavior Research Methods, Instruments & Computers Vol 20(5) Oct 1988, 503-507.
  • Reed, W. M., & Palumbo, D. B. (1992). The effect of BASIC instruction on problem solving skills over an extended period of time: Journal of Educational Computing Research Vol 8(3) 1992, 311-325.
  • Reidbord, S. P., & Redington, D. J. (1992). Analysis and visualization of complex psychophysiological data: Coordinated use of multiple applications on a microcomputer: Behavior Research Methods, Instruments & Computers Vol 24(2) May 1992, 213-218.
  • Reilly, R., & Mac Aogain, E. (1988). Poorly formed input and miscommunication in natural-language keyboard dialogue: An exploratory study: Computers in Human Behavior Vol 4(3) 1988, 275-283.
  • Reimer, G. D. (1987). Logo effects on readiness for first grade, creativity, and self-concept: Dissertation Abstracts International.
  • Reips, U.-D., & Neuhaus, C. (2002). WEXTOR: A web-based tool for generating and visualizing experimental designs and procedures: Behavior Research Methods, Instruments & Computers Vol 34(2) May 2002, 234-240.
  • Reisman, S. (1977). The effect of selected variables on the learning of some computer programming elements: Dissertation Abstracts International.
  • Rembert, W. I. (1990). Cross-age tutoring and young children's spatial problem-solving skills in a Logo programming environment: Dissertation Abstracts International.
  • Renk, S. C. (1987). Factors affecting academic success in introductory computer programming: Dissertation Abstracts International.
  • Resnick, M. (1991). MultiLogo: A study of children and concurrent programming. Westport, CT: Ablex Publishing.
  • Resnick, M. (1993). Beyond the centralized mindset: Explorations in massively-parallel microworlds: Dissertation Abstracts International.
  • Resnick, M. (1994). Turtles, termites, and traffic jams: Explorations in massively parallel microworlds. Cambridge, MA: The MIT Press.
  • Reynolds, K. E. (1985). A study of in-service teachers' behavior while using inductive and deductive instructional materials in an introductory course in BASIC: Dissertation Abstracts International.
  • Rhodes, P. C., & Merad-Menani, S. (1995). Towards a fuzzy logic programming system: A clausal form fuzzy logic: Knowledge-Based Systems Vol 8(4) Aug 1995, 174-182.
  • Rice, C. G. (1986). DOMSORT: An Apple II program for sorting interaction matrices to find the dominance order: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 389-392.
  • Richardson, W. H., Jr. (2006). A treatment of computational precision, number representation, and large integers in an introductory Fortran course: Journal of Computers in Mathematics and Science Teaching Vol 25(3) 2006, 213-237.
  • Richer, M. H., & Clancey, W. J. (1987). GUIDON-WATCH: A graphic interface for viewing a knowledge-based system. Westport, CT: Ablex Publishing.
  • Righi, C. (1991). Using advance organizers to teach BASIC programming to primary-grade children: Educational Technology Research and Development Vol 39(4) 1991, 79-90.
  • Rippey, R. M. (1965). A 1620 FORTRAN program for compiling a Flanders-Amidon interaction analysis matrix: Educational and Psychological Measurement 25(1) 1965, 235-237.
  • Rist, R. S. (1990). Knowledge creation and retrieval in program design: A comparison of novice and experienced programmers: Dissertation Abstracts International.
  • Rittle, R. H. (1990). Computer literacy in the psychology curriculum: Teaching a database language for control of experiments: Teaching of Psychology Vol 17(2) Apr 1990, 127-129.
  • Roberts, J. S., & Huang, C.-W. (2003). GGUMLINK: A computer program to link parameter estimates of the generalized graded unfolding model from item response theory: Behavior Research Methods, Instruments & Computers Vol 35(4) Nov 2003, 525-536.
  • Roberts, R. J. (1985). Young children's spatial frames of reference in simple computer graphics programming: Dissertation Abstracts International.
  • Rodd, M. K. (1984). Locus of control, self-esteem, and the acquisition of problem solving skills through the instruction of logo and basic computer programming languages in gifted children: Dissertation Abstracts International.
  • Rodefer, J. C. (1986). Teaching higher-level thinking skills through LOGO: Dissertation Abstracts International.
  • Rogalski, J., & He, Y. (1989). Logic abilities and mental representations of the informatical device in acquisition of conditional structures by 15-26 year old students: European Journal of Psychology of Education Vol 4(1) Mar 1989, 71-82.
  • Rogalski, J., Samurcay, R., & Hoc, J. M. (1988). Learning programming methods as problem-solving methods: Le Travail Humain Vol 51(4) Dec 1988, 309-320.
  • Rogers, R. H. (1991). The relationship of cognitive style to selected learning outcomes of a middle school exploratory Logo course: Dissertation Abstracts International.
  • Rohwer, W. D., & Thomas, J. W. (1989). The role of autonomous problem-solving activities in learning to program: Journal of Educational Psychology Vol 81(4) Dec 1989, 584-593.
  • Roid, G. H. (1974). Selecting CAI author languages to solve instructional problems: Educational Technology Vol 14(5) May 1974, 29-31.
  • Romero, P. (2001). Focal structures and information types in Prolog: International Journal of Human-Computer Studies Vol 54(2) Feb 2001, 211-236.
  • Roos, L. L., Wise, S. L., Yoes, M. E., & Rocklin, T. R. (1996). Conducting self-adapted testing using MicroCAT: Educational and Psychological Measurement Vol 56(5) Oct 1996, 821-827.
  • Ross, M. A. (1986). A study of the interaction between locus of control and scheduled feedback on the level of achievement in a post-secondary COBOL programming course: Dissertation Abstracts International.
  • Rouchier, A. (1987). The writing and interpretation of recursive procedures in LOGO: Psychologie Francaise Vol 32(4) Dec 1987, 281-285.
  • Rucinski, T. T. (1987). The effect of computer programming on the problem solving strategies of preservice teachers: Dissertation Abstracts International.
  • Runciman, C. (1990). From abstract models to functional prototypes. New York, NY: Cambridge University Press.
  • Rush, D. K. (1986). Apple II assembly language routines for digital data acquisition and contingency control: Behavior Research Methods, Instruments & Computers Vol 18(1) Feb 1986, 32-35.
  • Saariluoma, P. (1988). The psychology of programming as a part of the psychology of problem solving: Psykologia Vol 23(4) 1988, 262-272.
  • Sattler, D. M. (1987). Programming in BASIC or LOGO: Effects on critical thinking skills: Dissertation Abstracts International.
  • Scapin, D. L. (1981). Computer commands in restricted natural language: Some aspects of memory and experience: Human Factors Vol 23(3) Jun 1981, 365-375.
  • Scapin, D. L. (1982). Generation effect, structuring and computer commands: Behaviour & Information Technology Vol 1(4) Oct-Dec 1982, 401-410.
  • Schaefer, L., & Sprigle, J. E. (1988). Gender differences in the use of the LOGO programming language: Journal of Educational Computing Research Vol 4(1) 1988, 49-55.
  • Schank, P. K., Linn, M. C., & Clancy, M. L. (1993). Supporting Pascal programming with an on-line template library and case studies: International Journal of Man-Machine Studies Vol 38(6) Jun 1993, 1031-1048.
  • Scherz, Z., Goldberg, D., & Fund, Z. (1990). Cognitive implications of learning Prolog: Mistakes and misconceptions: Journal of Educational Computing Research Vol 6(1) 1990, 89-110.
  • Schiele, F., & Green, T. (1990). HCI formalisms and cognitive psychology: The case of Task-Action Grammar. New York, NY: Cambridge University Press.
  • Schmalhofer, F., Boschert, S., & Kuhn, O. (1990). The construction of a situation model from text and examples: Zeitschrift fur Padagogische Psychologie/ German Journal of Educational Psychology Vol 4(3) Sep 1990, 177-186.
  • Schmalhofer, F., Kuhn, O., Messamer, P., & Charron, R. (1990). An experimental evaluation of different amounts of receptive and exploratory learning in a tutoring system: Computers in Human Behavior Vol 6(1) 1990, 51-68.
  • Schmidt, R., Fischer, E., Heydemann, M., & Hoffmann, R. (1991). Searching for interference among consistent and inconsistent editors: The role of analytic and wholistic processing: Acta Psychologica Vol 76(1) Feb 1991, 51-72.
  • Schmitt, J. C. (1977). Factor analysis in BASIC for minicomputers: Behavior Research Methods & Instrumentation Vol 9(3) Jun 1977, 302-304.
  • Schneck, M. A. (1986). Principles of learning and instruction underlying effective computer-based mathematics curricula: I and II: Dissertation Abstracts International.
  • Schneider, M. L., Hirsh-Pasek, K., & Nudelman, S. (1984). An experimental evaluation of delimiters in a command language syntax: International Journal of Man-Machine Studies Vol 20(6) Jun 1984, 521-535.
  • Schocken, S., & Kleindorfer, P. R. (1989). Artificial intelligence dialects of the Bayesian belief revision language: IEEE Transactions on Systems, Man, & Cybernetics Vol 19(5) Sep-Oct 1989, 1106-1121.
  • Scholtz, J., & Wiedenback, S. (1993). Using unfamiliar programming languages: The effects on expertise: Interacting with Computers Vol 5(1) Mar 1993, 13-30.
  • Scholtz, J., & Wiedenbeck, S. (1990). Learning second and subsequent programming languages: A problem of transfer: International Journal of Human-Computer Interaction Vol 2(1) 1990, 51-72.
  • Scholtz, J., & Wiedenbeck, S. (1992). Learning new programming languages: An analysis of the process and problems encountered: Behaviour & Information Technology Vol 11(4) Jul-Aug 1992, 199-215.
  • Scholtz, J., & Wiedenbeck, S. (1992). The role of planning in learning a new programming language: International Journal of Man-Machine Studies Vol 37(2) Aug 1992, 191-214.
  • Scholtz, J. C. (1990). A study of transfer of skill between programming languages: Dissertation Abstracts International.
  • Scholz, K. W. (1972). Computerized process control in behavioral science research: Behavior Research Methods & Instrumentation Vol 4(4) Jul 1972, 203-208.
  • Scholz, K. W. (1973). PROSS: A process control programming language: Behavior Research Methods & Instrumentation Vol 5(2) Mar 1973, 245-247.
  • Schroder, O., Frank, K.-D., Kohnert, K., Mobus, C., & et al. (1990). Instruction-based knowledge acquisition and modification: The operational knowledge for a functional, visual programming language: Computers in Human Behavior Vol 6(1) 1990, 31-49.
  • Schumacher, R. M., DeCoste, D., Dugan, D., & Grunzke, P. M. (1986). Three programs for evaluation of human-computer interaction: Behavior Research Methods, Instruments & Computers Vol 18(5) Oct 1986, 476-477.
  • Schwartz, A. (1998). Tutorial: Perl, a psychologically efficient reformatting language: Behavior Research Methods, Instruments & Computers Vol 30(4) Nov 1998, 605-609.
  • Schwartz, S., Perkins, D. N., Estey, G., Kruidenier, J., & et al. (1989). A "metacourse" for basic: Assessing a new model for enhancing instruction: Journal of Educational Computing Research Vol 5(3) 1989, 263-297.
  • Scott, P. J., & Nicolson, R. I. (1991). Cognitive science projects in Prolog. Hillsdale, NJ, England: Lawrence Erlbaum Associates, Inc.
  • Sebrechts, M. M., & Gross, P. H. (1985). Programming in natural language: A descriptive analysis: Behavior Research Methods, Instruments & Computers Vol 17(2) Apr 1985, 268-274.
  • Segal, J., Ahmad, K., & Rogers, M. (1992). The role of systematic errors in developmental studies of programming language learners: Journal of Educational Computing Research Vol 8(2) 1992, 129-153.
  • Seidman, R. H. (1980). The effects of learning the LOGO computer programming language on conditional reasoning in school children: Dissertation Abstracts International.
  • Senay, H. (1992). Fuzzy command grammars for intelligent interface design: IEEE Transactions on Systems, Man, & Cybernetics Vol 22(5) Sep-Oct 1992, 1124-1131.
  • Shackelford, R. L., & Badre, A. N. (1993). Why can't smart students solve simple programming problems? : International Journal of Man-Machine Studies Vol 38(6) Jun 1993, 985-997.
  • Shanker, S. G. (1987). The decline and fall of the mechanist metaphor. New York, NY: Croom Helm.
  • Shaw, D. G. (1985). The effects of learning to program a computer in BASIC or Logo on the problem solving abilities of fifth grade students: Dissertation Abstracts International.
  • Shelley, D. J. (1987). Programming abilities of elementary students using Beginners All-Purpose Symbolic Instructional Code: Dissertation Abstracts International.
  • Sherin, B. (2002). Representing geometric constructions as programs: A brief exploration: International Journal of Computers for Mathematical Learning Vol 7(1) Apr 2002, 101-115.
  • Shore, A. (1987). Improved higher order thinking skills through guided problem solving in Logo: Dissertation Abstracts International.
  • Shurtleff, M. S. (1992). Menu organization through block clustering: International Journal of Man-Machine Studies Vol 37(6) Dec 1992, 779-792.
  • Shute, V. J. (1991). Who is likely to acquire programming skills? : Journal of Educational Computing Research Vol 7(1) 1991, 1-24.
  • Silverman, K. E. (1986). FRED: An interactive graphics program to modify fundamental frequency contours in resynthesized speech: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 395-397.
  • Sime, M. E., Arblaster, A. T., & Green, T. R. (1977). Reducing programming errors in nested conditionals by prescribing a writing procedure: International Journal of Man-Machine Studies Vol 9(1) Jan 1977, 119-126.
  • Sime, M. E., Arblaster, A. T., & Green, T. R. (1977). Structuring the programmer's task: Journal of Occupational Psychology Vol 50(3) Sep 1977, 205-216.
  • Sime, M. E., Green, T. R., & Guest, D. J. (1973). Psychological evaluation of two conditional constructions used in computer languages: International Journal of Man-Machine Studies Vol 5(1) Jan 1973, 105-113.
  • Sime, M. E., Green, T. R., & Guest, D. J. (1977). Scope marking in computer conditionals: A psychological evaluation: International Journal of Man-Machine Studies Vol 9(1) Jan 1977, 107-118.
  • Sime, M. E., Green, T. R. G., & Guest, D. J. (1999). Psychological evaluation of two conditional constructions used in computer languages: International Journal of Human-Computer Studies Vol 51(2) Aug 1999, 125-133.
  • Simon, T. (1987). Claims for LOGO: What should we believe and why? Oxford, England: John Wiley & Sons.
  • Simpson, H. K. (1988). The use of descriptive models to facilitate the learning of a command language: Dissertation Abstracts International.
  • Simpson, H. K., & Pellegrino, J. W. (1993). Descriptive models in learning command languages: Journal of Educational Psychology Vol 85(3) Sep 1993, 539-550.
  • Skuce, D. (2000). Integrating web-based documents, shared knowledge bases, and information retrieval for user help: Computational Intelligence Vol 16(1) Feb 2000, 95-113.
  • Slagle, J. R. (1971). Artificial intelligence: The heuristic programming approach. New York, NY: McGraw-Hill.
  • Slemmer, C. F. (1992). Development and evaluation of a learning hierarchy for computer programming in COBOL: Dissertation Abstracts International.
  • Small, D. W., & Weldon, L. J. (1983). An experimental comparison of natural and structured query languages: Human Factors Vol 25(3) Jun 1983, 253-263.
  • Smelcer, J. B. (1990). Understanding user errors in database query: Dissertation Abstracts International.
  • Smelcer, J. B. (1995). User errors in database query composition: International Journal of Human-Computer Studies Vol 42(4) Apr 1995, 353-381.
  • Smith, B. A. (1987). The effect of spatial ability, field independence, course background, attitude, and sex on computer programming ability: Dissertation Abstracts International.
  • Smith, C. D. (1986). Learning LOGO: Effects on learning BASIC and statistics: Journal of Computer Assisted Learning Vol 2(2) Jul 1986, 102-109.
  • Smith, E. W. (2000). The influence of syntax on cognitive processing of computer program statements. (psycholinguistics, software, grammars). Dissertation Abstracts International: Section B: The Sciences and Engineering.
  • Smith, K. H., Zirkler, D., & Mynatt, B. T. (1985). Transfer of training from introductory computer courses is highly specific... and negativep: Behavior Research Methods, Instruments & Computers Vol 17(2) Apr 1985, 259-264.
  • Snapper, A., & Hamilton, B. (1974). Programming special functions in the SKED system: Behavior Research Methods & Instrumentation Vol 6(2) Mar 1974, 173-176.
  • Snapper, A., Lee, D., Burczyk, L., & Simoes-Fontes, J. C. (1974). FOCAL, FORTRAN, and BASIC programs for reformatting and analyzing data collected by the SKED program: Behavior Research Methods & Instrumentation Vol 6(2) Mar 1974, 176-180.
  • Snaprud, M., & Kaindl, H. (1994). Types and inheritance in hypertext: International Journal of Human-Computer Studies Vol 41(1-2) Jul-Aug 1994, 223-241.
  • Sohn, W.-S., Kim, J.-K., Ko, S.-K., Lim, S.-B., & Choy, Y.-C. (2003). Context-based free-form annotation in XML documents: International Journal of Human-Computer Studies Vol 59(3) Sep 2003, 257-285.
  • Sorin, N., & Desrosiers-Sabbath, R. (1991). The impact of learning LOGO on the structuring of narratives: Canadian Journal of Education Vol 16(2) Spr 1991, 121-136.
  • Sparkes, R. A. (1995). An investigation of Year 7 pupils learning CONTROL LOGO: Journal of Computer Assisted Learning Vol 11(3) Sep 1995, 182-191.
  • Spector, P. E. (1993). SAS programming for researchers and social scientists. Thousand Oaks, CA: Sage Publications, Inc.
  • Spence, I. (1983). Monte carlo simulation studies: Applied Psychological Measurement Vol 7(4) Fal 1983, 405-425.
  • Sprigle, J. E., & Schaefer, L. (1984). Age, gender and spatial knowledge influences on preschoolers' computer programming ability: Early Child Development and Care Vol 14(3-4) Mar 1984, 243-250.
  • Stanton, J. M. (2000). Empirical distributions of correlations as a tool for scale reduction: Behavior Research Methods, Instruments & Computers Vol 32(3) Aug 2000, 403-406.
  • Starkweather, J. A. (1965). Computest: A computer language for individual testing, instruction, and interviewing: Psychological Reports 17(1) 1965, 227-237.
  • Steedman, M. (1996). Natural language processing. San Diego, CA: Academic Press.
  • Steinbach, M. J. (1977). Phase-difference haploscope using only one shutter disk: Behavior Research Methods & Instrumentation Vol 9(3) Jun 1977, 267-268.
  • Steven, M., Lammertyn, J., Verbruggen, F., & Vandierendonck, A. (2006). Tscope: A C library for programming cognitive experiments on the MS Windows platform: Behavior Research Methods Vol 38(2) May 2006, 280-286.
  • Stevens, A. L., Levin, J. A., Olds, R. R., & Rumelhart, D. E. (1977). A computer system for automatically constructing stimulus material: Behavior Research Methods & Instrumentation Vol 9(3) Jun 1977, 269-273.
  • Stone, D. N., Jordan, E. W., & Wright, M. K. (1990). The impact of Pascal education on debugging skill: International Journal of Man-Machine Studies Vol 33(1) Jul 1990, 81-95.
  • Stout, J., Caplain, G., Marcus, S., & McDermott, J. (1988). Toward automating recognition of differing problem-solving demands: International Journal of Man-Machine Studies Vol 29(5) Nov 1988, 599-611.
  • Strand, E. B. (1987). Preschoolers' problem-solving experiences with Logo: A microethnographic study: Dissertation Abstracts International.
  • Striler, R. J. (1990). Effects of high school BASIC programming on critical thinking: Dissertation Abstracts International.
  • Strube, M. J. (1986). SMOOTH: A BASIC program for smoothing a data series: Behavior Research Methods, Instruments & Computers Vol 18(5) Oct 1986, 475.
  • Sturgis, S. P. (1983). A spectral-analysis tutorial with examples in FORTRAN: Behavior Research Methods & Instrumentation Vol 15(3) Jun 1983, 377-386.
  • Su, Y.-H., Sheu, C.-F., & Wang, W.-C. (2007). Computing confidence intervals of item fit statistics in the family of Rasch models using the bootstrap method: Journal of Applied Measurement Vol 8(2) 2007, 190-203.
  • Subhi, T. (1999). The impact of LOGO on gifted children's achievement and creativity: Journal of Computer Assisted Learning Vol 15(2) Jun 1999, 98-108.
  • Sugarman, D. B. (1983). Factor structure comparisons: Two BASIC programs for microprocessors: Behavior Research Methods & Instrumentation Vol 15(5) Oct 1983, 542.
  • Suomala, J. (1996). Eight-year-old-pupils' problem solving processes within a LOGO learning environment: Scandinavian Journal of Educational Research Vol 40(4) Dec 1996, 291-309.
  • Swan, K. (1991). Programming objects to think with: LOGO and the teaching and learning of problem solving: Journal of Educational Computing Research Vol 7(1) 1991, 89-112.
  • Sweetland, R. D. (1987). Learning PASCAL in a sixth grade classroom: After LOGO experiences: Dissertation Abstracts International.
  • Takane, Y. (1978). A maximum likelihood method for nonmetric multidimensional scaling: I. The case in which all empirical pairwise orderings are independent: Evaluations: Japanese Psychological Research Vol 20(3) Sep 1978, 105-114.
  • Takigawa, T., & Mino, T. (1981). TYMES: A high-level language for process control and data manipulation in the behavior laboratory: Behavior Research Methods & Instrumentation Vol 13(6) Dec 1981, 741-746.
  • Tamiz, M., & Mardle, S. J. (1998). An interactive graphics-based linear, integer and goal programme modelling environment: Decision Support Systems Vol 23(3) Jul 1998, 285-296.
  • Tancig, P., & Tancig, S. (1976). Analysis of symbolic structures with computers: Revija za Psihologiju Vol 6(1-2) 1976, 93-100.
  • Tannenbaum, G. P. (1986). Cognitive and behavioral correlates of success in a computer programming course for elementary school students: Dissertation Abstracts International.
  • Tarjan, J. R. (1990). A behavioral model of software development productivity and an exploratory study of the relationship between individual variables and programming performance: Dissertation Abstracts International.
  • Tatham, T. A., & Zurn, K. R. (1989). The MED-PC experimental apparatus programming system: Behavior Research Methods, Instruments & Computers Vol 21(2) Apr 1989, 294-302.
  • Taylor, J., & Boulay, B. d. (1987). Studying novice programmers: Why they may find learning PROLOG hard. Oxford, England: John Wiley & Sons.
  • Tegarden, D. P., & Sheetz, S. D. (2001). Cognitive activities in OO development: International Journal of Human-Computer Studies Vol 54(6) Jun 2001, 779-798.
  • Tennyson, R. D., & Bagley, C. A. (1992). Structured versus constructed instructional strategies for improving concept acquisition by domain-competent and domain-novice learners: Journal of Structural Learning Vol 11(3) Nov 1992, 255-263.
  • Theise, E. S. (1989). Finding a subset of stimulusesponse pairs with minimum total confusion: A binary integer programming approach: Human Factors Vol 31(3) Jun 1989, 291-305.
  • Theise, E. S. (1989). Finding a subset of stimulus-response pairs with minimum total confusion: A binary integer programming approach: Human Factors Vol 31(3) Jun 1989, 291-305.
  • Thibadeau, R. (1983). CAPS: A language for modeling highly skilled knowledge-intensive behavior: Behavior Research Methods & Instrumentation Vol 15(2) Apr 1983, 300-304.
  • Thomas, J. C. (1976). A method for studying natural language dialogue. Oxford, England: Ibm Research Div.
  • Thomas, J. C. (1976). Quantifiers and question-asking. Oxford, England: Ibm Research Div.
  • Thronson, R. M. (1985). Achievement as a function of learning style preference in beginning computer programming courses: Dissertation Abstracts International.
  • Till, A. (1977). CONVERSION: A series of FORTRAN IV programs for converting probabilities, odds, evidence, and information measures into one another: Behavior Research Methods & Instrumentation Vol 9(6) Dec 1977, 515-516.
  • Todman, J. B., & File, P. E. (1991). Effects of subjective and objective databases on children's attitudes to computers: Journal of Educational Computing Research Vol 7(3) 1991, 351-362.
  • Topolski, J. M. (1984). Predictors of computer program readability: Dissertation Abstracts International.
  • Trautteur, G. (1989). Remarks on recursion: A response to Vitale: New Ideas in Psychology Vol 7(3) 1989, 283-284.
  • Treu, S. (1975). Interactive command language design based on required mental work: International Journal of Man-Machine Studies Vol 7(1) Jan 1975, 135-149.
  • Tseng, J.-d. (1991). The effects of two instructional methods on problem-solving ability and LOGO programming achievement: Dissertation Abstracts International.
  • Tu, J.-j. (1989). The relationship between learning programming and problem-solving ability: Dissertation Abstracts International.
  • Turner, S. V., & Land, M. L. (1988). Cognitive effects of a Logo-enriched mathematics program for middle school students: Journal of Educational Computing Research Vol 4(4) 1988, 443-452.
  • Underwood, J. D. (1983). Analysing command language paradigms in software for computer assisted learning: Human Learning: Journal of Practical Research & Applications Vol 2(1) Jan-Mar 1983, 7-16.
  • Van Bergem, P., Ditrichs, R., & Simon, S. (1986). A BASIC program for nonparametric analyses of proximity matrices: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 407-408.
  • Van Biljon, W. R. (1988). Extending Petri nets for specifying man-machine dialogues: International Journal of Man-Machine Studies Vol 28(4) Apr 1988, 437-455.
  • Van der Veer, G. C. (1989). Individual differences and the user interface: Ergonomics Vol 32(11) Nov 1989, 1431-1449.
  • Van Dyke, J. G. (1985). The relationship between "LOGO" and creativity: Dissertation Abstracts International.
  • Van Someren, M. W. (1990). What's wrong? Understanding beginners' problems with Prolog: Instructional Science Vol 19(4-5) 1990, 257-282.
  • Vandierendonck, A., de Soete, G., & Vlaeminck, F. (1985). How to write compound statements in structured computer programming languages? : Psychologica Belgica Vol 25(2) 1985, 169-174.
  • Veldman, D. J. (1969). Off target! : PsycCRITIQUES Vol 14 (10), Oct, 1969.
  • Verschaffel, L., de Corte, E., & Schrooten, H. (1992). Transfer of Logo knowledge and programming ability: Tijdschrift voor Onderwijsresearch Vol 17(1) Feb 1992, 40-54.
  • Vessey, I. (1988). Expert-novice knowledge organization: An empirical investigation using computer program recall: Behaviour & Information Technology Vol 7(2) Apr-Jun 1988, 153-171.
  • Vessey, I., & Weber, R. (1984). Conditional statements and program coding: An experimental evaluation: International Journal of Man-Machine Studies Vol 21(2) Aug 1984, 161-190.
  • Vihmalo, A., & Vihmalo, M. (1988). Utilization of subject's background knowledge in computer program comprehension: Zeitschrift fur Psychologie mit Zeitschrift fur angewandte Psychologie Vol 196(4) 1988, 401-413.
  • Visser, W. (1988). The activity of comparing representations in program debugging: Le Travail Humain Vol 51(4) Dec 1988, 351-362.
  • Vitale, B. (1988). Psycho-cognitive aspects of dynamic model-building in LOGO: A simple population evolution and predator/prey program: Journal of Educational Computing Research Vol 4(3) 1988, 227-252.
  • Vitale, B. (1989). Elusive recursion: A trip in recursive land: New Ideas in Psychology Vol 7(3) 1989, 253-276.
  • Vitale, B. (1990). A psychopedagogical approach to the teaching of a programming language in secondary schools: Infancia y Aprendizaje No 50 1990, 63-71.
  • Vodounon, M. A. (2004). Perceptions Displayed by Novice Programmers When Exploring the Relationship Between Modularization Ability and Performance in the C++ Programming Language: Journal of Computers in Mathematics and Science Teaching Vol 23(4) 2004, 379-397.
  • Vodounon, M. A. (2006). Exploring the relationship between modularization ability and performance in the C++ programming language: The case of novice programmers and expert programmers: Journal of Computers in Mathematics and Science Teaching Vol 25(2) 2006, 197-207.
  • Vokey, J. R. (1986). MATRICKS: Matrix algebra for Applesoft BASIC: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 409-411.
  • von Collani, G. (1983). Computing probabilities for F, t, chi-square, and z in BASIC: Behavior Research Methods & Instrumentation Vol 15(5) Oct 1983, 543-544.
  • Wager, W. W., Wager, S., & Duffield, J. (1989). Computers in teaching: A compleat training manual for teachers to use computers in their classrooms. Cambridge, MA: Brookline Books.
  • Wagner, R. K., Sebrechts, M. M., & Black, J. B. (1985). Tracing the evolution of knowledge structures: Behavior Research Methods, Instruments & Computers Vol 17(2) Apr 1985, 275-278.
  • Walder, L. O. (1966). A set of sociometric Fortran II routines: Educational and Psychological Measurement 26(1) 1966, 175-177.
  • Walsh, J. F. (1990). Locating errors in questionnaire style data: A FORTRAN program: Perceptual and Motor Skills Vol 71(2) Oct 1990, 537-538.
  • Wang, C. H., & Hwang, S. L. (1989). The dynamic hierarchical model of problem solving: IEEE Transactions on Systems, Man, & Cybernetics Vol 19(5) Sep-Oct 1989, 946-954.
  • Wang, H., Liao, S., & Liao, L. (2002). Modeling constraint-based negotiating agents: Decision Support Systems Vol 33(2) Jun 2002, 201-217.
  • Warner, C. B., & Martin, M. K. (1999). eXpTools: A C++ class library for animation, tachistoscopic presentation, and response timing: Behavior Research Methods, Instruments & Computers Vol 31(3) Aug 1999, 387-399.
  • Watson, J. A., Lange, G., & Brinkley, V. M. (1992). Logo mastery and spatial problem-solving by young children: Effects of Logo language training, route-strategy training, and learning styles on immediate learning and transfer: Journal of Educational Computing Research Vol 8(4) 1992, 521-540.
  • Watts, B. H. (1986). FORTH, a software solution to real-time computing problems: Behavior Research Methods, Instruments & Computers Vol 18(2) Apr 1986, 228-235.
  • Weaver, J. L. (1990). The complexity of BASIC computer programming for novices: Dissertation Abstracts International.
  • Weber, G., Bogelsack, A., & Wender, K. F. (1993). When can individual student models be useful? Amsterdam, Netherlands: North-Holland/Elsevier Science Publishers.
  • Weinberg, C. B. (1974). The change agent game (A computerized game in BASIC for use on time sharing terminals): Behavior Research Methods & Instrumentation Vol 6(5) Sep 1974, 505.
  • Weiser, M., & Shneiderman, B. (1987). Human factors of computer programming. Oxford, England: John Wiley & Sons.
  • Weitzenfeld, A., Arbib, M., & Alexander, A. (2002). The neural simulation language: A system for brain modeling. Cambridge, MA: MIT Press.
  • Welty, C. (1985). Correcting user errors in SQL: International Journal of Man-Machine Studies Vol 22(4) Apr 1985, 463-477.
  • White, A. P., Still, A. W., & Harris, P. W. (1978). Six FORTRAN IV programs for conducting simple randomization tests: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 455.
  • White, G. L. (2002). Cognitive characteristics of learning Java, an object-oriented programming language. Dissertation Abstracts International Section A: Humanities and Social Sciences.
  • Whitley, K. N., Novick, L. R., & Fisher, D. (2006). Evidence in favor of visual representation for the dataflow paradigm: An experiment testing LabVIEW's comprehensibility: International Journal of Human-Computer Studies Vol 64(4) Apr 2006, 281-303.
  • Wicks, J. W. (1974). BALANCE: A FORTRAN IV program for computing the demographic "balancing equation" on a computer terminal: Behavior Research Methods & Instrumentation Vol 6(5) Sep 1974, 504.
  • Wiedenbeck, S. (1989). Learning iteration and recursion from examples: International Journal of Man-Machine Studies Vol 30(1) Jan 1989, 1-22.
  • Wiedenbeck, S., & Ramalingam, V. (1999). Novice comprehension of small programs written in the procedural and object-oriented styles: International Journal of Human-Computer Studies Vol 51(1) Jul 1999, 71-87.
  • Williams, M. G., & Buehler, J. N. (1999). Comparison of visual and textual languages via task modeling: International Journal of Human-Computer Studies Vol 51(1) Jul 1999, 89-115.
  • Williamson, J. D. (1986). Knowledge representation and cognitive outcomes of teaching Logo to children: Dissertation Abstracts International.
  • Wilson, D., Mundy-Castle, A., & Sibanda, P. (1991). Cognitive effects of LOGO and computer-aided instruction among Black and White Zimbabwean primary school girls: Journal of Social Psychology Vol 131(1) Feb 1991, 107-116.
  • Wilson, D., Mundy-Castle, A. C., Sibanda, P., & Lavelle, S. (1990). Cognitive benefits of LOGO and computer-aided instruction among Zimbabwean schoolgirls: Psychological Reports Vol 66(3, Pt 1) Jun 1990, 946.
  • Winer, L. R. (1987). A personal construct theory based method for questionnaire development: A field test with teacher attitudes towards educational computing: Dissertation Abstracts International.
  • Winograd, T. (1972). Understanding natural language. Oxford, England: Academic Press.
  • Wolfe, C. R., & Reyna, V. F. (2002). Using NetClock to develop server-side web-based experiments without writing CGI programs: Behavior Research Methods, Instruments & Computers Vol 34(2) May 2002, 204-207.
  • Wood, D. L., & Wood, D. (1986). Precise F integration: Behavior Research Methods, Instruments & Computers Vol 18(4) Aug 1986, 405-406.
  • Wotawa, F. (2004). Debugging VHDL Designs: Introducing Multiple Models and First Empirical Results: Applied Intelligence Vol 21(2) Sep-Oct 2004, 159-172.
  • Wray, R. E., & Jones, R. M. (2006). Considering Soar as an Agent Architecture. New York, NY: Cambridge University Press.
  • Wright, J., & Lane, D. M. (1978). A FORTRAN IV program for linear contrasts in designs with repeated measurements: Behavior Research Methods & Instrumentation Vol 10(3) Jun 1978, 433-434.
  • Wu, Q., & Anderson, J. R. (1993). Strategy choice and change in programming: International Journal of Man-Machine Studies Vol 39(4) Oct 1993, 579-598.
  • Xia, L., Wynne, C. D., von Munchow-Pohl, F., & Delius, J. D. (1991). PSYCHOBASIC: A BASIC dialect for the control of psychological experiments with the Commodore-64 and DELA interfacing: Behavior Research Methods, Instruments & Computers Vol 23(1) Feb 1991, 72-76.
  • Xinogalos, S., Satratzemi, M., & Dagdilelis, V. (2006). An introduction to object-oriented programming with a didactic microworld: objectKarel: Computers & Education Vol 47(2) Sep 2006, 148-171.
  • Yared, W. I., & Sheridan, T. B. (1991). Plan recognition and generalization in command languages with application to telerobotics: IEEE Transactions on Systems, Man, & Cybernetics Vol 21(2) Mar-Apr 1991, 327-338.
  • Yen, M. Y.-m. (1990). A human factors experimental comparison of two database query languages: Dissertation Abstracts International.
  • Zaldivar, V. A. R., Arandia, J. A. E., & Brito, M. L. (2005). YADBrowser: A Browser for Web-Based Educational Applications: Journal of Educational Multimedia and Hypermedia Vol 14(2) 2005, 129-149.
  • Zar, J. H. (1976). Watson's nonparametric two-sample test: Behavior Research Methods & Instrumentation Vol 8(6) Dec 1976, 513.
  • Zhang, D., & Luqi. (1999). Approximate declarative semantics for rule base anomalies: Knowledge-Based Systems Vol 12(7) Nov 1999, 341-353.
  • Zhang, G.-j. (1987). Learning to program in OPS5: Dissertation Abstracts International.
  • Zirkler, D. J. (1989). The effects of guided discovery and example-based instruction on the cognitive consequences of Logo programming: Dissertation Abstracts International.
  • Zoeppritz, M. (1986). A framework for investigating language-mediated interaction with machines: International Journal of Man-Machine Studies Vol 25(3) Sep 1986, 295-315.

Further readingEdit

  • Daniel P. Friedman, Mitchell Wand, Christopher Thomas Haynes: Essentials of Programming Languages, The MIT Press 2001.
  • David Gelernter, Suresh Jagannathan: Programming Linguistics, The MIT Press 1990.
  • Shriram Krishnamurthi: Programming Languages: Application and Interpretation, online publication.
  • Bruce J. MacLennan: Principles of Programming Languages: Design, Evaluation, and Implementation, Oxford University Press 1999.
  • John C. Mitchell: Concepts in Programming Languages, Cambridge University Press 2002.
  • Benjamin C. Pierce: Types and Programming Languages, The MIT Press 2002.
  • Ravi Sethi: Programming Languages: Concepts and Constructs, 2nd ed., Addison-Wesley 1996.
  • Michael L. Scott: Programming Language Pragmatics, Morgan Kaufmann Publishers 2005.
  • Richard L. Wexelblat (ed.): History of Programming Languages, Academic Press 1981.

External linksEdit

Template:Programming language Template:Computer language

This page uses Creative Commons Licensed content from Wikipedia (view authors).

Around Wikia's network

Random Wiki