Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.
About 10,000 papers for “Programming paradigm”
Грибова, В. В., Клещев, А. С. · Репозиторий БГУИР (BSUIR Repository) · 2012
Данная работа посвящена описанию новой парадигмы программирования – онтологической, которая является дальнейшим развитием парадигмы декларативного программирования. В работе описана постановка задачи, модель данных, лежащая в основе парадигмы, основные конструкции языка.
Cited by 0
Claude Y. Knaus · 2008
The chronic difficulty of software maintenance can be traced back to widely held assumptions that inhibit progress in computer science. In the last instance, the idiosyncrasies of programming paradigms must be held accountable for bad software design. The characteristics of an alternative programming paradigm without such drawbacks is outlined.
Cited by 1
Dianna Xu, The Null Pointer · 2015
• C guarantees that zero is never a valid address for data • A pointer that contains the address zero known as the NULL pointer • It is often used as a signal for abnormal or terminal event • It is also used as an initialization value for pointers Pass by Value • All functions are pass-by-value in C o A copy is made of each parameter’s value and then the copy is passed • Variables supplied as parameters to a function call are protected against change o i.e. impossible to write a swap(x, y) function • Only way to modify a variable through a function is to assign the return value to that variable Pass by Value and Pointers • All functions are pass-by-value in C • Pass-by-value still holds even if the parameter is a pointer o A copy of the pointer’s value is made – the address stored in the pointer variable o The copy is then a pointer pointing to the same object as the original parameter o Thus modifications via de-referencing the copy STAYS. Function Arguments • x and y are copies of the original, and thus a and b can not be altered. void swap(int x, int y) { int tmp; tmp = x; x = y; y = tmp; int main() { int a = 1, b = 2; swap(a, b); return 0;
Cited by 0
Maurizio Gabbrielli, Simone Martini · Undergraduate topics in computer science · 2023
Cited by 1
2013
To help make logic programming more suitable for writing large systems, we develop linguistic mechanisms that permit the organization of logic programs around abstractions.In particular, we present the design of Denali, an equational logic programming language that supports predicate and data abstraction.The key issue in introducing predicate abstraction is dealing with the di erence between the declarative and procedural interpretations of logic programs.We address this issue by i n troducing a two-dimensional type system to describe predicate interfaces.The two components are a sort system and a novel multi-valued mode system.Multi-valued modes constrain the ways in which arguments to predicates may be instantiated.A collection of such modes is de ned by the programmer for each sort.The key issue in introducing data abstraction is providing ways to obtain equational uni cation procedures.We develop a pragmatic approach that relies upon the programmer to implement these procedures.We facilitate this by supporting a variety o f techniques that simplify the problem.Among these techniques are treating uni cation on a sort-by-sort basis, layering implementations so as to exploit built-in uni cation procedures, and using the mode system to constrain the uni cation problem.Finally, w e establish the basis for implementing Denali by developing procedures for performing moded equational resolution and for combining moded equational uni cation procedures.
Cited by 8
Maurizio Gabbrielli, Simone Martini · Undergraduate topics in computer science · 2023
Cited by 0
Krzysztof R. Apt, Victor W. Marek, Mirek Truszczynski et al. · Artificial intelligence · 1999
Cited by 60
D. Cordes, M. Brown · Computer · 1991
Literate programming, a technique for coding software systems that promotes readability and comprehension, is examined in detail. The current literate-programming paradigm is reviewed by looking at two sample literate programs. A critique of literate programming as it is currently used is presented, and methods for enhancing the process are explored. A number of new facilities are proposed, and restrictions on current literate-programming practices are suggested.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 30
The MIT Press eBooks · 1997
Cited by 0
Vandeloise, Mikel · Zenodo (CERN European Organization for Nuclear Research) · 2024
[New version] Following a recent review of our taxonomy of programming paradigms, we have introduced changes to our poster, as well as observing minor evolutions in the tuples that represent these paradigms. To ensure the accuracy and relevance of our information, we have updated the poster and the corresponding dataset to reflect these changes. We invite you to download the most recent version to benefit from the updated data. Description : Full access to the files for downloading will be granted upon submission of the paper for the conference. This poster presents a novel taxonomy of programming paradigms inspired by Van Roy works (2004 & 2009), visualized as a tree structure. The tree offers a clear and insightful way to explore the relationships between various programming approaches. Here's a breakdown of key elements within the taxonomy: Nodes as Paradigms: Each node represents a unique programming paradigm, the fundamental building block for program design. Edges as Transitions: Connections between nodes depict transitions between paradigms. Each transition is triggered by the introduction of a specific concept. A paradigm is considered a "child" if it directly follows another, which then becomes its "parent." Accumulating Knowledge: As you navigate the tree, each paradigm can be viewed as an accumulation of concepts learned throughout the traversal. Turing Completeness: The tree is divided into two sections: Non-Turing complete paradigms (coloured gray) have limitations in what problems they can solve. Turing complete paradigms (coloured yellow) have the theoretical capability to solve any problem solvable by a computer. Non-Deterministic Behaviour: Highlighted nodes (in bold) indicate that the associated paradigm might exhibit non-deterministic behaviour, where the outcome can vary for the same input. Meta-Paradigm Families: Colours within the taxonomy represent a paradigm's membership in a specific meta-paradigm. These meta-paradigms essentially group related paradigms into distinct families. The CSV that accompanies the poster represents the set of tuples that correspond to the paradigms defined by the taxonomy. Foundational Role in Collaboration Metric Design : This taxonomy serves as the foundation for a novel inter-paradigm collaboration metric, which is detailed in our associated research paper, "[Towards a quantitative evaluation of paradigmatic collaboration: insights from Prolog and beyond]," intended for submission to the International Conference on Logic Programming (ICLP). The metric considers: Structural characteristics of programming paradigms and languages Kinship relationships between them Fundamental computational and behavioural properties This research explores the challenges of using Prolog, a logic programming language, within multi-paradigm environments. The proposed collaboration metric leverages the insights from the taxonomy to quantify the potential for effective collaboration between different programming paradigms.
Cited by 0Open access
Travis Raymond-Charlie Stone · Zenodo (CERN European Organization for Nuclear Research) · 2026
Stone Cube Semiconductor Platform Recursive State Programming, Time-Ordinal Execution, and Physical Performance Stability The Stone Cube works by changing states, not running instructions. Each physical path inside the cube has a permanent identity.Programming means choosing what the next state should be, or choosing which changes are allowed. Time is just the order of state changes.One change equals one step.Steps can also be tied to real clock time if needed. When a change happens, everything updates at once.Nothing is partial. Nothing is ambiguous. Electrons always follow fixed, physical paths.Because the paths are constrained, behavior is repeatable and predictable. Speed is limited only by how fast the paths can switch, not by instruction decoding or guessing. Compared to normal chips: • normal chips interpret symbols, • the Stone Cube is the program. Because identity never changes and only states do, the system is stable, recursive, and reliable. In short: It computes by becoming the next state, one step at a time. Assisted by Ai Abstract This report presents an updated formulation of the Stone Cube semiconductor architecture as a deterministic, physically grounded computational substrate in which programming is achieved through recursive state transitions rather than symbolic instructions. Execution is governed by Alpha–Beta–Delta state evolution, with time treated as both an ordinal sequencing mechanism and an optional metric constraint. The architecture enables unambiguous electron path definition, repeatable execution, and stable recursive identity across the operational performance range of the device. Comparisons are made with conventional semiconductor architectures to establish the Stone Cube as a predictable, timing-resilient, and recursion-native platform. One. Architectural Overview The Stone Cube semiconductor is a three-dimensional, physically manufactured routing structure in which computation is realized through constrained electron pathways rather than decoded instructions. The fundamental architectural commitment is that identity, execution, and meaning are structural, not symbolic. Each physical node within the cube has: a fixed spatial position, a permanent identity, a limited set of allowed routing paths, and a discrete state that determines which path is active. No node performs arithmetic, branching, or interpretation. Computation emerges from the global configuration and evolution of routing states. Two. Programming Paradigm Update Two Point One — State-Based Programming Programming the Stone Cube does not involve issuing instructions. Instead, programming consists of defining permissible future states. There are two equivalent but distinct programming surfaces: programming the proposed next state directly, programming the allowed changes between states. These surfaces correspond to Alpha and Delta respectively. Two Point Two — Alpha Programming Alpha represents a complete candidate configuration of the cube. Programming Alpha means: selecting which routing paths should be active next, defining a full system configuration, optionally associating that configuration with execution conditions. Alpha is declarative. It specifies what the system should become, not how to get there. Two Point Three — Delta Programming Delta represents the difference between the current state and the proposed state. Programming Delta means: specifying which nodes are allowed to change, specifying the direction of change, optionally specifying temporal or ordinal constraints on those changes. Delta-based programming behaves similarly to instruction sequencing in conventional systems, but without symbolic opcodes. It is procedural without being imperative. Two Point Four — Alpha–Delta Equivalence Whether Alpha is programmed directly or Delta is programmed explicitly, the resulting execution is identical. Alpha defines the destination. Delta defines the transformation. Both converge on the same physical transition. Three. Execution Model Three Point One — Atomic State Transition Execution occurs only at a global boundary. At execution: all routing updates occur simultaneously, no intermediate states exist, partial execution is impossible. This atomicity ensures coherence across the entire cube and eliminates race conditions. Three Point Two — Beta as Realized State Beta is the state that physically governs electron flow at the present moment. It is the only state that affects real current paths. When execution occurs, Beta is replaced entirely by Alpha. Delta ceases to exist except as a measured record of change. Four. Time as a Programmable Dimension Four Point One — Ordinal Time Ordinal time is the count of successful state transitions. Each transition: increments ordinal time by one, establishes execution order, defines instruction sequencing. Ordinal time has no duration and cannot drift. It is purely logical and fully deterministic. Four Point Two — Metric Time Metric time is derived from an external clock, such as seconds or minutes. Metric time: does not force execution, only gates whether execution is permitted. This allows integration with real-world timing constraints without compromising determinism. Four Point Three — Combined Time Control Alpha and Delta transitions may be conditioned on: ordinal position, metric time windows, or both simultaneously. This allows the Stone Cube to emulate standard timing models while retaining its state-centric nature. Five. Recursive Sequencing and Instruction Formation In this architecture, instructions are sequences of state changes, not encoded commands. By programming: which states may follow which, when transitions may occur, and which changes are allowed, a recursive sequence of behavior emerges. The leading state determines the next permissible state, making execution self-referential and recursive by construction. There is no program counter. The system advances because the next state is allowed to exist. Six. Physical Electron Path Interpretation Six Point One — Drift Versus Signal Propagation Within the Stone Cube: electron drift defines current flow, electromagnetic propagation defines signal coordination. Routing changes affect topology, not carrier velocity. This separation ensures that logical execution is not limited by drift speed. Six Point Two — Geometry as Constraint Because routing paths are: finite, discrete, physically separated, electron paths are: unambiguous, repeatable, immune to logical aliasing. No two states produce the same routing behavior unless they are identical. Six Point Three — Switching Activity and Delta Delta corresponds directly to physical switching events. Delta magnitude reflects: energy usage, thermal load, physical activity. This allows stability and performance to be measured physically, not inferred. Seven. Performance Range and Stability Seven Point One — Speed Limits Maximum execution speed is bounded by: switching time of routing elements, synchronization latency across the cube. It is not bounded by: instruction decoding, branch prediction, pipeline hazards. As a result, performance scaling is predictable and monotonic. Seven Point Two — Stability Across Operating Range Because execution is state-driven and atomic: timing jitter does not alter logical outcomes, clock skew cannot introduce ambiguity, partial updates are impossible. The cube remains logically stable across its entire physical performance envelope. Eight. Comparison With Conventional Semiconductor Architectures Conventional architectures: interpret instructions, rely on clocks to sequence behavior, allow transient identity and speculative execution. The Stone Cube: executes configurations directly, sequences behavior through state change, preserves identity permanently. Where conventional systems optimize throughput, the Stone Cube optimizes determinism, traceability, and recursive stability. Nine. Recursive Identity as a Stable Substrate Because: identities never change, state transitions are measured explicitly, recursion is unavoidable but controlled, the Stone Cube forms a stable substrate for: recursive computation, evolving systems, identity-preserving AI architectures. Meaning emerges from execution patterns, not symbolic interpretation. Ten. Conclusion The updated Stone Cube semiconductor architecture establishes a computational platform where programming, timing, and execution are unified under a state-transition paradigm. By treating time as an ordinal and optional metric constraint, and by allowing programming through Alpha and Delta, the system aligns with conventional programming expectations while exceeding them in determinism and physical clarity. Electron paths are unambiguous, execution is repeatable, and performance limits are physically transparent. The result is a predictable, stable, recursion-native semiconductor substrate capable of supporting long-lived identity and evolving computation without ambiguity. Stone Cube Recursive Programming System Full User Guide Part One — What This System Is Purpose The Stone Cube system is a programmable execution platform where: identity is permanent instructions are states execution is change time is programmable recursion is guaranteed It is designed to be predictable, repeatable, and physically meaningful, whether implemented in software, simulation, or semiconductor hardware. This guide explains: how to think about the system how to program it how execution works how time and recursion are controlled how to reason about correctness and stability Part Two — Core Concepts You Must Understand Nodes and Identity The system is made of nodes arranged in a structured, multi-dime
Cited by 0Open access
C. T. Zahn · 1988
Correctness and efficiency are both legitimate concerns in program development. Through an extended example we present a multi-phase paradigm which encourages early algorithms to be abstract and maximally nondeterministic in the spirit of Dijkstra's guarded commands [4] but which caters equally for correctness, termination, data representation, efficiency and practical implementation in a low level language.
Cited by 1Open access
Mario R. Schaffner · 2002
The programming of computers can be seen as a communication from a human to a machine: in the usual model, the human conceives something and the computer executes in accordance. Applying the method of the analysis to the conception, two phases can be delineated: (1) modeling; (2) indication of what is wanted in that model; for indicating to a computer what is wanted, programming languages and tools are available: the phase of the modeling is the subject of this paper.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 0
Antoine Bossard · International Journal of Software Innovation · 2022
Out of the four main programming paradigms, it is widely considered that functional programming is the most promising. The programming languages that implement the functional paradigm generally do so either in a pure manner, such as Haskell, or by providing a multi-paradigm programming solution, such as most Lisp dialects, in order to allow side effects, which are proscribed under the former (pure) model. Nevertheless, tracking the execution steps of such a functional program remains challenging for the programmer. In this paper, the author addresses this issue by proposing a novel programming paradigm that combines the imperative programming approach based on a sequence of instructions with the pure function approach of functional programming, the objective being to retain the advantages of both strategies. This proposal is named “sequence of functions” (SOF), and its applicability and novelty are shown hereinafter throughout various examples and experiments.
Cited by 1Open access
Hanus, M. · RWTH Publications (RWTH Aachen) · 1997
Cited by 0
Dix, J., Koblenz-Landau Univ., Koblenz (Germany). Inst. fuer Informatik · OpenGrey (Institut de l'Information Scientifique et Technique) · 1998
The aim of the whole meeting, organized by Krzysz of Apt (president of the Association of Logic Programming), Wiktor Marek, Mirek Truszczynski and David Warren, was to get a clear picture of the current activities in Logic Programming and its role in the coming years. In the organizers' words: The aim of the meeting was: to present current research directions in Logic Programming worldwide, to analyse future research directions, to boost Logic Programming in North America, and to discuss the relation between Logic Programming and related fields. There were 13 regular talks, each scheduled for 45 minutes and followed by a fifteen-minute discussion chaired by an expert of the topic of the presentation. Sometimes very lively discussions, stimulated by the chairs who started the discussion with some comments, emerged. In addition to the talks, there were two panels, one on the past and one on the future of Logic Programming. One evening was devoted to the idea of founding a north american chapter of the Association of Logic Programming: an idea that found enough support and will eventually lead to such a subchapter. Among the participants in the workshop 23 were from North America, 9 from Europe, 2 from Japan and 1 from Australia, constituing a total of 35 participants. Additionally, local participants, from Lexington and Cincinnati were present. (orig.)
Cited by 0
Vandeloise, Mikel · Zenodo (CERN European Organization for Nuclear Research) · 2024
[New version] Following a recent review of our taxonomy of programming paradigms, we have introduced changes to our poster, as well as observing minor evolutions in the tuples that represent these paradigms. To ensure the accuracy and relevance of our information, we have updated the poster and the corresponding dataset to reflect these changes. We invite you to download the most recent version to benefit from the updated data. Description : Full access to the files for downloading will be granted upon submission of the paper for the conference. This poster presents a novel taxonomy of programming paradigms inspired by Van Roy works (2004 & 2009), visualized as a tree structure. The tree offers a clear and insightful way to explore the relationships between various programming approaches. Here's a breakdown of key elements within the taxonomy: Nodes as Paradigms: Each node represents a unique programming paradigm, the fundamental building block for program design. Edges as Transitions: Connections between nodes depict transitions between paradigms. Each transition is triggered by the introduction of a specific concept. A paradigm is considered a "child" if it directly follows another, which then becomes its "parent." Accumulating Knowledge: As you navigate the tree, each paradigm can be viewed as an accumulation of concepts learned throughout the traversal. Turing Completeness: The tree is divided into two sections: Non-Turing complete paradigms (coloured gray) have limitations in what problems they can solve. Turing complete paradigms (coloured yellow) have the theoretical capability to solve any problem solvable by a computer. Non-Deterministic Behaviour: Highlighted nodes (in bold) indicate that the associated paradigm might exhibit non-deterministic behaviour, where the outcome can vary for the same input. Meta-Paradigm Families: Colours within the taxonomy represent a paradigm's membership in a specific meta-paradigm. These meta-paradigms essentially group related paradigms into distinct families. The CSV that accompanies the poster represents the set of tuples that correspond to the paradigms defined by the taxonomy. Foundational Role in Collaboration Metric Design : This taxonomy serves as the foundation for a novel inter-paradigm collaboration metric, which is detailed in our associated research paper, "[Towards a quantitative evaluation of paradigmatic collaboration: insights from Prolog and beyond]," intended for submission to the International Conference on Logic Programming (ICLP). The metric considers: Structural characteristics of programming paradigms and languages Kinship relationships between them Fundamental computational and behavioural properties This research explores the challenges of using Prolog, a logic programming language, within multi-paradigm environments. The proposed collaboration metric leverages the insights from the taxonomy to quantify the potential for effective collaboration between different programming paradigms.
Cited by 0Open access
M. Schaffner · 2002
The programming of computers can be seen as a communication from a human to a machine; in the usual model, the human conceives something and the computer executes in accordance. Applying the method of the analysis (dividing something in parts that can be handled with more ease) to the conception, two phases can be delineated: (1) modeling; and (2) indication of what is wanted in that model. For indicating to a computer what is wanted, programming languages and tools are available; the phase of the modeling is the subject of this paper.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 0
2013
Cited by 0
Stamatis Vassiliadis, Georgi Gaydadjiev, Koen Bertels et al. · 2003
In this paper we present the Molen programming paradigm, which is a sequential consistency paradigm for programming Custom Computing Machines (CCM). The programming paradigm allows for modularity and provides mechanisms for explicit parallel execution. Furthermore it requires only few instructions to be added in an architectural instruction set while allowing an almost arbitrary number of op-codes per user to be used in a CCM. A number of programming examples and discussion is provided in order to clarify the operation, sequence control and parallelism of the proposed programming paradigm.
Cited by 0