Views: a way for pattern matching to cohabit with data abstraction
POPL '87 Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Why functional programming matters
The Computer Journal - Special issue on Lazy functional programming
The design and implementation of hierarchical software systems with reusable components
ACM Transactions on Software Engineering and Methodology (TOSEM)
FPCA '93 Proceedings of the conference on Functional programming languages and computer architecture
Subject-oriented programming: a critique of pure objects
OOPSLA '93 Proceedings of the eighth annual conference on Object-oriented programming systems, languages, and applications
Structuring Z specifications with views
ACM Transactions on Software Engineering and Methodology (TOSEM)
N degrees of separation: multi-dimensional separation of concerns
Proceedings of the 21st international conference on Software engineering
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
DITTO: automatic incrementalization of data structure invariant checks (in Java)
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
Bidirectionalization transformation based on automatic derivation of view complement functions
ICFP '07 Proceedings of the 12th ACM SIGPLAN international conference on Functional programming
Imperative self-adjusting computation
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Algorithms and Data Structures: The Basic Toolbox
Algorithms and Data Structures: The Basic Toolbox
Hi-index | 0.00 |
The separation of concerns has been a core idiom of software engineering for decades. In general, software can be decomposed properly only according to a single concern, other concerns crosscut the prevailing one. This problem is well known as "the tyranny of the dominant decomposition". Similarly, at the programming level, the choice of a representation drives the implementation of the algorithms. This article explores an alternative approach with no dominant representation. Instead, each algorithm is developed in its "natural" representation and a representation is converted into another one only when it is required. To support this approach, we designed a laziness framework for Java, that performs partial conversions and dynamic optimizations while preserving the execution soundness. Performance evaluations over graph theory examples demonstrates this approach provides a practicable alternative to a naive one.