Hardwired control
Microprogrammed logic arrays
Writable control store
Automatic synthesis
Formal models
Simulation
Diagnostics
Error-checking
Redundant design
Test generation
Firmware engineering
Languages and compilers
Machine-Independent microcode generation
Optimization
Verification
Direct data manipulation
Firmware support of operating systems/instruction sets
Instruction set interpretation
Peripheral control
Special-purpose
Calculator
Parallel
Pipeline
Simulation
Verification
Worst-case analysis
Diagnostics
Error-checking
Redundant design
Test generation
Algorithms
Cost/performance
Dynamic memory (DRAM)
Read-only memory (ROM)
Static memory (SRAM)
Associative memories
Cache memories
Interleaved memories
Mass storage (e.g., magnetic, optical, RAID)
Primary memory
Sequential-access memory
Shared memory
Virtual memory
Formal models
Simulation
Worst-case analysis
Diagnostics
Error-checking
Redundant design
Test generation
Processors
Receivers (e.g., voice, data. image)
Transmitters
Channels and controllers
Data terminals and printers
Image display
Voice
Asynchronous/synchronous operation
Fiber optics
Interfaces
Parallel I/O
Physical structures (e.g., backplanes, cables, chip carriers)
Topology (e.g. bus, point-to-point)
Formal models
Simulation
Verification
Worst-case analysis
Built-in tests
Diagnostics
Error-checking
Hardware reliability
Redundant design
Test generation
Arithmetic and logic units
Control design
Data-path design
Memory design
Styles (e.g., parallel, pipelined, special-purpose)
Automatic synthesis
Hardware description languages
Optimization
Simulation
Verification
Built-in tests
Error-checking
Redundant design
Test generation
Testability
Cellular arrays and automata
Combinational logic
Logic arrays
Memory control and access
Memory used as logic
Parallel circuits
Sequential circuits
Built-in tests
Error-checking
Redundant design
Test generation
Testability
Automatic synthesis
Hardware description languages
Optimization
Simulation
Switching theory
Verification
Advanced technologies
Algorithms implemented in hardware
Gate arrays
Input/Output circuits
Memory technologies
Microprocessors and microcomputers
Standard cells
VLSI (very large scale integration)
Graphics
Layout
Placement and routing
Simulation
Verification
Built-in tests
Error-checking
Redundant design
Test generation
Testability
Design management
Hardware/software interfaces
Instruction set design (e.g., RISC, CISC, VLIW)
System architectures
Systems specification methodology
Multiple-instruction-stream, single-data-stream processors (MISD)
Pipeline processors
Risc/CISC, VLIW architectures
Single-instruction-stream, single-data-stream processors (SISD)
Von Neumann architectures
Array and vector processors
Associative processors
Connection machines
Interconnection architectures (e.g., common bus, multiport memory, crossbar
switch)
Multiple-instruction-stream, multiple-data-stream processors (MIMD)
Parallel processors
Pipeline processors
Single-instruction-stream, multilpe-data-stream processors (SIMD)
Adaptable architectures
Analog computers
Capability architectures
Cellular architecture (e.g., mobile)
Data-flow architectures
High-level language architectures
Neural nets
Pipeline processors
Stack-oriented processors
Distributed architectures
Mobile processors
Analog computers
Hybrid systems
Data communications
Open System Interconnection reference model (OSI)
Security and protection (e.g., firewalls)
Asynchronous Transfer Mode (ATM)
Centralized networks
Circuit switching networks
Distributed networks
ISDN (Integrated Services Digital Network)
Frame relay networks Network communications
Network topology
Packet-switching networks
Store and forward networks
Wireless communication
Aplications (SMTP, FTP, etc.)
Protocol architecture (OSI model)
Protocol verification
Routing protocols
Network management
Network monitoring
Public networks
Client/server
Distributed applications
Distributed databases
Network operating systems
Access schemes
Buses
Ethernet (e.g., CSMA/CD)
High-speed (e.g., FDDI, fiber channel, ATM)
Internet (e.g., TCP/IP)
Token rings
Routers
Standards (e.g., TCP/IP)
Microprocessor/microcomputer applications
Process control systems
Real-time and embedded systems
Signal processing systems
Smartcards
Design studies
Fault tolerance
Measurement techniques
Modeling techniques
Performance attributes
Reliability, availability, and serviceability
Distributed programming
Parallel programming
Protection mechanisms
Standards
Elicitation methods (e.g., rapid prototyping, interviews, JAD)
Languages
Methodologies (e.g., object-oriented, structured)
Tools
Computer-aided software engineering (CASE)
Decision tables
Evolutionary prototyping
Flow charts
Modules and interfaces
Object-oriented design methods
Petri nets
Programmer workbench
Software libraries
State diagrams
Structured programming
Top-down programming
User interfaces
Object-oriented programming
Pretty printers
Program editors
Reentrant code
Standards
Structured programming
Top-down programming
Assertion checkers
Class invariants
Correctness proofs
Formal methods
Model checking
Programming by contract
Reliability
Statistical methods
Validation
Code inspections and walk-troughs
Debugging aids
Diagnostics
Distributed debugging
Dumps
Error handling and recovery
Monitors
Symbolic execution
Testing tools (e.g., data generators, coverage testing)
Tracing
Graphical environments
Integrated environments
Interactive environments
Programmer workbench
Corrections
Documentation
Enhancement
Extensibility
Portability
Restructuring, reverse engineering, and reengineering
Version control
Complexity measures
Performance measures
Process metrics
Product metrics
Software science
Copyrights
Cost estimation
Life cycle
Productivity
Programming teams
Software configuration management (e.g., CMM, ISO, PSP)
Software quality assurance (SQA)
Time estimation
Methodologies
Representation
Data abstraction
Domain-specific architectures
Information hiding
Languages (e.g., description, interconnection, definition)
Patterns (e.g., client/server, pipeline, blackboard)
Data mapping
Distributed objects
Interface definition languages
Domain engineering
Reusable libraries
Reuse models
Rapid prototyping
Reusable software
Standards
Semantics
Syntax
Applicative (functional) languages
Concurrent, distributed, and parallel languages
Constraint and logic languages
Data-flow languages
Design languages
Extensible languages
Macro and assembly languages
Microprogramming languages
Multiparadigm languages
Nondeterministic languages
Nonprocedural languages
Object-oriented languages
Specialized application languages
Very high-level languages
Abstract data types
Classes and objects
Concurrent programming structures
Constraints
Control structures
Coroutines
Date types and structures
Dynamic storage management
Frameworks
Inheritance
Input/Output
Modules, packages
Patterns
Polymorphism
Procedures, functions, and subroutines
Recursion
Code generation
Compilers
Debuggers
Internal compilers
Interpreters
Optimization
Parsing
Preprocessors
Pretargetable compilers
Run-time environments
Translator writing systems and compiler generators
Concurrency
Deadlocks
Multiprocessing/multiprogramming
Mutual exclusion
Scheduling
Synchronization
Threads
Allocation/deallocation strategies
Distributed memories
Garbage collection
Main memory
Secondary storage
Segmentation
Storage hierarchies
Swapping
Virtual memory
Access methods
Directory structures
Distributed file systems
File organization
Maintenance
Buffering
Input/Output
Message sending
Network communication
Terminal management
Backup procedures
Checkpoint/restart
Fault-tolerance
Verification
Access controls
Authentication
Cryptographic controls
Information flow controls
Invasive software (e.g., viruses, worms, Trojan horses)
Security kernels
Verification
Batch processing systems
Distributed systems
Hierarchical design
Interactive systems
Real-time and embedded systems
Measurements
Modeling and prediction
Monitors
Operational analysis
Queueing theory
Simulation
Stochastic analysis
Command and control languages
Linkers
Loaders
Window managers
Software psychology
Arrays
Distributed data structures
Graphs and networks
Lists, stacks, and queues
Records
Tables
Trees
Composite structures
Contiguous representations
Hash-table representations
Linked representations
Object representations
Primitive data items
Code breaking
Data encryption standard (DES)
Public key cryptosystems
Standards (e.g., DES, PGP, RSA)
Data compaction and compression
Error control codes
Formal models of communication
Nonsecret encoding schemes
Backup/recovery
Optimization
Organization/structure
Sorting/searching
Automate (e.g.. finite. pushdown, resource-bounded)
Bounded-action devices (e.g., Turing machines, random access machines)
Computability theory
Relations among models
Self-modifying machines (e.g., neural networks)
Unbounded-action devices (e.g., cellular automata, circuits, networks of
machines)
Alternation and nondeterminism
Interactive and reactive computation
Online computation
Parallelism and concurrency
Probabilistic computation
Relations among modes
Relativized computation
Complexity hierarchies
Machine-independent complexity
Reducibility and completeness
Relations among complexity classes
Relations among complexity measures
Computation of transforms (e.g., Fast Fourier transform)
Computations in finite fields
Computations on matrices
Computations on polynomials
Number-theoretic computations (e.g., factoring, primality testing)
Complexity of proof procedures
Computations on discrete structures
Geometrical problems and computations
Pattern matching
Routing and layout
Sequencing and scheduling
Sorting and searching
Assertions
Invariants
Logics of programs
Mechanical verification
Pre- and post-conditions
Specification techniques
Algebraic approaches to semantics
Denotational semantics
Operational semantics
Partial evaluation
Process models
Program analysis
Control primitives
Functional constructs
Object-oriented constructs
Program and recursion schemes
Type structure
Category theory
Philosophical issues on logic and computer science
Computability theory
Computational logic
Lambda calculus and related systems
Logic and constraint programming
Mechanical theorem proving
Modal logic
Model theory
Proof theory
Recursive function theory
Set theory
Temporal logic
Decision problems
Grammar types (e.g., context-free. context-sensitive)
Parallel rewriting systems (e.g., developmental systems, L-systems)
Parsing
Thue systems
Algebraic language theory
Classes defined by grammars or automata (e.g., context-free languages,
regular sets, recursive sets)
Classes defined by resource-bounded automata
Decision problems
Operations on languages
Computer arithmetic
Conditioning (and ill-conditioning)
Error analysis
Interval arithmetic
Multiple precision arithmetic
Numerical algorithms
Parallel algorithms
Stability (and instability)
Difference formulas
Extrapolation
Interpolation formulas
Smoothing
Spline and piecewise polynomial interpolation
Approximation of surfaces and contours
Chebyshev approximation and theory
Elementary function approximation
Fast Fourier transforms (FFT)
Least squares approximation
Linear approximation
Minimax approximation and algorithms
Nonlinear approximation
Rational approximation
Special function approximations
Spline and piecewise polynomial approximation
Wavelets and fractals
Conditioning
Determinants
Eigenvalues and eigenvectors (direct and iterative methods)
Error analysis
Linear systems (direct and iterative methods)
Matrix inversion
Pseudoinverses
Singular value decomposition
Sparse, structured, and very large systems (direct and iterative methods)
Adaptive and iterative quadrature
Automatic differentiation
Equal interval integration
Error analysis
Finite difference methods
Gaussian quadrature
Iterative methods
Multidimensional (multiple) quadrature
Continuation (homotopy) methods
Convergence
Error analysis
Iterative methods
Polynomials, methods for
Systems of equations
Constrained optimization
Convex programming
Global optimization
Gradient methods
Integer programming
Least squares methods
Linear programming
Nonlinear programming
Quadratic programming methods
Simulated annealing
Stochastic programming
Unconstrained optimization
Boundary value problems
Chaotic systems
Convergence and stability
Differential-algebraic equations
Error analysis
Finit difference methos
Initial value problems
Multistep and multivalue methods
One-step (single step) methods
Stiff equations
Domain decomposition methods
Elliptic equations|
Finite difference methods
Finite element methods
Finite volume methods
Hyperbolic equations
Inverse problems
Iterative solution techniques
Method of lines
Multigrid and multilevel methods
Parabolic equations
Spectral methods
Delay equations
Fredholm equations
Integro-differential equations
Volterra equations
Combinatorial algorithms
Counting problems
Generating functions
Permutations and combinations
Recurrences and difference equations
Graph algorithms
Graph labeling
Hypergraphs
Network problems
Path and circuit problems
Trees
Contingency table analysis
Correlation and regression analysis
Distribution functions
Experimental design
Markov processes
Multivariate statistics
Nonparametric statistics
Probabilistic algorithms (including Monte Carlo)
Queueing theory
Random number generation
Reliability and life testing
Renewal theory
Robust regression
Statistical computing
Statistical software
Stochastic processes
Survival analysis
Time series analysis
Algorithm design and analysis
Certification and testing
Documentation
Efficiency
Parallel and vector implementations
Portability
Reliability and robustness
User interfaces
Verification
Queueing theory
General systems theory
Information theory
Value of information
Human factors
Human information processing
Software psychology
Security, integrity, and protection
Data models
Normal forms
Schema and subschema
Access methods
Deadlock avoidance
Recovery and restart
Date description languages (DDL)
Date manipulation languages (DML)
Database (persistent) programming languages
Query languages
Report writers
Concurrency
Distributed databases
Multimedia databases
Object-oriented databases
Parallel databases
Query processing
Relational databases
Rule-based databases
Textual databases
Transaction processing
Data translation
Program translation
Data dictionary/directory
Data warehouse and repository
Logging and recovery
Security, integrity, and protection
Data mining
Image databases
Scientific databases
Spatial databases and GIS
Statistical databases
Abstracting methods
Dictionaries
Indexing methods
Linguistic processing
Thesauruses
File organization
Record classification
Clustering
Data mining
Information filtering
Query formulation
Relevance feedback
Retrieval models
Search process
Selection process
Currant awareness systems (selective dissemination of information SDI)|
Distributed systems
Information networks
Performance evaluation (efficiency and effectiveness)
Question-answering (fact retrieval) systems
User profiles and alert services
Commercial services
Data bank sharing
Web-based services
Large text archives
Collection
Dissemination
Standards
Systems issues
User issues
Desktop publishing
Equipment
Groupware
Spreadsheets
Time management (e.g., calendars, schedules)
Word processing
Workflow management
Decision support (e.g., MIS)
Logistics
Bulletin boards
Computer conferencing, teleconferencing and videoconferencing
Electronic mail
Information browsers
Videotex
World Wide Web
Animations
Artificial, augmented, and virtual realities
Audio input/output
Evaluation/methodology
Hypertext navigation and maps
Video (e.g., tape, disk, DVI)
Auditory (non-speech) feedback
Benchmarking
Ergonomics
Evaluation/methodology
Graphic user interfaces (GUI)
Haptic I/O
Input devices and strategies (e.g., mouse, touchscreen)
Interaction styles (e.g., commands, menus, forms, direct manipulation)
Natural language
Prototyping
Screen design (e.g., text, graphics, color)
Standardization
Style guides
Theory and methods
Training, help, and documentation
User-centered design
User interface management systems (UIMS)
Voice I/O
Windowing systems
Asynchronous interaction
Collaborative computing
Computer-supported cooperative work
Evaluation/methodology
Organizational design
Synchronous interaction
Theory and models
Web-based interaction
Architectures
Navigation
Theory
User issues
Methodologies and techniques
Modeling
Signal analysis, synthesis, and processing
Systems
Representations (general and polynomial)
Simplification of expressions
Algebraic algorithms
Analysis of algorithms
Nonalgebraic algorithms
Evaluation strategies
Nonprocedural languages
Special-purpose algebraic systems
Special-purpose hardware
Substitution mechanisms
Cognitive simulation
Philosophical foundations
Cartography
Games
Industrial automation
Law
Medicine and science
Natural language interfaces
Office automation
Automatic analysis of algorithms
Program modification
Program synthesis
Program transformation
Program verification
Answer/reason extraction
Constraint satisfaction
Deduction (e.g., natural, rule-based)
Inference engines
Logic programming
Mathematical induction
Metatheory
Nonmonotonic reasoning and belief revision
Resolution
Uncertainty, fuzzy, and probabilistic reasoning
Frames and scripts
Modal logic
Predicate logic
Relation systems
Representation languages
Representations (procedural and rule-based)
Semantic networks
Temporal logic
Expert system tools and techniques
Analogies
Concept learning
Connectionism and neural nets
Data mining
Induction
Knowledge acquisition
Language acquisition
Parameter learning
Discourse
Language generation
Language models
Language parsing and understanding
Machine translation
Speech recognition and synthesis
Text analysis
Backtracking
Control theory
Dynamic programming
Graph and tree search strategies
Heuristic methods
Plan execution, formation, and generation
Scheduling
Autonomous vehicles
Commercial robots and applications
Kinematics and dynamics
Manipulators
Operator interfaces
Propelling mechanisms
Sensors
Workcell organization and planning
3D/stereo scene analysis
Architecture and control structures
Intensity, color, photometry, and thresholding
Modeling and recovery of physical attributes
Motion
Perceptual reasoning
Representations, data structures, and transforms
Shape
Texture
Video analysis
Coherence and coordination
Intelligent agents
Languages and structures
Multiagent systems
Graphics processors
Hardcopy devices
Input devices
Parallel processing
Raster display devices
Storage devices
Three-dimensional displays
Vector display devices
Distributed/network graphics
Remote systems
Stand-alone systems
Antialiasing
Bitmap and framebuffer operations
Digitizing and scanning
Display algorithms
Line and curve generation
Viewing algorithms
Application packages
Device drivers
Graphics editors
Graphics packages
Meta files
Paint systems
Picture description languages
Software support
Virtual device interfaces
Boundary representations
Constructive solid geometry (CSG)
Curve, surface, solid, and object representations
Geometric algorithms, languages, and systems
Hierarchy and geometric transformations
Modeling packages
Object hierarchies
Physically based modeling
Splines
Device independence
Ergonomics
Graphics date structures and date types
Interaction techniques
Languages
Standards (e.g., GKS, PHIGS, VDI, CGM, IGES)
Animation
Color, shading, shadowing, and texture
Fractals
Hidden line/surface removal
Radiosity
Raytracing
Virtual reality
Visible line/surface algorithms
Image displays
Image processing software
Camera calibration
Imaging geometry
Quantization
Radiometry
Reflectance
Sampling
Scanning
Approximate methods
Exact coding
Filtering
Geometric correction
Grayscale manipulation
Registration
Sharpening and deblurring
Smoothing
Inverse filtering
Kalman filtering
Pseudoinverse restoration
Wiener filtering
Series expansion methods
Summation methods
Transform methods
Edge and feature detection
Pixel classification
Region growing, partitioning
Relaxation
Feature representation
Invariants
Moments
Projections
Size and shape
Texture
Color
Depth cues
Motion
Object recognition
Photometry
Range data
Sensor fusion
Shading
Shape
Stereo
Surface fitting
Time-varying imagery
Tracking
Hierarchical
Morphological
Multidimensional
Statistical
Volumetric
Deterministic
Fuzzy set
Geometric
Neural nets
Statistical
Structural
Classifier design and evaluation
Feature evaluation and selection
Pattern analysis
Algorithms
Similarity measures
Computer vision
Signal processing
Text processing
Waveform analysis
Interactive systems
Special architectures
Model classification
Systems theory
Types of simulation (continuous and discrete)
Modeling methodologies
Environments
Animation
Combined
Discrete event
Distributed
Gaming
Monte Carlo
Parallel
Visual
Document management
Languages
Spelling
Version control
Desktop publishing
Format and notation
Hypertext/hypermedia
Index generation
Languages and systems
Markup languages
Multi/mixed media
Photocompositon/typesetting
Scripting languages
Standards (e.g., CALS, ODA, SGML)
Document analysis
Graphics recognition and interpretation
Optical character recognition (OCR)
Scanning
Business
Education
Financial (e.g., ERTS)
Government
Law
Manufacturing
Marketing
Military
Aerospace
Archeology
Astronomy
Chemistry
Earth and atmospheric sciences
Electronics
Engineering
Mathematics and statistics
Physics
Biology and genetics
Health
Medical information systems
Economics
Psychology
Sociology
Architecture
Arts, fine and performing
Fine arts
Language translation
Linguistics
Literature
Music
Performing arts (e.g., dance, music)
Computer-aided design (CAD)
Computer-aided manufacturing (CAM)
Command and control
Consumer products
Industrial control
Military
Process control
Publishing
Real time
Markets
Standards
Statistics
Suppliers
Hardware
People
Software
Systems
Theory
Collaborative learning
Computer-assisted instruction (CAI)
Computer-managed instruction (CMI)
Distance learning
Accreditation
Computer science education
Curriculum
Information systems education
Literacy
Self-assessment
Accreditation
Computer Literacy
Abuse and crime involving computers
Computer-related health issues
Ethics
Human safety
Intellectual property rights
Privacy
Regulation
Transborder date flow
Use/abuse of power
Abuse and crime involving computers
Assistive technologies for persons with disabilities
Employment
Handicapped persons/special needs
Automation
Computer-supported collaborative work
Employment
Reengineering
Cybercash, digital cash
Distributed commercial transactions
Electronic data interchange (EDI)
Intellectual property
Payment schemes
Security
Copyrights
Licensing
Patents
Proprietary rights
Trade secrets
Censorship
Regulation
Taxation
Contracts
Hardware patents
Economics
Livecycle
Management techniques (e.g., PERT/CPM)
Staffing
Strategic information systems planning
Systems analysis and design
Systems development
Training
Benchmarks
Computer selection
Computing equipment management
Performance and usage measurement
Pricing and resource allocation
Software development
Software maintenance
Software process
Software selection
Centralization/decentralization
Management audit
Quality assurance
Authentication
Insurance
Invasive software (e.g., viruses, worms, Trojan horses)
Physical security
Unauthorized access (e.g., hacking, phreaking)
Insurance
Security
Codes of ethics
Codes of good practice
Ethical dilemmas
Codes of good practice
Ethics
Biographies/autobiographies
Conference proceedings
General literary works (e.g., fiction, plays)
In the library of the Department of Computer Science, Utrecht University, a variant of the classification scheme of Computing Reviews is used. Note that there are some significant differences with the current CR-scheme (the ACM Computing Classification System (1998)).Below, you find the scheme that is used in the departments library.
The main different to the ACM system is that the A-category of the ACM-scheme is the K-category here, and all other categories has moved one letter in the alphabet. This is for historical reasons. In addition, the scheme carries some terms from previous versions of the CR-scheme, and a few codes that were added locally. Some Miscellaneous categories were removed: books for these categories are instead usually placed in the `.0' category.
The ACM Computing Classification System is copyrighted 1998 by the Association for Computing Machinery, Inc.