“Co-Dfns: A Data Parallel Compiler Hosted on the GPU § 2.1.4 Idiomatic APL”, 2019-11 ():
APL emphasizes functions over procedures. Functions can be composed together like mathematical formulas to express complex operations in a declarative style. This is in contrast to imperative programming where code is written as step-by-step procedures that explicitly mutate state. APL code leans heavily on functions as fundamental building blocks that transform data. These function blocks can be nested, combined, and abstracted into higher-order functions, enabling a very high-level declarative programming style.
…The APL design philosophy focuses on making common operations easy to express while relying on the composition of these basic building blocks for more complex or rarely used functionality. Harder operations are accomplished by combining the primitive functions in creative ways, rather than providing separate built-in functions for every potential use case. There are specific primitive functions for common data manipulations like reshape, transpose, and sorting, enabling clear and concise code for core programming tasks.
…APL code prioritizes brevity, building abstractions through the composition of smaller functional elements, and leveraging the rich syntax of mathematical notation. The terse syntax enables programmers to think and operate at a very high level of abstraction. Solutions can be expressed concisely in a notation style similar to mathematical formulas. The ability to capture complex operations with minimal notation allows the code itself to focus on higher level reasoning rather than implementation details.
…APL uses a rich set of special symbols to enable an extremely terse yet readable syntax. The use of special symbols allows fitting many operations into a single character. This results in APL code that is very dense and concise, while still maintaining readability due to its basis in mathematical notation. Much of the power of APL comes from the multifaceted symbols representing a wide range of operations. This allows APL to provide a lot of built-in functionality with very little syntactic overhead.
…APL aims to provide built-in operators for most common data manipulations, making it a very high-level language where programs can operate on a higher plane of abstraction. Rather than needing to specify iteration loops, conditionals, and other implementation details explicitly, APL code can focus on expressing the essential transformations at a higher level. Primitive functions encapsulate common operations so programmers do not have to think about lower-level mechanics.
…APL code often exploits implicit behavior in execution to minimize notational overhead. For example, loops are implicit in operations over arrays rather than needing explicit iteration syntax. This serves to reduce syntactic space, but programmers still expect the behavior to be predictable. There is a strong emphasis on implicit semantics having well-defined, consistent behavior even if not fully notated…APL makes extensive use of implicit looping constructs and other implied behaviors that are not explicitly notated in the code. For example, operations on arrays will implicitly loop across the elements without needing explicit iteration syntax…The notation leaves many details of execution implicit, yet APL programmers come to intuitively understand the implicit semantics and rely on them. The expected behavior is inherited through the community and culture of APL programmers over decades…Certain operations have inherent mathematical meanings and implicit behavior that experienced APL programmers understand intuitively. For example, reduction or scan operators work implicitly across array dimensions without looping constructs needing to be explicitly coded…Leaving repetitive boilerplate implicit enhances the power and terseness of APL, while retaining a readable style. The heavy use of implicit behavior places a greater burden on programmers to deeply understand the intrinsic semantics.
…APL intentionally avoided building up standard libraries of functions, instead keeping the core language small and focused on array primitives. The intent was to enable an environment where users could write their own operations crafted specifically for their use cases, rather than relying on pre-built libraries. The design philosophy emphasized minimalism and putting power into the core primitives rather than developing standard library packages. This forced creative composition of the built-in operators rather than reusing pre-fabricated functions from an expansive library. Unlike other languages that boast extensive standard libraries, APL deliberately provides a sparse set of primitive functions. The motivation was to enable users to think at a higher level, composing the core operations to create customized functionality.