Question 1

In human–computer interaction and communication theory, which modality represents the primary interactive method that humans use to exchange information in real time with other people?

Accepted Answer

Introduction / Context: Communication can be carried out through many modalities such as speaking, writing, and reading. In everyday human–human interaction, one modality dominates for immediate, interactive exchange: spontaneous speech. This question probes your understanding of the primary, real-time channel humans naturally rely on to coordinate, persuade, instruct, and collaborate.Given Data / Assumptions:We are comparing common human modalities: speaking, writing, and reading.“Primary interactive” emphasizes real-time, two-way exchange with low latency.Cultural and technological contexts may vary, but the biological and developmental basis of speech remains universal.Concept / Approach: Speaking is the default human modality acquired early in life without formal instruction. It supports duplex (turn-taking) conversation, rapid feedback (prosody, intonation), and efficient error correction. Writing and reading are powerful but generally slower, learned skills best suited to persistence, archival, and asynchronous communication. Therefore, for interactive communication in real time, speaking is primary.Step-by-Step Solution:Identify which modality humans acquire first and use most naturally for live dialogue: speaking.Consider immediacy and feedback: speech enables instant clarification.Contrast with writing/reading: valuable but typically asynchronous and slower.Select the choice that reflects real-time primacy: speaking.Verification / Alternative check: Observationally, emergency coordination, spontaneous teaching, and informal collaboration are speech-led. Even in digital platforms, live voice (and video with voice) remains the fastest path to mutual understanding when speed matters.Why Other Options Are Wrong:Reading: critical for learning, but not a production modality for two-way exchange.Writing: excellent for permanence and precision, but slower and often asynchronous.All of the above: overbroad; only one modality is primary for real-time interaction.None of the above: incorrect because speaking fits the criterion.Common Pitfalls: Equating importance with primacy; writing and reading are essential, but the question asks about the primary interactive method, not the most accurate or permanent one.Final Answer: speaking

Question 2

Semiconductor history check: The integrated circuit (IC) was invented by Jack Kilby working at which organization?

Accepted Answer

Introduction / Context: The development of the integrated circuit marked a turning point in modern electronics, enabling miniaturization and mass production of complex logic. Identifying the correct inventor and organization helps ground your understanding of computing hardware history and its industrial origins.Given Data / Assumptions:Inventor: Jack Kilby.Timeframe: late 1950s.Question: On whose payroll and at which company did the breakthrough occur?Concept / Approach: Jack Kilby demonstrated the first integrated circuit while employed by Texas Instruments, showing that resistors, capacitors, and transistors could be fabricated together as a single piece. This enabled compact, reliable, and scalable electronics. Although other organizations contributed to GUI, AI, and research (e.g., Xerox PARC, MIT), the IC invention credited to Kilby is tied to Texas Instruments.Step-by-Step Solution:Identify the inventor: Jack Kilby.Recall the employer at the time of invention: Texas Instruments.Match the option corresponding to Texas Instruments.Reject distractors not associated with Kilby’s IC demonstration.Verification / Alternative check: Historical accounts and awards (including the Nobel Prize in Physics to Kilby) document the Texas Instruments affiliation for the integrated circuit’s first demonstration.Why Other Options Are Wrong:MIT: a leading research university, but not where Kilby invented the IC.Xerox: known for PARC innovations (GUI, Ethernet, laser printing), not Kilby’s IC.All of the above: impossible; the invention is credited to a single organization.None of the above: false because Texas Instruments is correct.Common Pitfalls: Confusing general computing milestones (like GUI at Xerox PARC) with semiconductor fabrication breakthroughs; mixing up multiple inventors across companies.Final Answer: Texas Instruments

Question 3

Programming languages: Which symbols are conventionally used to denote nonterminal metavariables in grammar notations (e.g., BNF) when describing syntax?

Accepted Answer

Introduction / Context: Formal descriptions of programming language syntax often use grammar notations such as BNF (Backus–Naur Form) or EBNF. In these notations, it is standard to distinguish nonterminals (syntactic categories) from terminals (literal tokens). This question asks which symbols are commonly used to mark nonterminals.Given Data / Assumptions:We are focusing on notation conventions, not language keywords.Typical textbooks show nonterminals enclosed in angle brackets.Terminals are shown as quoted strings or literal characters.Concept / Approach: In BNF-style grammars, nonterminal symbols are frequently written as using angle brackets, whereas terminals are often represented with quotes. Braces {} can indicate repetition or sets in some EBNF variants, and quotation marks indicate literal terminals. A bare zero is unrelated to grammar categories. Hence, angle brackets best fit the conventional marking of nonterminals.Step-by-Step Solution:Recall BNF conventions: ::= | ...Recognize that the angle brackets wrap nonterminal names.Eliminate symbols used for other purposes (quotes, braces).Select the angle-bracket notation.Verification / Alternative check: Most compiler design texts (e.g., on lexical and syntax analysis) illustrate nonterminals with angle brackets, reinforcing the choice.Why Other Options Are Wrong:0: a numeral, not a notation for grammar categories.{}: sometimes used for repetition in EBNF, not to denote nonterminals."""": quotation marks indicate terminals (literal tokens), not nonterminals.None of the above: incorrect because angle brackets are standard.Common Pitfalls: Mixing terminal and nonterminal conventions; assuming braces or quotes mark categories rather than repetition or literals.Final Answer: <>

Question 4

Historical AI hardware: Texas Instruments Incorporated produced a relatively low-cost LISP machine. What was this platform called?

Accepted Answer

Introduction / Context: During the AI boom of the 1980s, dedicated LISP machines provided hardware and environments optimized for symbolic computation and AI development. Texas Instruments was among the vendors producing such systems at lower price points compared to some competitors. This question asks you to recall the specific TI product name.Given Data / Assumptions:Vendor: Texas Instruments.Product category: LISP machine.We need the correct branded name used by TI.Concept / Approach: TI’s family of LISP machines was marketed under the name “Explorer.” These systems bundled hardware, operating environments, and LISP development tools. Other names in the options refer to expert-system shells or languages that are not the TI LISP machine brand.Step-by-Step Solution:Identify that we are looking for a hardware platform name, not software.Recall the TI LISP machine branding: Explorer.Eliminate software-only shells (e.g., The Personal Consultant) and languages (Smalltalk).Choose “The Explorer.”Verification / Alternative check: Historical catalogs and AI retrospectives list TI Explorer alongside Symbolics and Lisp Machines Inc. offerings.Why Other Options Are Wrong:The Computer-Based Consultant: not TI’s LISP machine brand.Smalltalk: a programming language and environment from Xerox PARC, not TI hardware.The Personal Consultant: an expert-system shell, not a hardware platform.None of the above: incorrect because Explorer is correct.Common Pitfalls: Confusing software shells and languages with hardware product names; mixing Xerox PARC artifacts with TI branding.Final Answer: The Explorer

Question 5

AI methodology: One way to program a computer to exhibit human-like intelligence is to build a computer model of the target behavior. This approach is commonly called modeling or what?

Accepted Answer

Introduction / Context: AI systems often emulate aspects of human cognition or intelligent behavior. When we construct a computational mechanism that behaves like the system we are studying, we are building a model that runs—i.e., a simulation. This question targets the standard terminology connecting modeling to its operational manifestation in AI and computational science.Given Data / Assumptions:We are considering a method to program human-like intelligence.“Modeling” refers to representing mechanisms and processes.The term sought is the widely accepted companion concept to modeling.Concept / Approach: Modeling creates a structured representation; simulation executes that representation over time to observe behavior. In AI, we might simulate perception, reasoning, or learning processes to test hypotheses and evaluate performance. Thus “simulation” is the canonical term paired with modeling.Step-by-Step Solution:Recognize that modeling defines structure and rules.A running model that mimics behavior is a simulation.Map terminology: modeling ↔ simulation.Select “simulation.”Verification / Alternative check: In research literature, “model and simulate” is a standard phrase; AI cognitive modeling explicitly involves simulation to compare with human performance.Why Other Options Are Wrong:Cognitization: not standard terminology.Duplication: implies exact copying, not model-based emulation.Psychic amelioration: unrelated to AI methodology.None of the above: incorrect because simulation is correct.Common Pitfalls: Assuming simulation requires physical robots; it can be entirely software-based. Confusing “duplicate” with “simulate”—models approximate essential features, not necessarily every detail.Final Answer: simulation

Question 6

Foundations of AI: A classic definition emphasizes problem-solving methods that operate on which kind of internal representations?

Accepted Answer

Introduction / Context: One influential view of artificial intelligence, sometimes called the Physical Symbol System Hypothesis, frames intelligence in terms of manipulating formal symbols according to rules. Understanding this framing clarifies how early AI systems represented knowledge and performed search, planning, and reasoning.Given Data / Assumptions:We are selecting the type of internal representation emphasized by classic AI.The focus is on problem-solving methods (search, inference).We are not discussing sensory modalities directly (smell, touch).Concept / Approach: Symbolic AI represents entities, relations, and operations as symbols and structures (lists, trees, graphs) and applies algorithms to transform these symbols. While algorithms are the procedures, the key representational substrate is symbols. Thus the question’s emphasis is on representational form rather than the procedures per se.Step-by-Step Solution:Identify what classic AI systems manipulate: symbols (logical expressions, semantic nets, rules).Distinguish representation (symbols) from process (algorithms).Eliminate sensory choices (smell, touch) as categories of input, not internal representation.Select “symbols.”Verification / Alternative check: Historical AI textbooks discuss rule-based systems, theorem proving, and search operating over symbolic structures, confirming this emphasis.Why Other Options Are Wrong:Smell and touch: sensory modalities, not representational substrates.Algorithms: methods that operate on representations; the question asks about the objects being processed.None of the above: incorrect because symbols fit exactly.Common Pitfalls: Confusing the role of algorithms with the nature of representations; overlooking that modern AI also includes subsymbolic representations, but the classic definition names symbols explicitly.Final Answer: symbols

Question 7

User interface history: Early graphical user interfaces (GUIs) were pioneered at Xerox. Which Xerox environment is widely associated with introducing GUI concepts later adopted industry-wide?

Accepted Answer

Introduction / Context: The modern GUI—windows, icons, menus, and pointing—owes much to work done at Xerox PARC. Understanding which environments showcased these ideas helps trace the lineage from research systems to commercial desktops at Apple and Microsoft.Given Data / Assumptions:The environment was developed at Xerox PARC.It is specifically associated with GUI exploration and demonstration.We are choosing among names that include languages and unrelated technologies.Concept / Approach: Smalltalk at Xerox PARC was both a programming language and an interactive environment exhibiting overlapping windows, direct manipulation, and object-oriented design—core GUI concepts. While the Xerox Star workstation later commercialized a GUI, Smalltalk is the best match among the provided options for “graphical interfaces first used in a Xerox product called …”. Ethernet is a networking technology; InterLISP and ZetaLISP are Lisp systems not singled out for GUI invention in the same way.Step-by-Step Solution:Identify Xerox PARC GUI demonstrators: Alto + Smalltalk environment.Match the option list: Smalltalk is the PARC GUI environment listed.Eliminate networking and non-GUI-focused Lisp variants.Choose “Smalltalk.”Verification / Alternative check: Histories of GUI credit PARC’s Smalltalk environment and the later Xerox Star; among the listed names, Smalltalk uniquely fits GUI origins.Why Other Options Are Wrong:InterLISP and ZetaLISP: primarily Lisp systems, not the canonical GUI showcase.Ethernet: network technology, unrelated to GUI.None of the above: incorrect because Smalltalk is correct.Common Pitfalls: Confusing the research environment (Smalltalk on Alto) with later commercial products; attributing GUI firsts to networking or unrelated language distributions.Final Answer: Smalltalk

Question 8

Expert-system tooling: ART (Automatic Reasoning Tool) was originally designed to run on which class of hardware/platform?

Accepted Answer

Introduction / Context: ART (Automatic Reasoning Tool), developed during the heyday of expert systems, provided a high-performance rule-based environment. Early expert-system tools frequently targeted specialized hardware optimized for symbolic processing, such as LISP machines, before later ports broadened availability.Given Data / Assumptions:The time period is the early-to-mid expert-systems era.Vendors prioritized platforms with strong Lisp support and memory management.We are selecting the original/primary intended hardware class.Concept / Approach: LISP machines (e.g., Symbolics, TI Explorer) were prime hosts for early AI toolkits due to native Lisp support and development environments. ART’s early deployments emphasized these machines. Although later versions and related tools reached conventional workstations and PCs, the historically accurate initial platform class is LISP machines.Step-by-Step Solution:Identify ART as an expert-system tool from the LISP-machine era.Match the platform most associated with early AI tool deployment: LISP machines.Reject over-broad “All of the above,” which overstates initial availability.Select “LISP machines.”Verification / Alternative check: Contemporary product literature and retrospectives frequently list LISP machines among ART’s earliest supported platforms, with later ports extending reach.Why Other Options Are Wrong:Personal computers / microcomputers: became targets later; not the original emphasis.All of the above: historically inaccurate for the initial design intent.None of the above: incorrect because LISP machines fit.Common Pitfalls: Projecting modern cross-platform expectations backward; assuming early expert systems launched on commodity PCs.Final Answer: LISP machines

Question 9

Knowledge engineering history: The KEE (Knowledge Engineering Environment) expert-system shell was a product of which company?

Accepted Answer

Introduction / Context: KEE (Knowledge Engineering Environment) was a prominent commercial expert-system shell that provided a rich object–rule environment and graphical tools. Knowing the vendor behind KEE helps place it among peers like ART and other shells of the same era.Given Data / Assumptions:The correct vendor name must match one of the provided options exactly.We recognize KEE as a commercial product, not an academic prototype.Some distractor options are near-miss spellings or other AI companies.Concept / Approach: KEE was developed and sold by IntelliCorp. The option text presents “IntelliCorpn,” which is a misspelling in the original choices but clearly refers to IntelliCorp. Because the instructions require choosing exactly from the given options, we must select the provided string that corresponds to IntelliCorp.Step-by-Step Solution:Recall vendor of KEE: IntelliCorp.Identify closest exact-match option: “IntelliCorpn.”Eliminate other companies and misspellings that do not match KEE’s vendor.Select the IntelliCorpn option per the list.Verification / Alternative check: Historical product catalogs and AI market surveys list KEE under IntelliCorp’s offerings.Why Other Options Are Wrong:Teknowledge: a different AI company; not the KEE vendor.Texas Instruments: hardware and software vendor (e.g., Explorer), but not KEE.Tech knowledge: malformed distractor.None of the above: incorrect because the IntelliCorpn option corresponds to IntelliCorp.Common Pitfalls: Being thrown off by the slight misspelling; always match the historically correct vendor to the closest exact option provided.Final Answer: IntelliCorpn

Question 10

Applications of natural language understanding (NLU): In practice, NLU technology is used in which of the following categories of systems?

Accepted Answer

Introduction / Context: Natural language understanding (NLU) refers to computational methods that parse and interpret human language input to extract meaning, intent, and actionable structure. This capability underpins a variety of system categories used in databases, applications, and information extraction.Given Data / Assumptions:Categories listed include interfaces, front ends, and text-understanding systems.We are asked where NLU is used in practice, not just theoretically.Multiple categories may apply simultaneously.Concept / Approach: NLU powers natural language interfaces (directly querying systems in everyday language), natural language front ends (wrapping existing systems like databases or search with NLU), and text understanding systems (information extraction, summarization, sentiment). Therefore, all listed categories legitimately employ NLU techniques.Step-by-Step Solution:Identify NLU’s functional role: parsing/semantic interpretation.Map NLU to each category: interfaces, front ends, and text analytics.Confirm that all three categories routinely rely on NLU.Select the inclusive choice: All of the above.Verification / Alternative check: Industry applications—from voice assistants (interfaces/front ends) to document mining (text understanding)—demonstrate NLU’s breadth.Why Other Options Are Wrong:(b) and (c) above: too narrow; excludes interfaces that also use NLU.Individual categories (a, b, or c alone) omit legitimate NLU uses.Common Pitfalls: Assuming NLU is only for unstructured text analytics; forgetting that front ends and conversational interfaces depend on the same semantic parsing.Final Answer: All of the above

Question 11

Computer architecture classification (Flynn's taxonomy): How should the Cray X-MP, IBM 3090, and the Connection Machine be characterized at the architectural level used in parallel-computing surveys?

Accepted Answer

Introduction / Context: Classifying computers using Flynn's taxonomy helps students understand how instruction and data streams are organized in different architectures. Classic supercomputers and massively parallel systems are often grouped by whether they execute a single instruction on many data elements (SIMD) or multiple independent instruction streams (MIMD). The question asks how the Cray X-MP, IBM 3090, and the Connection Machine are characterized in these high-level surveys.Given Data / Assumptions: Systems mentioned: Cray X-MP, IBM 3090 (vector supercomputers), and the Connection Machine (massively parallel array).The taxonomy options: SISD, SIMD, MISD, MIMD, or none.We use the conventional teaching view that classifies classic vector and array processors with the SIMD family.Concept / Approach: SIMD (Single Instruction, Multiple Data) applies one instruction simultaneously to multiple data points. Vector supercomputers like the Cray and IBM 3090 execute vector instructions across vector registers/pipelines, which many texts group under SIMD. The Connection Machine CM series implements data-parallel operations across thousands of simple processing elements under a common instruction stream—archetypal SIMD.Step-by-Step Solution: Identify the execution style of vector machines: data-parallel vector operations.Identify the Connection Machine's array of PEs under a shared instruction stream.Map both families to the SIMD category in standard overviews.Choose the taxonomy label that consistently fits all three: SIMD.Verification / Alternative check: Introductory parallel-computing texts commonly depict vector and array machines in the SIMD quadrant, contrasting them with shared-memory or message-passing MIMD multiprocessors. While vector multiprocessors can have multiple CPUs, their defining programming model for performance is data parallelism akin to SIMD.Why Other Options Are Wrong: SISD: single instruction and single data stream; does not reflect data-parallel execution. MISD: rare and largely theoretical; does not match these systems. MIMD: some models apply, but the standard survey grouping for these exemplars emphasizes SIMD-style data parallelism. None of the above: unnecessary; SIMD is appropriate.Common Pitfalls: Confusing implementation details (e.g., multiple CPUs) with the dominant programming model. In pedagogy, these machines are taught as data-parallel exemplars, thus placed in SIMD.Final Answer: SIMD

Question 12

In industrial robotics terminology: A robot’s articulated “arm” assembly—responsible for positioning and orienting the tool—is called the ______.

Accepted Answer

Introduction / Context: Robotics uses precise terms for each part of an automated system. Understanding names like “manipulator,” “end effector,” and “actuator” is essential for selecting hardware, reading datasheets, and troubleshooting performance. The question asks for the correct name of the robot’s arm assembly that moves and positions tools in space.Given Data / Assumptions: The “arm” refers to the multi-joint mechanical structure from base to wrist.Common related terms are provided as options.We assume a standard industrial robot (e.g., 6-DOF articulated arm).Concept / Approach: The manipulator is the robot’s arm structure made up of links and joints. The manipulator provides the degrees of freedom required to place and orient the tool. The end effector (such as a gripper or welder) attaches to the wrist. Actuators (motors) drive joints, and servomechanisms are control loops that manage position/velocity/torque.Step-by-Step Solution: Identify what the “arm” physically represents: links + joints.Match this structure to the robotics term “manipulator.”Differentiate end effector (tool), actuator (drive), and servomechanism (control system).Select “manipulator.”Verification / Alternative check: Robot kinematics texts define forward/inverse kinematics on the manipulator; the end effector pose is the output. This confirms that the arm assembly is the manipulator, independent of the tool attached.Why Other Options Are Wrong: End effector: the tool, not the arm. Actuator: a component (motor), not the assembly. Servomechanism: control method, not the physical arm. None of the above: incorrect because “manipulator” fits precisely.Common Pitfalls: Calling the entire arm “the gripper.” The gripper is just one type of end effector; the arm that positions it is the manipulator.Final Answer: manipulator

Question 13

Common Lisp function behavior: What does the expression (list-length <list>) return when evaluated at the top level of the REPL?

Accepted Answer

Introduction / Context: Lisp lists and list-processing functions are foundational for AI and symbolic programming. The function list-length is used to determine how many cons cells are in a proper list. Knowing precisely what it returns prevents confusion with predicates or list-copying utilities.Given Data / Assumptions: The form is (list-length ).We consider standard Common Lisp semantics for proper lists.We assume is a well-formed finite list for this question.Concept / Approach: In Common Lisp, list-length computes the number of elements in a proper list and returns an integer. It is not a predicate (it does not return t/nil based solely on emptiness) and does not produce a new copy of the list. Predicates like null check for emptiness, and functions such as copy-list duplicate lists.Step-by-Step Solution: Identify the function’s role: measure cardinality of a list.Recall: (list-length nil) returns 0, not t.Confirm that no new list structure is created; only a count is computed.Therefore, it returns the length as an integer.Verification / Alternative check: Evaluate examples: (list-length '(a b c)) → 3; (list-length nil) → 0. This verifies the behavior and differentiates it from predicates and copying functions.Why Other Options Are Wrong: Copy list: behavior of copy-list, not list-length. Returns t if empty: that is null, not list-length. All of the above: mixes mutually exclusive behaviors. None of the above: incorrect because returning the length is correct.Common Pitfalls: Confusing truthy/falsey values with numeric counts, and forgetting that an empty list has length 0 rather than returning a boolean.Final Answer: returns the length of

Question 14

Computer-Assisted Instruction (CAI) methods: Which CAI technique is explicitly based on programmed instruction, presenting content as a sequence of small, structured frames?

Accepted Answer

Introduction / Context: Computer-Assisted Instruction encompasses a range of approaches, from simple drill-and-practice to intelligent tutoring. One historically important method follows the behaviorist tradition of programmed instruction, delivering content in small steps and branching based on student responses.Given Data / Assumptions: The question asks for the CAI approach tied to programmed instruction.Options include multiple CAI families with distinct pedagogical goals.We interpret “programmed instruction” as linear/branching frames with immediate feedback.Concept / Approach: Frame-based CAI presents content as a series of discrete frames: a statement/question followed by a required response and feedback. This mirrors Skinnerian programmed instruction and can include branching to remedial or advanced frames. Other approaches (e.g., intelligent CAI) incorporate domain models and learner models to adapt more deeply beyond fixed frames.Step-by-Step Solution: Identify the hallmark of programmed instruction: sequenced frames with immediate feedback.Match that hallmark to “frame-based CAI.”Exclude alternatives that emphasize discovery/problem solving or AI-driven tutoring.Select “frame-based CAI.”Verification / Alternative check: Educational technology texts categorize classic programmed instruction under frame-based CAI. Intelligent tutoring systems extend beyond frames with knowledge-based reasoning.Why Other Options Are Wrong: Generative CAI: focuses on learner-generated content or rule generation, not classic frames. Problem-solving CAI: emphasizes open-ended tasks rather than sequenced frames. Intelligent CAI: uses AI for adaptivity; not synonymous with programmed instruction. None of the above: incorrect because frame-based CAI directly matches.Common Pitfalls: Equating any step-by-step tutorial with intelligent CAI; the latter requires explicit domain and student models, not just branching frames.Final Answer: frame-based CAI

Question 15

AI programming history: What was the first widely recognized programming language created specifically for artificial intelligence research?

Accepted Answer

Introduction / Context: Early AI research required symbolic processing and list structures that were poorly supported by the numeric-focused languages of the 1950s. Understanding the sequence of languages adopted by the AI community clarifies how representation and search techniques shaped language design.Given Data / Assumptions: We are selecting the earliest AI-focused language.Candidates include general-purpose languages (BASIC, FORTRAN) and AI-centric languages (IPL, LISP).Historical context: mid-to-late 1950s development in AI labs.Concept / Approach: IPL (Information Processing Language), developed by Newell, Shaw, and Simon in the 1950s, supported list processing for programs like the Logic Theorist and General Problem Solver. It predated LISP and directly targeted AI problem solving. LISP, later created by John McCarthy, became the dominant AI language, but IPL was earlier.Step-by-Step Solution: Identify which options are AI-specific: IPL and LISP.Order historically: IPL predates LISP.Eliminate general-purpose teaching or numeric languages like BASIC/FORTRAN for early AI symbolism.Select IPL.Verification / Alternative check: AI histories consistently credit IPL as an early AI language used to implement seminal AI programs, with LISP subsequently providing a more general algebra of programs and data via s-expressions.Why Other Options Are Wrong: BASIC/FORTRAN: not designed for symbolic AI in the 1950s. LISP: highly influential but later than IPL. None of the above: incorrect because IPL is correct.Common Pitfalls: Assuming LISP was first due to its long-standing prominence; the chronological first for AI work is IPL.Final Answer: IPL

Question 16

Lisp REPL behavior: When a top-level function call is entered, what sequence of actions does the Lisp system perform in the classic Read–Eval–Print loop?

Accepted Answer

Introduction / Context: A hallmark of Lisp environments is the interactive Read–Eval–Print Loop (REPL). Understanding how the REPL processes expressions is key to debugging AI programs, experimenting with data structures, and building incremental prototypes.Given Data / Assumptions: The prompt accepts a function call form (operator followed by operands).The system follows the canonical REPL cycle.We consider a normal, successful evaluation without reader or runtime errors.Concept / Approach: The REPL cycles through three main steps: read (parse the textual input into Lisp objects), eval (evaluate the expression—i.e., call the function on evaluated arguments under Lisp's applicative order), and print (render the returned value to the console using the printer). Many Lisp implementations add a fourth “loop” step to continue interaction.Step-by-Step Solution: Read: the reader converts characters into a symbolic expression.Eval: the evaluator resolves symbols, applies functions, and computes results.Print: the printer outputs the returned value in a readable form.Combine: all three are performed in sequence on each top-level input.Verification / Alternative check: Try a simple call, e.g., (+ 1 2). The system reads the list, evaluates it to 3, then prints 3. Errors during reading (e.g., mismatched parentheses) or evaluation (e.g., undefined function) confirm the distinct phases.Why Other Options Are Wrong: Single-phase options omit essential steps; REPL does all three. None of the above: incorrect because “All of the above” maps to the REPL exactly.Common Pitfalls: Confusing macro expansion with reading or printing; macros expand during evaluation but are separate from the reader and printer.Final Answer: All of the above

Question 17

Classic LISP truth values: In Lisp, which atom conventionally represents the logical value “true” in conditionals and predicates?

Accepted Answer

Introduction / Context: Lisp uses simple, elegant semantics for truth: any value other than NIL is considered true. Nevertheless, the community converged on a canonical symbol to represent truth explicitly. Knowing this symbol helps when reading code, documentation, and test predicates.Given Data / Assumptions: We are using classic Common Lisp conventions.NIL represents false and the empty list.We want the conventional atom used for explicit truth.Concept / Approach: While Lisp treats any non-NIL value as truthy, the symbol T is the conventional explicit true value. Many built-in predicates return T for success and NIL for failure. This convention improves readability and consistency, even though other non-NIL values would also be treated as true in conditionals.Step-by-Step Solution: Recall the pairing: NIL = false, T = true.Map options: “t” is the conventional true symbol; others are arbitrary.Select “t.”Verification / Alternative check: Evaluate (if t 'yes 'no) → YES, (if nil 'yes 'no) → NO. Predicate examples like (numberp 42) typically return T.Why Other Options Are Wrong: ml, y, time: plain symbols with no special truth status. None of the above: incorrect; T is standard.Common Pitfalls: Thinking true must always be T; any non-NIL is treated as true, but T is the conventional explicit true value.Final Answer: t

Question 18

Parallel computer families (examples): Cedar, BBN Butterfly, Cosmic Cube, and Hypercube machines are best classified under which Flynn category?

Accepted Answer

Introduction / Context: Learning to classify famous parallel machines helps build intuition about how programs execute on different architectures. The Cedar, BBN Butterfly, Cosmic Cube, and Hypercube systems are classic exemplars frequently cited in parallel-computing courses and texts.Given Data / Assumptions: The listed machines use multiple processors that can execute independent instruction streams.We map them to one of SISD, SIMD, MISD, or MIMD.We focus on their dominant architectural model.Concept / Approach: MIMD (Multiple Instruction, Multiple Data) machines contain multiple autonomous processors, each with its own control unit and instruction stream. Systems like the BBN Butterfly and Intel's hypercube-connected machines are prototypical MIMD multiprocessors/multicomputers, executing different threads on different processors concurrently.Step-by-Step Solution: Identify independent control: each node executes its own instructions.Note interconnection topologies (butterfly, hypercube) that enable scalable communication among nodes.Map this to MIMD rather than SIMD or SISD.Select “MIMD.”Verification / Alternative check: Standard references list Cedar and BBN Butterfly as shared-memory or message-passing MIMD machines. Hypercube-based systems like the Cosmic Cube are also canonical MIMD multicomputers.Why Other Options Are Wrong: SISD: single processor; not applicable. SIMD: single instruction broadcast; not the model here. MISD: rarely used; does not describe these examples. None of the above: unnecessary; MIMD fits precisely.Common Pitfalls: Confusing interconnection topology (e.g., hypercube) with instruction/data stream classification. The topology is orthogonal to the MIMD nature of independent instruction streams.Final Answer: MIMD

Question 19

Basic phonology and units of speech: Which term names the elementary linguistic units smaller than words that function as the minimal distinctive sounds in a language?

Accepted Answer

Introduction / Context: In speech and language processing, it is important to distinguish the basic units that underpin pronunciation and lexical contrast. Understanding these units helps in fields from automatic speech recognition to phonological analysis and language teaching.Given Data / Assumptions: We compare allophones, phonemes, and syllables.We seek the elementary units smaller than words that are contrastive in a language.The question targets the standard linguistic definition used in phonology.Concept / Approach: Phonemes are the smallest units of sound that can distinguish meaning (e.g., /p/ vs. /b/ in English “pat” vs. “bat”). Allophones are context-dependent variants of a phoneme that do not create lexical contrasts (e.g., aspirated [pʰ] vs. unaspirated [p]). Syllables are larger prosodic units typically built from one or more phonemes, not the minimal contrastive units.Step-by-Step Solution: Identify the requirement of distinctiveness (meaning-changing power).Map that property to phonemes, not to allophones or syllables.Recognize that syllables are composed of phonemes; they are not minimal units.Select “phonemes.”Verification / Alternative check: Minimal-pair tests (e.g., “cap” vs. “cab”) show that swapping one phoneme yields a meaning change; swapping an allophone typically does not change lexical meaning.Why Other Options Are Wrong: Allophones: variants of a phoneme; not contrastive. Syllables: supra-segmental units, larger than phonemes. All of the above: incorrect because only phonemes satisfy the “elementary, contrastive unit” criterion. None of the above: incorrect because phonemes fit perfectly.Common Pitfalls: Confusing “smaller than a word” with “elementary and contrastive.” Several units are smaller than words, but only phonemes are the minimal contrastive sound units in standard phonology.Final Answer: phonemes

Artificial Intelligence Questions

Questions

Practice smarter