69,059 research outputs found
CLPGUI: a generic graphical user interface for constraint logic programming over finite domains
CLPGUI is a graphical user interface for visualizing and interacting with
constraint logic programs over finite domains. In CLPGUI, the user can control
the execution of a CLP program through several views of constraints, of finite
domain variables and of the search tree. CLPGUI is intended to be used both for
teaching purposes, and for debugging and improving complex programs of
realworld scale. It is based on a client-server architecture for connecting the
CLP process to a Java-based GUI process. Communication by message passing
provides an open architecture which facilitates the reuse of graphical
components and the porting to different constraint programming systems.
Arbitrary constraints and goals can be posted incrementally from the GUI. We
propose several dynamic 2D and 3D visualizations of the search tree and of the
evolution of finite domain variables. We argue that the 3D representation of
search trees proposed in this paper provides the most appropriate visualization
of large search trees. We describe the current implementation of the
annotations and of the interactive execution model in GNU-Prolog, and report
some evaluation results.Comment: 16 pages; Alexandre Tessier, editor; WLPE 2002,
http://xxx.lanl.gov/abs/cs.SE/020705
Fuzzy Logic Engine
The Fuzzy Logic Engine is a software package that enables users to embed fuzzy-logic modules into their application programs. Fuzzy logic is useful as a means of formulating human expert knowledge and translating it into software to solve problems. Fuzzy logic provides flexibility for modeling relationships between input and output information and is distinguished by its robustness with respect to noise and variations in system parameters. In addition, linguistic fuzzy sets and conditional statements allow systems to make decisions based on imprecise and incomplete information. The user of the Fuzzy Logic Engine need not be an expert in fuzzy logic: it suffices to have a basic understanding of how linguistic rules can be applied to the user's problem. The Fuzzy Logic Engine is divided into two modules: (1) a graphical-interface software tool for creating linguistic fuzzy sets and conditional statements and (2) a fuzzy-logic software library for embedding fuzzy processing capability into current application programs. The graphical- interface tool was developed using the Tcl/Tk programming language. The fuzzy-logic software library was written in the C programming language
PC-Based Automated Control System for Jordan Northern Grain Silo
This paper presents a PC-based automated control system operation of the Northern Grain Silo of Jordan. The system connects to a PLC (programmable logic controller) device, and combines operator interface, PLC programming and monitoring functions into one platform. The PLC portion handles direct operations control, while the PC portion handles interfacing and data intensive functions. A simulation package is developed. The package generates a graphical user interface for real-time graphic animations of the Grain Silo operation. We discuss anticipated benefits of such a system and phases of implementation
An Integrated Development Environment for Declarative Multi-Paradigm Programming
In this paper we present CIDER (Curry Integrated Development EnviRonment), an
analysis and programming environment for the declarative multi-paradigm
language Curry. CIDER is a graphical environment to support the development of
Curry programs by providing integrated tools for the analysis and visualization
of programs. CIDER is completely implemented in Curry using libraries for GUI
programming (based on Tcl/Tk) and meta-programming. An important aspect of our
environment is the possible adaptation of the development environment to other
declarative source languages (e.g., Prolog or Haskell) and the extensibility
w.r.t. new analysis methods. To support the latter feature, the lazy evaluation
strategy of the underlying implementation language Curry becomes quite useful.Comment: In A. Kusalik (ed), proceedings of the Eleventh International
Workshop on Logic Programming Environments (WLPE'01), December 1, 2001,
Paphos, Cyprus. cs.PL/011104
Scientists in the MIST: Simplifying Interface Design for End Users
We are building a Malleable Interactive Software Toolkit (MIST), a tool set and infrastructure to simplify the design and construction of dynamically-reconfigurable (malleable) interactive software. Malleable software offers the end-user powerful tools to reshape their interactive environment on the fly. We aim to make the construction of such software straightforward, and to make reconfiguration of the resulting systems approachable and manageable to an educated, but non-specialist, user. To do so, we draw on a diverse body of existing research on alternative approaches to user interface (UI) and interactive software construction, including declarative UI languages, constraint-based programming and UI management, reflection and data-driven programming, and visual programming techniques
Emerging from the MIST: A Connector Tool for Supporting Programming by Non-programmers
Software development is an iterative process. As user re-quirements emerge software applications must be extended to support the new requirements. Typically, a programmer will add new code to an existing code base of an application to provide a new functionality. Previous research has shown that such extensions are easier when application logic is clearly separated from the user interface logic. Assuming that a programmer is already familiar with the existing code base, the task of writing the new code can be considered to be split into two sub-tasks: writing code for the application logic; that is, the actual functionality of the application; and writing code for the user interface that will expose the functionality to the end user.
The goal of this research is to reduce the effort required to create a user interface once the application logic has been created, toward supporting scientists with minimal pro-gramming knowledge to be able to create and modify pro-grams. Using a Model View Controller based architecture, various model components which contain the application logic can be built and extended. The process of creating and extending the views (user interfaces) on these model components is simplified through the use of our Malleable Interactive Software Toolkit (MIST), a tool set an infrastructure intended to simplify the design and extension of dynamically reconfigurable interfaces.
This paper focuses on one tool in the MIST suite, a connec-tor tool that enables the programmer to evolve the user interface as the application logic evolves by connecting related pieces of code together; either through simple drag-and-drop interactions or through the authoring of Python code. The connector tool exemplifies the types of tools in the MIST suite, which we expect will encourage collabora-tive development of applications by allowing users to inte-grate various components and minimizing the cost of de-veloping new user interfaces for the combined compo-nents
Visual Programming Language with Natural User Interface
One of the fastest-growing fields of interest in computer science, fueled primarily by gaming, is the Natural User Interface (NUI). NUI encompasses technologies which would replace the typical mouse-and-keyboard approach to interaction with computer systems, with the goal of making human-computer interactions more similar to face-to-face interpersonal interactions. This is done by using technologies such as gesture recognition or speech recognition and speech synthesis, which use interpersonal skills we learn and practice on a daily basis. Visual Programming Languages (VPLs) are languages that allow the creation of a program by arranging graphical representations of program behavior, rather than textual program code. Visual programming tools are used in various disciplines, but are used most often for K-12 programming education, as a way to introduce fundamental programming concepts. This project is an application which combines these two ideas as an attempt to answer a question: Is it possible to do meaningful programming without actually touching a computer? The application uses the Leap Motion controller for gesture recognition, C# speech recognition functionality for speech recognition, and C# and WPF for the user interface design and logic
- …