Study guide

12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs

Praxis Computer Science 5652

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Praxis 5652 Exam Overview and ETS Pseudocode

1.1 Praxis 5652 Test Facts, Scoring, and Registration 1.2 Official ETS Pseudocode Notation and Tracing Strategy

2 Chapter 2: Impacts of Computing: Innovation, Access, and Effects

2.1 Computing for Creativity, Problem Solving, Communication, and Innovation 2.2 Equal Access, the Digital Divide, and Accessibility 2.3 Beneficial and Harmful Effects of Computing Innovations

3 Chapter 3: Impacts of Computing: Intellectual Property, Ethics, Privacy, and Security

3.1 Intellectual Property: Copyright, Open Source, and Creative Commons 3.2 Ethical and Unethical Computing Practices and Their Implications 3.3 Privacy, Security, Data Collection, and Local vs. Cloud Storage

4 Chapter 4: Algorithms and Computational Thinking: Abstraction, Decomposition, Number Bases, and Representation

4.1 Abstraction and Abstraction Hierarchies 4.2 Decomposition, Pattern Recognition, and Developing Algorithms 4.3 Number Bases: Binary, Octal, Decimal, and Hexadecimal 4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing

5 Chapter 5: Algorithms: Efficiency, Limits of Computing, and Randomization

5.1 Algorithm Efficiency: Linear, Quadratic, Exponential, and Logarithmic Growth 5.2 Limits of Computing: Unsolvable Problems, Intractability, and Heuristics 5.3 Randomization, Random vs. Pseudorandom Numbers, and Scaling to a Range

6 Chapter 6: Algorithms: Searching, Sorting, and Recursion

6.1 Searching Algorithms: Linear Search and Binary Search 6.2 Sorting Algorithms: Tracing, Comparisons, Correctness, and Efficiency 6.3 Recursion: Base Cases, Tracing, Errors, and Iterative Equivalents

7 Chapter 7: Programming: Variables, Data Types, Strings, and Expressions

7.1 Variables, Data Types, and Type Conversion 7.2 Strings and String Operations 7.3 Operators, Precedence, Expressions, and Formulas 7.4 Boolean Expressions, Truth Tables, and Boolean Algebra

8 Chapter 8: Programming: Selection, Iteration, and Writing Code

8.1 Sequence and Selection: if, else, Chained and Nested Conditions 8.2 Iteration: for, while, do … while, and repeat … until Loops 8.3 Reading, Completing, and Modifying Code

9 Chapter 9: Programming: Procedures, Arrays, and Data Structures

9.1 Procedures, Parameters, Return Values, Nested Calls, and Scope 9.2 Arrays, Lists, and Two-Dimensional Arrays 9.3 Stacks, Queues, and Dictionaries (Maps)

10 Chapter 10: Programming: Correctness, Errors, Testing, and Code Quality

10.1 Program Correctness: Preconditions, Postconditions, Invariants, and Testing vs. Proof 10.2 Error Types and Debugging Techniques 10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression 10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization 10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback

11 Chapter 11: Programming: Events, Usability, Input Validation, and APIs

11.1 Event-Driven Programming, Asynchronous Events, and Concurrency 11.2 Usability, Meaningful Error Messages, and Input Validation vs. Verification 11.3 Libraries and APIs: Reading Definitions, Making Calls, and Weighing Trade-offs

12 Chapter 12: Programming: Languages, Tools, Paradigms, and Object-Oriented Design

12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs 12.2 Programming Paradigms: Procedural, Object-Oriented, and Others 12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation 12.4 Inheritance, Polymorphism, and Overloading vs. Overriding

13 Chapter 13: Data: Bits, Encoding, Compression, and Encryption

13.1 Bits and Bytes: Why Binary, Storage Calculations, and Signed Integers 13.2 Encoding Text, Images, and Sound 13.3 Lossless and Lossy Compression: Run-Length Encoding, Huffman Coding, and Media Formats 13.4 Encoding vs. Encryption, Symmetric and Public-Key Encryption, and Their Trade-offs

14 Chapter 14: Data: Analysis Tools, Simulation, Storage, and Collection

14.1 Analyzing Data with Spreadsheets: Cleaning, Transforming, and Visualizing 14.2 Simulation and Modeling 14.3 Files, Databases, and Storage Requirements: Scale, Redundancy, and Backup 14.4 Collecting, Aggregating, and Generating Data: Public Data Sets, Surveys, Sensors, and Crowdsourcing

15 Chapter 15: Computing Systems: Hardware, Operating Systems, and Computing Environments

15.1 Hardware Components and the Fetch–Decode–Execute Cycle 15.2 Operating Systems, Software Components, and Resource Issues 15.3 Embedded Systems, the Internet of Things, and Types of Computing Systems 15.4 Local, Network, and Cloud Computing and Storage; How Binary Data Are Stored

16 Chapter 16: Networks, the Internet, the Web, and Cybersecurity

16.1 Network Types and Wired and Wireless Communication 16.2 Network Hardware and Layered Network Models (OSI and TCP/IP) 16.3 Network Performance: Bandwidth, Latency, Load, and Estimating Needs 16.4 How the Internet Works: Protocols, IP Addressing, DNS, URLs, and Reliability 16.5 The Web: HTTP, HTML and Markup Languages, Browsers, Servers, and Clients 16.6 Cybersecurity: The Five Pillars, Strong Passwords, Security Strategies, and Trade-offs

12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs

Key Takeaways Explain This Topic AI

Low-level languages (machine language and assembly) are close to the hardware, fast, and processor-specific; high-level languages are more readable, portable, and productive.

A compiler translates an entire high-level program into machine code (object code) before execution; an interpreter translates and runs the program statement by statement, or from bytecode, at run time.

Source code is the human-readable program a programmer writes; object code is the machine-level translation produced by a compiler, which a linker combines into an executable.

An IDE combines a code editor, build and run tools, a debugger, and project management in one application.

Context-aware editor features such as syntax highlighting, autocompletion, and error underlining speed up coding and reduce syntax errors, but they can hide details from beginners and slow down on large projects.

Last updated: September 2026

What this competency asks

Three small ETS competencies are clustered here:

IDEs: identify the components of IDEs, the benefits and drawbacks of using IDEs, and the costs and benefits of context editors .

Language levels: identify the characteristics of low- and high-level languages.

Translation: identify the differences between compilation and interpretation, and between source code and object code .

ETS's sample question on this topic asks for the role of a compiler. The answer: it translates a program written in an abstract, high-level language into a program with the same behavior expressed in machine code.

Low-level vs. high-level languages

Level Example Characteristics

Machine language 10110000 01100001 Binary instructions the CPU executes directly; specific to one processor family; very hard for people to read

Assembly language MOV AL, 61h Readable mnemonics that correspond almost one-to-one to machine instructions; translated by an assembler ; still processor-specific

High-level language Python, Java, C++, JavaScript Close to human language and mathematics; one statement becomes many machine instructions; portable across processors; must be compiled or interpreted

Block-based / very high level Scratch, Snap! Drag-and-drop blocks remove syntax errors; ideal for beginners

  • Characteristic Low-level High-level
  • Abstraction Low: registers and memory addresses High: variables, objects, procedures
  • Readability and productivity Low High
  • Portability Tied to one processor family Runs on many platforms after translation
  • Control over hardware Fine-grained Limited; the language handles details

Typical uses Device drivers, embedded firmware, performance-critical routines Applications, web, data analysis, teaching

Remember the ordering from Section 4.1: machine language is below assembly language.

Source code, object code, and the build process

Source code: the human-readable program text a programmer writes and edits ( grades.java , game.py ).

Object code: the machine-level (or intermediate) output of a compiler. It is not meant for people to read.

Linker: combines object files and library code into one executable .

Loader: the operating system component that places the executable in memory and starts it.

To change a program you need its source code. Companies that distribute only executables keep their source private, which is one reason open-source licenses (Section 3.1) require source availability.

Compilation vs. interpretation

Compiler Interpreter

When translation happens Before running, for the whole program During running, statement by statement (often via an intermediate form)

Output Object code, then an executable file No separate executable; the interpreter runs the program

Error reporting Syntax and type errors are reported before the program runs Errors appear when the offending line is reached

Execution speed Usually faster, because the work was done in advance Usually slower, because translation happens at run time

  • Distribution Share the executable (for a specific platform) Share the source; users need the interpreter
  • Development cycle Edit, compile, then run Edit and run immediately; convenient for experimenting

Many modern languages are hybrids . Java compiles source code to bytecode , which the Java Virtual Machine interprets or compiles "just in time" while the program runs. Python also compiles source to bytecode and runs it on its virtual machine. The distinction is still useful: a compiled workflow produces a standalone translation before execution, and an interpreted workflow translates as it executes.

Integrated development environments (IDEs)

An IDE bundles the tools of programming into one application. Examples include Visual Studio Code, IntelliJ IDEA, Eclipse, PyCharm, BlueJ, and Thonny.

  • Component What it does
  • Source code editor Editing, with syntax highlighting, auto-indentation, and code completion
  • Build and run tools Compile or interpret and run with one click; show output in a console
  • Debugger Breakpoints, stepping through code, watching variables, viewing the call stack (Section 10.2)
  • Project or file manager Organizes files, libraries, and settings
  • Error checking (linting) Flags syntax errors and suspicious code while you type
  • Version control integration Commit, branch, and review changes (Section 2.1)
  • Testing tools Run unit tests and show results
  • Designers (some IDEs) Drag-and-drop interface builders

Benefits: faster development, immediate error feedback, integrated debugging, easy navigation of large projects, and consistent formatting.

Drawbacks: a learning curve for the tool itself, heavy memory and processor use, possible licensing costs, and complexity that can overwhelm beginners. By automating builds, an IDE can also hide what compiling and running involve. Some teachers start novices in simpler editors, or in beginner IDEs such as BlueJ or Thonny, for this reason.

Context-aware editors

ETS also lists context editors . These are editors, often part of an IDE, that use the context of the code being written to assist the programmer: syntax highlighting, autocompletion of variable and method names, pop-up parameter hints, and errors underlined as you type.

  • Benefits Costs
  • Fewer syntax and spelling errors Suggestions can be wrong or distracting
  • Faster typing and API discovery Beginners may rely on autocompletion instead of learning syntax
  • Immediate feedback on mistakes More memory and processing, and slower on very large files
  • Easier navigation (jump to a definition) Setup and configuration effort

In a classroom, the right choice depends on the goal. Assistance helps students focus on logic, while a plainer editor can help them learn syntax precisely.