[Paper Review] Extending Object-Oriented Languages by Declarative Specifications of Complex Objects using Answer-Set Programming

Johannes Oetsch, Jörg Pührer+1 more|arXiv (Cornell University)|Dec 5, 2011

Logic, Reasoning, and Knowledge19 references3 citations

TL;DR

This paper proposes integrating Answer-Set Programming (ASP) into Java to declaratively specify complex, constraint-rich objects, enabling automatic generation of valid object structures via ASP solvers. By embedding ASP logic within Java methods, the approach allows for concise, constraint-driven instantiation of objects such as network graphs, with support for optimization, sampling, and verification—demonstrated in a 23-line solution for a complex network topology problem.

ABSTRACT

Many applications require complexly structured data objects. Developing new or adapting existing algorithmic solutions for creating such objects can be a non-trivial and costly task if the considered objects are subject to different application-specific constraints. Often, however, it is comparatively easy to declaratively describe the required objects. In this paper, we propose to use answer-set programming (ASP)---a well-established declarative programming paradigm from the area of artificial intelligence---for instantiating objects in standard object-oriented programming languages. In particular, we extend Java with declarative specifications from which the required objects can be automatically generated using available ASP solver technology.

Motivation & Objective

• To address the challenge of developing complex, constraint-embedded data structures in imperative programming, where algorithmic solutions are costly and non-trivial to implement.
• To enable programmers to declaratively specify desired complex objects using ASP, avoiding low-level algorithmic implementation.
• To integrate ASP solving seamlessly into Java workflows, minimizing boilerplate and external calls.
• To support dynamic, parameterized object generation at runtime with support for optimization and solution sampling.
• To provide a practical, extensible framework for rapid prototyping and testing of complex data structures in software development.

Proposed method

• Extends Java with ASP-like syntax to express object specifications, where constructors and method calls are treated as logical predicates.
• Translates Java parameters (e.g., component arrays) into input facts for ASP solvers at runtime.
• Uses ASP solvers (e.g., CLASP) to compute answer sets representing valid object configurations satisfying all constraints.
• Maps the resulting answer sets back into concrete Java objects using automatic interpretation of solver output.
• Supports optimization via ASP’s #minimize statements to select preferred solutions (e.g., minimal edge count).
• Enables runtime interaction through a Java method call that accepts parameters, number of solutions, and returns structured object instances.

Experimental results

Research questions

• RQ1 Can declarative ASP specifications be effectively embedded in a mainstream object-oriented language like Java to generate complex, constrained data structures?
• RQ2 How can the integration of ASP solvers into Java be made efficient and seamless, minimizing external calls and boilerplate?
• RQ3 To what extent can ASP’s capabilities—such as constraint satisfaction, optimization, and solution sampling—improve the development of complex data structures?
• RQ4 How does the proposed approach compare to existing imperative or constraint-based testing frameworks in terms of expressiveness and maintainability?
• RQ5 What are the limitations of current integration when method calls depend on object state, and how can they be mitigated?

Key findings

• The approach successfully generates complex network graphs satisfying multiple constraints (e.g., no same-type connections, connectivity, edge limits) in just 23 lines of combined Java and ASP code.
• ASP solvers can be used to find optimal solutions (e.g., minimal edge count) via #minimize statements, demonstrating support for preference-based selection.
• The framework supports runtime parameterization, allowing different component arrays and edge limits to be used without recompilation.
• The prototype implementation successfully translates ASP answer sets into actual Java objects, using object identifiers for internal representation.
• The method enables rapid prototyping and testing of complex data structures, such as red-black trees, by declaratively specifying their required invariants.
• The approach outperforms traditional testing frameworks like KORAT and ALLOY in expressiveness, as it supports dynamic parameters and optimization, not just bounded exhaustive generation.