Статті в журналах з теми "Interface and specification languages"
Щоб переглянути інші типи публікацій з цієї теми, перейдіть за посиланням: Interface and specification languages.
Оформте джерело за APA, MLA, Chicago, Harvard та іншими стилями
Ознайомтеся з топ-50 статей у журналах для дослідження на тему "Interface and specification languages".
Біля кожної праці в переліку літератури доступна кнопка «Додати до бібліографії». Скористайтеся нею – і ми автоматично оформимо бібліографічне посилання на обрану працю в потрібному вам стилі цитування: APA, MLA, «Гарвард», «Чикаго», «Ванкувер» тощо.
Також ви можете завантажити повний текст наукової публікації у форматі «.pdf» та прочитати онлайн анотацію до роботи, якщо відповідні параметри наявні в метаданих.
Переглядайте статті в журналах для різних дисциплін та оформлюйте правильно вашу бібліографію.
1
Hatcliff, John, Gary T. Leavens, K. Rustan M. Leino, Peter Müller, and Matthew Parkinson. "Behavioral interface specification languages." ACM Computing Surveys 44, no. 3 (June 2012): 1–58. http://dx.doi.org/10.1145/2187671.2187678.
2
Paulweber, Philipp, Georg Simhandl, and Uwe Zdun. "Specifying with Interface and Trait Abstractions in Abstract State Machines: A Controlled Experiment." ACM Transactions on Software Engineering and Methodology 30, no. 4 (July 2021): 1–29. http://dx.doi.org/10.1145/3450968.
Анотація:
Abstract State Machine (ASM) theory is a well-known state-based formal method. As in other state-based formal methods, the proposed specification languages for ASMs still lack easy-to-comprehend abstractions to express structural and behavioral aspects of specifications. Our goal is to investigate object-oriented abstractions such as interfaces and traits for ASM-based specification languages. We report on a controlled experiment with 98 participants to study the specification efficiency and effectiveness in which participants needed to comprehend an informal specification as problem (stimulus) in form of a textual description and express a corresponding solution in form of a textual ASM specification using either interface or trait syntax extensions. The study was carried out with a completely randomized design and one alternative (interface or trait) per experimental group. The results indicate that specification effectiveness of the traits experiment group shows a better performance compared to the interfaces experiment group, but specification efficiency shows no statistically significant differences. To the best of our knowledge, this is the first empirical study studying the specification effectiveness and efficiency of object-oriented abstractions in the context of formal methods.
3
ACHEE, B. L., and DORIS L. CARVER. "OBJECT EXTENSIONS TO Z: A SURVEY." International Journal of Software Engineering and Knowledge Engineering 06, no. 03 (September 1996): 507–30. http://dx.doi.org/10.1142/s0218194096000211.
Анотація:
Formal specification languages provide assistance to solving the problem of high maintenance costs caused by ineffective communication of a system’s requirements. Using a sound mathematical basis, a formal specification language provides a precise and definitive system description that can serve as a binding contract. Additionally, the integration of the object-oriented paradigm with a formal specification language provides increased potential for software reuse, conceptually cleaner specifications and a framework for defining interfaces. To this end, there has been significant work done to extend existing specification languages to allow object-oriented specifications. This paper provides a comparison of such object-oriented specification languages, specifically, those extending Z. The paper is organized into five major sections. After a brief introduction to the concepts of formal specification languages and Z, a simple library system is defined and used as an example throughout the paper. Each of the object-oriented specification languages is introduced and classified as either using Z in an object-oriented style or providing a true object-oriented extension of Z. For each language, the specification of the example library system is presented following a brief overview of the language’s features. An in-depth comparison is made of each of the languages which provide a true object-oriented extension of Z.
4
Lima, Lucas, Rodrigo Bonifácio, Edna Canedo, Thiago Mael de Castro, Ricardo Fernandes, Alisson Palmeira, and Uirá Kulesza. "NeoIDL: A Domain Specific Language for Specifying REST Contracts Detailed Design and Extended Evaluation." International Journal of Software Engineering and Knowledge Engineering 25, no. 09n10 (November 2015): 1653–75. http://dx.doi.org/10.1142/s0218194015400379.
Анотація:
Service-oriented computing has emerged as an effective approach for integrating business (and systems) that might spread throughout different organizations. A service is a unit of logic modularization that hides implementation details using well-defined contracts. However, existing languages for contract specification in this domain present several limitations. For instance, both WSDL and Swagger use language-independent data formats (XML and JSON) that are not suitable for specifying contracts and often lead to heavyweight specifications. Interface description languages, such as CORBA IDL and Apache Thrift, solve this issue by providing specific languages for contract specifications. Nevertheless, these languages do not target to the REST architectural style and lack support for language extensibility. In this paper we present the design and implementation of NeoIDL, an extensible domain specific language and program generator for writing REST based contracts that are further translated into service’s implementations. In addition, we also present a systematic evaluation of our approach from different perspectives, which involved the implementation of different services using NeoIDL from the domain of Command & Control. In particular, we found initial evidences that shows that NeoIDL can contribute: (i) to bring return on investment with respect to the design and development of NeoIDL, after the implementation of 4 to 7 services; and (ii) to reduce significantly the number of lines of specification when compared to an existing service specification language such as Swagger.
5
SINGH, NARINDER, MICHAEL GENESERETH, and MUSTAFA SYED. "A DISTRIBUTED AND ANONYMOUS KNOWLEDGE SHARING APPROACH TO SOFTWARE INTEROPERATION." International Journal of Cooperative Information Systems 04, no. 04 (December 1995): 339–67. http://dx.doi.org/10.1142/s0218843095000159.
Анотація:
The support for automatic interoperation of software components can reduce cost and provide greater functionality. This paper describes a novel approach to software interoperation based on specification sharing. Software components, called agents, provide machine processable descriptions of their capabilities and needs. Agents can be realized in different programming languages, and they can run in different processes on different machines. In addition, agents can be dynamic — at run time agents can join the system or leave. The system uses the declarative agent specifications to automatically coordinate their interoperation. The architecture supports anonymous interoperation of agents, where each agent has the illusion that the capabilities of all the other agents are provided directly by the system. The distinctive feature of this approach is the expressiveness of the declarative specification language, which enables sophisticated agent interoperation, e.g. decomposing complex requests into a collection of simpler requests, and translating between the interface of a requesting agent and the interface of an agent that can service the request. The agent-based interoperation scheme relies on a shared vocabulary, and it is our thesis that more effective software interoperation is made possible by agreeing to a shared declarative vocabulary, than by agreeing to procedural interface specifications that do not address the semantics of the software component (e.g. object interface specifications in an object-oriented programming environment).
6
Dandekar, Abhay, Ibrahim Zeid, and Theodore Bardasz. "User interface for specification language for case-based mechanical design." Artificial Intelligence for Engineering Design, Analysis and Manufacturing 11, no. 1 (January 1997): 17–31. http://dx.doi.org/10.1017/s0890060400001815.
Анотація:
AbstractCase-based design (CBD) systems aim to solve a design problem by tailoring previously solved design problems to the current problem. Designers' specifications are used for indexing the knowledge base of the CBD system to retrieve an appropriate design case. Menu-based systems fail to capture designers' specifications effectively due to lack of expressiveness, while natural language systems are too immature to satisfy the goal. This paper presents the development of a graphical user interface (GUI) to implement a mechanical design specification language (MDSL) (Stelling, 1994) used to facilitate indexing in case-based mechanical design. The specification language is context-free and hence computable. It represents mechanical design knowledge in a (feature):(attribute) format suitable for indexing. An augmented transition network (ATN) parser is built using the grammar of the specification language. The parser provides syntactic as well as semantic checks. It also has capabilities to expand grammar and to adapt to a specific user domain. A graphical front end to the parser assists and guides the user through the specification language syntax in entering the design specifications. Provisions have been made to expand or edit the language grammar and vocabulary. The ATN parser was implemented in Common Lisp and the graphical user interface was written using the Gold Hill Windows Toolkit. Sample user interactions with the interface and screen dumps of the GUI are included.
7
Cheon, Yoonsik, and Gary T. Leavens. "The Larch/Smalltalk interface specification language." ACM Transactions on Software Engineering and Methodology 3, no. 3 (July 1994): 221–153. http://dx.doi.org/10.1145/196092.195325.
8
SAVIDIS, ANTHONY, MARGHERITA ANTONA, and CONSTANTINE STEPHANIDIS. "A DECISION-MAKING SPECIFICATION LANGUAGE FOR VERIFIABLE USER-INTERFACE ADAPTATION LOGIC." International Journal of Software Engineering and Knowledge Engineering 15, no. 06 (December 2005): 1063–94. http://dx.doi.org/10.1142/s0218194005002646.
Анотація:
In automatic user interface adaptation, developers pursue the delivery of best-fit user interfaces according to the runtime-supplied profiles of individual end users and usage contexts. Software engineering of automatic interface adaptability entails: (a) storage and processing of user and usage-context profiles; (b) design and implementation of alternative interface components, to optimally support the various user activities and interface operations for different users and usage contexts; and (c) runtime decision-making, to choose on the fly the most appropriate alternative interface components, given the particular user and context profile. In automatic interface adaptation, the decision making process plays a key role in optimal on-the-fly interface assembly, engaging consolidated design wisdom in a computable form. A verifiable language has been designed and implemented which is particularly suited for the specification of adaptation-oriented decision-making logic, while also being easily deployable and usable by interface designers. This paper presents the language, its contextual role in adapted interface delivery and the automatic verification method. The employment of the language in an adaptation-design support tool is discussed, the latter automatically generating language rules by relying upon adaptation rule patterns. Finally, the deployment methodology of the language in supporting dynamic interface assembly is discussed, further generalizing towards dynamic software assembly, by introducing architectural contexts and polymorphic architectural containment.
9
Rath, Kamlesh, Venkatesh Choppella, and Steven D. Johnson. "Decomposition of Sequential Behavior Using Interface Specification and Complementation." VLSI Design 3, no. 3-4 (January 1, 1995): 347–58. http://dx.doi.org/10.1155/1995/74543.
Анотація:
Decomposition of system behavior along functional boundaries into interacting sequential components is a key step in top-down system design. In this paper, we present sequential decomposition, a method for factoring sequential components from a system specification based on interface specifications of the components. The resulting components can be independently synthesized, or realized using off-the-shelf components. We introduce interface specification language (ISL), based on finite-state machine semantics, to specify the input/output behavior of synchronous sub-systems. A component is factored from a system by embedding an implementation of the complement of its interface into the system description. The composition of a machine with its complement is shown to be isomorphic to the machine, and the composition of a machine with an implementation of its component is shown to be a safe interaction. We apply sequential decomposition to a non-trivial example, a special-purpose computer with Scheme programming language primitives as its instructions.
10
Castro Silva, Daniel, Pedro Henriques Abreu, Luís Paulo Reis, and Eugénio Oliveira. "Development of flexible languages for scenario and team description in multirobot missions." Artificial Intelligence for Engineering Design, Analysis and Manufacturing 31, no. 1 (May 2, 2016): 69–86. http://dx.doi.org/10.1017/s0890060416000184.
Анотація:
AbstractThe work described in this paper is part of the development of a framework to support the joint execution of cooperative missions by a group of vehicles, in a simulated, augmented, or real environment. Such a framework brings forward the need for formal languages in which to specify the vehicles that compose a team, the scenario in which they will operate, and the mission to be performed. This paper introduces the Scenario Description Language (SDL) and the Team Description Language (TDL), two Extensible Markup Language based dialects that compose the static components necessary for representing scenario and mission knowledge. SDL provides a specification of physical scenario and global operational constraints, while TDL defines the team of vehicles, as well as team-specific operational restrictions. The dialects were defined using Extensible Markup Language schemas, with all required information being integrated in the definitions. An interface was developed and incorporated into the framework, allowing for the creation and edition of SDL and TDL files. Once the information is specified, it can be used in the framework, thus facilitating environment and team specification and deployment. A survey answered by practitioners and researchers shows that the satisfaction with SDL+TDL is elevated (the overall evaluation of SDL+TDL achieved a score of 4 out of 5, with 81%/78.6% of the answers ≥4); in addition, the usability of the interface was evaluated, achieving a score of 86.7 in the System Usability Scale survey. These results imply that SDL+TDL is flexible enough to represent scenarios and teams, through a user-friendly interface.
11
Ahmad, Rais Aziz. "Interface-Driven Software Requirements Analysis." European Scientific Journal, ESJ 12, no. 30 (October 31, 2016): 40. http://dx.doi.org/10.19044/esj.2016.v12n30p40.
Анотація:
Software requirements are one of the root causes of failure for IT software development projects. Reasons for this may be that the requirements are high-level, many might simply be wishes, or frequently changed, or they might be unclear, missing, for example, goals, objectives, strategies, and so on. Another major reason for projects’ failure may also be the use of improper techniques for software requirements specification. Currently, most IT software development projects utilise textual techniques like use cases, user stories, scenarios, and features for software requirements elicitation, analysis and specification. While IT software development processes can construct software in different programming languages, the primary focus here will be those IT projects using object-oriented programming languages. Object-oriented programming itself has several characteristics worth noting, such as its popularity, reusability, modularity, concurrency, abstraction and encapsulation. Object-oriented analysis and design transforms software requirements gathered with textual techniques into object-oriented programming. This transformation can cause complexity in identifying objects, classes and interfaces, which, in turn, complicates the object-oriented analysis and design. Because requirements can change over the course of a project and, likewise, software design can evolve during software construction, the traceability of software requirements with objects and components can become difficult. Apart from leading to project complexity, such a process can impact software quality and, in the worst-case scenario, cause the project to fail entirely. The goal of this article is to provide interface-driven techniques that will reduce ambiguity among software requirements, improve traceability and simplify software requirements modelling.
12
HERRMANN, CHRISTOPH A. "GENERATING MESSAGE-PASSING PROGRAMS FROM ABSTRACT SPECIFICATIONS BY PARTIAL EVALUATION." Parallel Processing Letters 15, no. 03 (September 2005): 305–20. http://dx.doi.org/10.1142/s0129626405002234.
Анотація:
This paper demonstrates how parallel programs with message-passing can be generated from abstract specifications embedded in the functional language MetaOCaml. The functional style permits to design parallel programs with a high degree of parameterization, so-called skeletons. Programmers who are unexperienced in parallelism can take such skeletons for a simple and safe generation of parallel applications. Since MetaOCaml also has efficient imperative features and an MPI interface, the entire program can be written in one language, without the need to use a language interface restricting the set of data objects which could be exchanged. The semantics of abstract specifications is expressed by an interpreter written in MetaOCaml. A cost model is defined by abstract interpretation of the specification. Partial evaluation of the interpreter with a specification, a feature which MetaOCaml provides, yields a parallel program. The partial evaluation process takes time on each MPI process directly before the execution of the application program, exploiting knowledge of the number of processes, the current process identifier and the communication structure. Our example is the specification of a divide-and-conquer skeleton which is used to compute the multiplication of multi-digit numbers using Karatsuba's algorithm.
13
Zhang, Jian, Kun Huang, and Lu Wang. "An Integrating Method for Information System Based on CCM." Applied Mechanics and Materials 220-223 (November 2012): 2319–22. http://dx.doi.org/10.4028/www.scientific.net/amm.220-223.2319.
Анотація:
With the rapid development of computer technology, various distributed-component technologies are emerging. CCM specification, which has the features of independent of platforms and development languages, complete model, standard protocol and interface, has been widely recognized in computer industry. In this specification, the reuse of software is achieved through assembling. Its openness and extensibility makes it especially suitable for the integration of large-scale information system. Based on the introduction of CCM specification and information system integration, proposes the application of CCM specification to information system integration, and describes the integrating method from four aspects of integration framework, hierarchy structure, development process, and operation characteristic.
14
Vidal-Silva, C. L., E. Madariaga, T. Pham, F. Johnson, L. A. Urzua, and L. Carter. "JPIAspectZ: A Formal Requirement Specification Language for Joint Point Interface AOP Applications." Engineering, Technology & Applied Science Research 9, no. 4 (August 10, 2019): 4338–41. http://dx.doi.org/10.48084/etasr.2774.
Анотація:
Aspect-oriented software development (AOSD) solves a few issues of the object-oriented software development (OOSD) approach and adds a few more concerning modules and their relationships. Join point interface (JPI) is an AOSD methodology that by the definition of the interface between advised artifacts and aspects solves associated AOSD issues to get software with a high modularity level. Looking for a JPI software development approach, this article proposes and exemplifies the use of JPIAspectZ, an extension of the formal aspect-oriented language AspectZ for the software JPI requirement specifications. Mainly, JPIAspectZ looks for a concept and model consistency in a JPI software development process. Since the main JPI characteristics are the joining point interfaces definitions, i. e. explicit associations definition between aspects and advised modules, thus, by JPI, classes are no longer oblivious of possible interaction with aspects, and aspects, for their action effectiveness, do not depend anymore on signatures of advisable module components. JPIAspectZ fully supports these JPI principles. As JPI application examples, this article shows the formal requirements specification for classic aspect-oriented and JPI examples, along with describing the advantages and disadvantages of this language.
15
Pahl, Claus, and Luke Collins. "Software Service Adaptation Based on Interface Localisation." International Journal of Systems and Service-Oriented Engineering 5, no. 1 (January 2015): 16–34. http://dx.doi.org/10.4018/ijssoe.2015010102.
Анотація:
The aim of Web services is the provision of software services to a range of different users in different locations. Service localisation in this context can facilitate the internationalisation and localisation of services by allowing their adaption to different locales. The authors investigate three dimensions: (i) lingual localisation by providing service-level language translation techniques to adopt services to different languages, (ii) regulatory localisation by providing standards-based mappings to achieve regulatory compliance with regionally varying laws, standards and regulations, and (iii) social localisation by taking into account preferences and customs for individuals and the groups or communities in which they participate. The objective is to support and implement an explicit modelling of aspects that are relevant to localisation and runtime support consisting of tools and middleware services to automating the deployment based on models of locales, driven by the two localisation dimensions. The authors focus here on an ontology-based conceptual information model that integrates locale specification into service architectures in a coherent way.
16
Alexander, Perry. "Task Analysis and Design Plans in Formal Specification Design." International Journal of Software Engineering and Knowledge Engineering 08, no. 02 (June 1998): 223–52. http://dx.doi.org/10.1142/s0218194098000133.
Анотація:
This paper presents BENTON, a prototype system demonstrating task analysis and multi-agent reasoning applied to formal specification synthesis. BENTON transforms specifications written as attribute-value pairs into Larch Modula-3 interface language and Larch Shared Language specifications. BENTON decomposes the software specification design task into synthesis, analysis and evaluation subtasks. Each subtask is assigned a specific design method based on problem and domain characteristics. This task analysis is achieved using blackboard knowledge sources and multi-agent reasoning employing design plans to implement different problem solving methods. Knowledge sources representing different problem solving methodologies monitor blackboard spaces and activate when they are applicable. When executed, Design plans send subtasks to agents that select from available problem solving methodologies. BENTON agents and knowledge sources use case-based reasoning, schemata-based reasoning and procedure execution as their fundamental reasoning methods. This paper presents an overview of the BENTON design model, its agent architecture and plan execution capabilities, and two annotated examples of BENTON problem solving activities.
17
Wood, C. A., P. D. Gray, and A. C. Kilgour. "Experience with Chisl, a Configurable Hierarchical Interface Specification Language." Computer Graphics Forum 7, no. 2 (June 1988): 117–27. http://dx.doi.org/10.1111/j.1467-8659.1988.tb00597.x.
18
Zima, Hans P. "From FORTRAN 77 to Locality-Aware High Productivity Languages for Peta-Scale Computing." Scientific Programming 15, no. 1 (2007): 45–65. http://dx.doi.org/10.1155/2007/219061.
Анотація:
When the first specification of the FORTRAN language was released in 1956, the goal was to provide an "automatic programming system" that would enhance the economy of programming by replacing assembly language with a notation closer to the domain of scientific programming. A key issue in this context, explicitly recognized by the authors of the language, was the requirement to produce efficient object programs that could compete with their hand-coded counterparts. More than 50 years later, a similar situation exists with respect to finding the right programming paradigm for high performance computing systems. FORTRAN, as the traditional language for scientific programming, has played a major role in the quest for high-productivity programming languages that satisfy very strict performance constraints. This paper focuses on high-level support for locality awareness, one of the most important requirements in this context. The discussion centers on the High Performance Fortran (HPF) family of languages, and their influence on current language developments for peta-scale computing. HPF is a data-parallel language that was designed to provide the user with a high-level interface for programming scientific applications, while delegating to the compiler the task of generating an explicitly parallel message-passing program. We outline developments that led to HPF, explain its major features, identify a set of weaknesses, and discuss subsequent languages that address these problems. The final part of the paper deals with Chapel, a modern object-oriented language developed in the High Productivity Computing Systems (HPCS) program sponsored by DARPA. A salient property of Chapel is its general framework for the support of user-defined distributions, which is related in many ways to ideas first described in Vienna Fortran. This framework is general enough to allow a concise specification of sparse data distributions. The paper concludes with an outlook to future research in this area.
19
TAN, GANG. "JNI light: an operational model for the core JNI." Mathematical Structures in Computer Science 25, no. 4 (November 10, 2014): 805–40. http://dx.doi.org/10.1017/s0960129513000042.
Анотація:
Through foreign function interfaces (FFIs), software components in different programming languages interact with each other in the same address space. Recent years have witnessed a number of systems that analyse FFIs for safety and reliability. However, lack of formal specifications of FFIs hampers progress in this endeavour. We present a formal operational model, Java Native Interface (JNI) light (JNIL), for a subset of a widely used FFI – the Java Native Interface (JNI). JNIL focuses on the core issues when a high-level garbage-collected language interacts with a low-level language. It proposes abstractions for handling a shared heap, cross-language method calls, cross-language exception handling, and garbage collection. JNIL can directly serve as a formal basis for JNI tools and systems. We demonstrate its utility by proving soundness of a system that checks native code in JNI programs for type-unsafe use of JNI functions. The abstractions in JNIL are also useful when modelling other FFIs, such as the Python/C interface and the OCaml/C interface.
20
CLAESSEN, KOEN. "FUNCTIONAL PEARL Parallel Parsing Processes." Journal of Functional Programming 14, no. 6 (October 27, 2004): 741–57. http://dx.doi.org/10.1017/s0956796804005192.
Анотація:
We derive a combinator library for non-deterministic parsers with a monadic interface, by means of successive refinements starting from a specification. The choice operator of the parser implements a breadth-first search rather than the more common depth-first search, and can be seen as a parallel composition between two parsing processes. The resulting library is simple and efficient for “almost deterministic” grammars, which are typical for programming languages and other computing science applications.
21
Thangaraj, Jagadeeswaran, and Senthilkumaran Ulaganathan. "A Comparative Study on Transformation of UML/OCL to Other Specifications." Recent Advances in Computer Science and Communications 13, no. 2 (June 3, 2020): 256–64. http://dx.doi.org/10.2174/2213275912666190129121059.
Анотація:
Background: Static verification is a sound programming methodology that permits automated reasoning about the correctness of an implementation with respect to its formal specification before its execution. Unified Modelling Language is most commonly used modelling language which describes the client’s requirement. Object Constraint Language is a formal language which allows users to express textual constraints regarding the UML model. Therefore, UML/OCL express formal specification and helps the developers to implement the code according to the client’s requirement through software design. Objective: This paper aims to compare the existing approaches generating Java, C++, C# code or JML, Spec# specifications from UML/OCL. Methods: Nowadays, software system is developed via automatic code generation from software design to implementation when using formal specification and static analysis. In this paper, the study considers transformation from design to implementation and vice versa using model transformation, code generation or other techniques. Results: The related tools, which generate codes, do not support verification at the implementation phase. On the other hand, the specification generation tools do not generate all the required properties which are needed for verification at the implementation phase. Conclusion: If the generated system supports the verification with all required properties, code developer needs less efforts to produce correct software system. Therefore, this study recommends introducing a new framework which can act as an interface between design and implementation to generate verified software systems.
22
Sugimoto, Toru, Noriko Ito, Shino Iwashita, and Michio Sugeno. "Programming in Everyday Language: A Case for Email Management." Journal of Advanced Computational Intelligence and Intelligent Informatics 10, no. 6 (November 20, 2006): 821–29. http://dx.doi.org/10.20965/jaciii.2006.p0821.
Анотація:
We present a processing model of a natural language interface that accepts task specification texts consisting of more than one sentence. Such an interface enables users to easily specify complex requests as coherent texts, in other words, to write a program in everyday language, to operate computing systems. Corresponding to the characteristics of task specification texts, processing consists of paraphrasing, detection of loop structures, and executable program generation using rhetorical information. Algorithms have been fully implemented in our everyday language programming system that deals with personal email management tasks. In this paper, we explain our processing model using an example from the email management domain, give evaluation results, and discuss its effectiveness and future work.
23
COLOMBO, ENZO, CHIARA FRANCALANCI, and BARBARA PERNICI. "MODELING COOPERATION IN VIRTUAL DISTRICTS: A METHODOLOGY FOR E-SERVICE DESIGN." International Journal of Cooperative Information Systems 13, no. 04 (December 2004): 369–411. http://dx.doi.org/10.1142/s0218843004001048.
Анотація:
E-services can be used to wrap an organization's information system and to provide a standard interface that enables cooperation with other information systems. As a consequence, e-services should not only support operating activities, but also embed mechanisms for inter-organizational coordination and control over operating activities. Inter-organizational coordination and control are based on contractual agreements that coordinate processes across cooperating companies and establish mechanisms to control the fulfillment of production goals. The objective of this paper is to describe a methodological approach for the design of e-services that supports the specification of inter-organizational coordination and control requirements. The paper explains how the methodology is structured in three phases, from requirements specification to conceptual design and implementation. The first phase of the methodology supports the specification of cooperation requirements, which constitute the static description of coordination and control requirements. In the second methodological phase, this static description is completed with a dynamic description of the actions to be taken upon exceptions, which occur when cooperating partners do not comply with cooperation goals. The static and dynamic description of coordination and control represent a conceptual specification of a business transaction. In the final methodological phase, this conceptual specification is implemented based on the WSDL and BPEL4WS languages for e-service design. The methodology is tested on the case study of the Italian production district of Matera.
24
Corrêa, Letícia Maria Sicuro, and Marina R. A. Augusto. "Fatores determinantes de custo de processamento e suas implicações para a aquisição da linguagem (Factors affecting processing cost and their implications to language acquisition)." Estudos da Língua(gem) 7, no. 2 (December 1, 2009): 43. http://dx.doi.org/10.22481/el.v7i2.1091.
Анотація:
Fatores determinantes de custo de processamento são apontados, os quais incluem custo computacional, definido em função do modelo de computação on-line em Corrêa e Augusto (2007), e custo decorrente do processamento nas interfaces fônica e semântica. Suas implicações para a aquisição da linguagem são consideradas, no contexto de uma teoria procedimental de aquisição da língua (CORRÊA, 2006). Grau de visibilidade de distinções morfofonológicas na interface fônica, distinções conceptuais-intencionais relevantes na especificação de traços formais do léxico, mediante processamento na interface semântica, e peso da carga imposta à memória de trabalho na análise do material lingüístico são fatores especificamente discutidos.PALAVRAS-CHAVE: Aquisição da Linguagem. Bootstrapping. Custo de Processamento. Minimalismo.
ABSTRACT Factors affecting processing cost are presented, which include computational cost, defined in relation to an on-line model of syntactic computation (CORRÊA; AUGUSTO, 2007) and the cost derived from processing at the phonetic and semantic interfaces. Their implications to language acquisition are considered, in the light of a procedural theory of language acquisition (CORRÊA, 2006). The degree of visibility of morphophonological distinction at the phonetic interface, conceptual-intentional distinctions at the processing of the semantic interface, which contribute to the specification of formal features in the lexicon, and memory load are the factors discussed here.KEYWORDS: Language Acquisition. Boostrapping. Processing Cost. Minimalism.
25
Glenn, Floyd, James Hicinbothom, Stanley Schwartz, Ken Smith, and Eric Heilman. "A User Interface for a Battlefield Distributed Information System." Proceedings of the Human Factors Society Annual Meeting 33, no. 5 (October 1989): 340–44. http://dx.doi.org/10.1177/154193128903300523.
Анотація:
This effort was conducted to redesign and improve the user interface for the Distributed Fact Base (DFB) component of the Army's Smart Weapon System / Information Distribution System (SWS/IDS), which is being initially developed to support battlefield fire control for fighting echelons up to the brigade level. The SWS/IDS consists of multiple clusters of powerful workstations that are networked together over low-speed radio links. The IDS manages the efficient updating and interrogating of nodes of the DFB so as to maximize system performance within communication channel capacity limits, thereby minimizing the amount of information exchange among battlefield units. The user interfaces address the distributed character of both the information and the decision processes as well as the essential complexity of the knowledge domain. Interface design is being accomplished using a general design methodology for distributed intelligent systems that entails systematic consideration of system and user objectives, cognitive capabilities and limitations of the user, and available technology options. An object-oriented approach was used for developing an enhanced interface for map, chart, and list applications using newly devised interface design tools known as Object-Action Specification Tables (OASTs) and an Object-Action Specification Language (OASL). The OASTs are tables that indicate which actions can be performed on which display and control objects and which control objects can perform which actions on other objects. Wherever an object-action combination is feasible, an entry in OASL indicates how the action is accomplished (e.g., by selection of pull-right menu item; mouse-button click with mouse cursor on screen icon; etc.).
26
Lu, Quan, Gao Liu, and Jing Chen. "Integrating PDF interface into Java application." Library Hi Tech 32, no. 3 (September 9, 2014): 495–508. http://dx.doi.org/10.1108/lht-01-2014-0009.
Анотація:
Purpose – The purpose of this paper is to propose a novel approach to integrate portable document format (PDF) interface into Java-based digital library application. It bridges the gap between conducting content operation and viewing on PDF document asynchronously. Design/methodology/approach – In this paper, the authors first review some related research and discuss PDF and its drawbacks. Next, the authors propose the design steps and implementation of three modes of displaying PDF document: PDF display, image display and extensible markup language (XML) display. A comparison of these three modes has been carried out. Findings – The authors find that the PDF display is able to completely present the original PDF document contents and thus obviously superior to the other two displays. In addition, the format specification of PDF-based e-book does not perform well; lack of standardization and complex structure is exposed to the publication. Practical implications – The proposed approach makes viewing the PDF documents more convenient and effective, and can be used to retrieve and visualize the PDF documents and to support the personalized function customization of PDF in the digital library applications. Originality/value – This paper proposes a novel approach to solve the problem between content operation and the view of PDF synchronously, providing users a new tool to retrieve and reuse the PDF documents. It contributes to improve the service specification and policy of viewing the PDF for digital library. Besides, the personalized interface and public index make further development and application more feasible.
27
Belic, Katarina, and Dusan Surla. "Model of a user friendly system for library cataloguing." Computer Science and Information Systems 5, no. 1 (2008): 61–85. http://dx.doi.org/10.2298/csis0801061b.
Анотація:
Aim of the research is to model the system for cataloguing in the UNIMARC format which does not require specific knowledge of cataloguing formats. The Unified Modeling Language (UML 2.0) is used for the specification of both the information requirements and the architecture model of system for cataloguing. The research finding is a model of system for cataloguing in UNIMARC format by which authors themselves can process their bibliographic entries without knowing UNIMARC format. Bibliographic records formed in this way can be further processed according to adopted standards by librarians. Limitation of research results lies in the additional modeling of graphic user interface for the purpose of changing input data set of library documents. This limitation can be surpassed by specifying the input data set which would be used for automatic generation of appropriate user interface. The specification could be realized by means of XML Schema language. Practical usage of the research findings is the basic for the implementation of a Web application intended for the creation of electronic catalogues and bibliographies of researchers and scientific institutions. Integration of the catalogue into BISIS makes it publicly available through a standard user interface for searching bibliographic records on the Internet. In addition that application could be integrated into various librarian software systems. The contribution of this work is in the model architecture of the system for cataloguing in the UNIMARC format. User interface (described by use case diagrams) is connected with object model of UNIMARC format. According to that, any change or addition of new input data set of library documents requires only the change of use case diagrams which describe user interface while the rest of the model remains the same.
28
Karray, Fakhri, Rogelio Soto, Federico Guedea, and Insop Song. "Integration of Distributed Robotic Systems." Journal of Advanced Computational Intelligence and Intelligent Informatics 8, no. 1 (January 20, 2004): 7–13. http://dx.doi.org/10.20965/jaciii.2004.p0007.
Анотація:
Creating a distributed and remote operated robotic system is a very challenging and time-consuming task. This paper contains the development issues taking into account when multiple robotic components are integrated to create a distributed robotic application using the standard middleware, Common Object Request Broker Architecture (CORBA) specification. The main idea is to define a set of generic interfaces using the Interface Definition Language (IDL) that can be used with common components in order to facilitate the integration of new components or the modification of them. The generic IDL interfaces are based on wrapper functions, which provide an abstract encapsulated behaviors of the low level components. The approach is shown using two types of arm manipulators and two different pan-tilt model units. Because of the modularity and the abstraction of this approach, this development can be seen as the first stage in constructing more autonomous and complex system.
29
Roubi, Sarra, Mohammed Erramdani, and Samir Mbarki. "A Model Driven Approach for generating Graphical User Interface for MVC Rich Internet Application." Computer and Information Science 9, no. 2 (April 19, 2016): 91. http://dx.doi.org/10.5539/cis.v9n2p91.
Анотація:
<p><span style="font-size: 10.5pt; font-family: 'Times New Roman','serif'; mso-bidi-font-size: 12.0pt; mso-fareast-font-family: 宋体; mso-font-kerning: 1.0pt; mso-ansi-language: EN-US; mso-fareast-language: ZH-CN; mso-bidi-language: AR-SA;" lang="EN-US">Web applications have witnessed a significant improvement that exhibit advanced user interface behaviors and functionalities. Along with this evolution, Rich Internet Applications (RIAs) were proposed as a response to these necessities and have combined the richness and interactivity of desktop interfaces into the web distribution model. However, RIAs are complex applications and their development requires designing and implementation which are time-consuming and the available tools are specialized in manual design. In this paper, we present a new model driven approach in which we used well known Model-Driven Engineering (MDE) frameworks and technologies, such as Eclipse Modeling Framework (EMF), Graphical Modeling Framework (GMF), Query View Transformation (QVTo) and Acceleo to enable the design and the code automatic generation of the RIA. The method focus on simplifying the task for the designer and not necessary be aware of the implementation specification.</span></p>
30
GIMENO-SANZ, ANA. "E-language learning for the airline industry." ReCALL 14, no. 1 (May 2002): 47–57. http://dx.doi.org/10.1017/s0958344002000514.
Анотація:
The acquisition of foreign languages for specific purposes through e-learning strategies is one of the areas less researched and developed in the field of CALL. However, as a member of a recently completed Leonardo da Vinci Project, devoted to vocational training, the author will report on the findings of the Airline Talk project. The goals of the project were to supply materials which would promote continuing learning amongst airline staff in three target languages: English, German and Spanish. This paper focuses on the development, structure and language content of the Spanish courseware, ¡Bienvenido a bordo!, designed at the Universidad Politécnica de Valencia. The author discusses the process carried out by the project partners in order to satisfy learner demands in terms of learner orientation, process orientation and learner autonomy to achieve language competence through the development of communicative skills and interactivity. Issues that are described include: needs analysis, courseware specifications, exercise template design, graphical user interface and learner motivation. The results arising from the evaluation carried out at two different partner institutions will conclude the discussion.
31
Straszak, Tomasz, and Michał Śmiałek. "Model-driven acceptance test automation based on use cases." Computer Science and Information Systems 12, no. 2 (2015): 707–28. http://dx.doi.org/10.2298/csis141217033s.
Анотація:
Acceptance testing is highly dependent on the formulation of requirements, as the final system is tested against user requirements. It is thus highly desirable to be able to automate transition from requirements to acceptance tests. In this paper we present a model-driven approach to this issue, where detailed use case models are transformed into test cases. Importantly, our approach facilitates synchronising functional test cases with other types of tests (non-functional, domain logic, user interface) and introducing test data. This leads to a unified approach where requirements models of various kind drive the acceptance testing process. This process is parallel to the development process which also involves automatic transformations from requirements models to software development artefacts (models and code). To show validity of the approach we present a case study which uses a new tool called ReDSeT, that transforms requirements formulated in the Requirements Specification Language (RSL) into tests in a newly proposed Test Specification Language (TSL).
32
Benkner, Siegfried. "VFC: The Vienna Fortran Compiler." Scientific Programming 7, no. 1 (1999): 67–81. http://dx.doi.org/10.1155/1999/304639.
Анотація:
High Performance Fortran (HPF) offers an attractive high‐level language interface for programming scalable parallel architectures providing the user with directives for the specification of data distribution and delegating to the compiler the task of generating an explicitly parallel program. Available HPF compilers can handle regular codes quite efficiently, but dramatic performance losses may be encountered for applications which are based on highly irregular, dynamically changing data structures and access patterns. In this paper we introduce the Vienna Fortran Compiler (VFC), a new source‐to‐source parallelization system for HPF+, an optimized version of HPF, which addresses the requirements of irregular applications. In addition to extended data distribution and work distribution mechanisms, HPF+ provides the user with language features for specifying certain information that decisively influence a program’s performance. This comprises data locality assertions, non‐local access specifications and the possibility of reusing runtime‐generated communication schedules of irregular loops. Performance measurements of kernels from advanced applications demonstrate that with a high‐level data parallel language such as HPF+ a performance close to hand‐written message‐passing programs can be achieved even for highly irregular codes.
33
Tajsner, Przemysław. "On Specification Predication and the derivation of copular to-clauses in Polish." Studia Anglica Posnaniensia 50, no. 4 (December 1, 2015): 25–66. http://dx.doi.org/10.1515/stap-2015-0032.
Анотація:
AbstractThe paper offers a consistently derivational account of Polish predicational and specificational copular clauses with the occurrence of a particletoinstead of a verbal copulabyć(‘be’). The particletois given the status of a predicative head with the potential of designating a phrase in its c-command domain as a specification predicate. Such a phrase is then interpreted as the focus at the C-I interface. Thus, a view is promoted in which the focus, a category of information structure, is not directly coded in narrow syntax, but is rather an interpretive outcome of a more general syntactic relation, referred to asSpecification Predication. This view has been inspired by Kiss’s (2006, 2010) idea thatfocusing is predicationbut it substantially differs from her approach. The analysis is limited to copular-toclauses, but it is suggested to have a potential for the account of two more syntactic types with the occurrence of the particleto, namely, so-calledto-clefts, and topic-tosentences.The proposal advanced in the paper is confronted with three earlier accounts dealing with copular-toclauses, and is shown to avoid some empirical and conceptual problems they have posed. It is shown how the derivation of copular-toclauses proceeds through a sequence of minimal and well-defined steps starting from the formation of an array of two nominal phrases, through a Small Clause stage to a Specification Predicative Phrase. Couched in the recent minimalist framework, the analysis specifically dwells on the theoretical advancements determining the nature of syntactic derivations, such as Hornstein’s (2009) distinctions between operations Concatenate, Merge and Label, Moro’s (2000, 2008) idea of Spontaneous Symmetry Breaking or Chomsky’s (2013) view of Labeling.
34
Mollo Neto, Mario, and Mariana Mariana Matulovic da Silva Rodrigueiro. "SOFTWARE FOR RECORDING AND CAPTURE VIDEO SEQUENCES FOR POULTRY AND LAYING HENS FACILITY (BIOTERIUM)." International Journal for Innovation Education and Research 8, no. 2 (February 1, 2020): 53–65. http://dx.doi.org/10.31686/ijier.vol8.iss2.2167.
Анотація:
Behavior can sometimes be observed directly, and can also be affected by the presence of human observers. Technological devices have strongly advanced our understanding of certain aspects of animal behavior, and the small cameras borne in a straight line by study animals offer a reliable alternative to direct observation. One possible way to make animal welfare assessments easier and faster could be the application of audio and video data analysis. In this research, the main goal is to reach the requirements determination, and the construction to build a concurrent alternative to CCTV software based on new proprietary software, developed in Matlab® language, to record and capture video sequences in digital memory hardware. The proposed software stakeholders’ needs are written attending the specification in the ISO/IEC/IEEE 29148:2011 standard, and the life cycle adapted to the development was based in the standard ISO/IEC/IEEE 12207:2008. The main user interface was generated using the Matlab® GUI (Graphical User Interface). In the results, a resumed table with the final document of Requirement Specification (StRS) was generated and the main interface is coded. The system validation took place in the animal houses (bioterium) over a period of three months and the data collection and software usability reach the attendance to all the requirements listed. Thus, in the conclusions, it was observed that its users considered the developed software a good tool to help researches in the poultry and laying hens’ facility (bioterium).
35
Hengeveld, Kees, and J. Lachlan Mackenzie. "Grammar and context in Functional Discourse Grammar." Pragmatics. Quarterly Publication of the International Pragmatics Association (IPrA) 24, no. 2 (June 1, 2014): 203–27. http://dx.doi.org/10.1075/prag.24.2.02hen.
Анотація:
This article presents a proposal for the organization of the Contextual Component in Functional Discourse Grammar. A guiding principle in this proposal is that, given the fact that Functional Discourse Grammar is a theory of grammar, the Contextual Component should provide the information that is necessary for a proper functioning of the grammar rather than aim at an exhaustive specification of all the information that plays a role in interpreting linguistic expressions. The Contextual Component contains situational and discursive information and is organized in different strata that correspond to the interpersonal, representational, morphosyntactic, and phonological levels of representation within the grammar. The contextual representations make use of the same formalizations as the corresponding linguistic representations, thus allowing for direct exchange of information between the Grammatical and the Contextual Components. Thus exchange of information is handled by an interface called the contextualizer. The article illustrates the functioning of this model by analyzing the role of contextual information with respect to three grammatical phenomena in three different languages: Unexpressed arguments in Turkish, English too, and answers to yes/no questions in European Portuguese.
36
Garg, Mohit, and Richard Lai. "A Method for Measuring the Constraint Complexity of Components in Automotive Embedded Software Systems." International Journal of Software Engineering and Knowledge Engineering 29, no. 01 (January 2019): 1–21. http://dx.doi.org/10.1142/s0218194019500013.
Анотація:
The rapid growth of software-based functionalities has made automotive Electronic Control Units (ECUs) significantly complex. Factors affecting the software complexity of components embedded in an ECU depend not only on their interface and interaction properties, but also on the structural constraints characterized by a component’s functional semantics and timing constraints described by AUTomotive Open System ARchitecture (AUTOSAR) languages. Traditional constraint complexity measures are not adequate for the components in embedded software systems as they do not yet sufficiently provide a measure of the complexity due to timing constraints which are important for quantifying the dynamic behavior of components at run-time. This paper presents a method for measuring the constraint complexity of components in automotive embedded software systems at the specification level. It first enables system designers to define non-deterministic constraints on the event chains associated with components using the AUTOSAR-based Modeling and Analysis of Real-Time and Embedded systems (MARTE)-UML and Timing Augmented Description Language (TADL). Then, system analysts use Unified Modeling Language (UML)-compliant Object Constraint Language (OCL) and its Real-time extension (RT-OCL) to specify the structural and timing constraints on events and event chains and estimate the constraint complexity of components using a measure we have developed. A preliminary version of the method was presented in M. Garg and R. Lai, Measuring the constraint complexity of automotive embedded software systems, in Proc. Int. Conf. Data and Software Engineering, 2014, pp. 1–6. To demonstrate the usefulness of our method, we have applied it to an automotive Anti-lock Brake System (ABS).
37
Houshmand, Farzin, Mohsen Lesani, and Keval Vora. "Grafs: declarative graph analytics." Proceedings of the ACM on Programming Languages 5, ICFP (August 22, 2021): 1–32. http://dx.doi.org/10.1145/3473588.
Анотація:
Graph analytics elicits insights from large graphs to inform critical decisions for business, safety and security. Several large-scale graph processing frameworks feature efficient runtime systems; however, they often provide programming models that are low-level and subtly different from each other. Therefore, end users can find implementation and specially optimization of graph analytics error-prone and time-consuming. This paper regards the abstract interface of the graph processing frameworks as the instruction set for graph analytics, and presents Grafs, a high-level declarative specification language for graph analytics and a synthesizer that automatically generates efficient code for five high-performance graph processing frameworks. It features novel semantics-preserving fusion transformations that optimize the specifications and reduce them to three primitives: reduction over paths, mapping over vertices and reduction over vertices. Reductions over paths are commonly calculated based on push or pull models that iteratively apply kernel functions at the vertices. This paper presents conditions, parametric in terms of the kernel functions, for the correctness and termination of the iterative models, and uses these conditions as specifications to automatically synthesize the kernel functions. Experimental results show that the generated code matches or outperforms handwritten code, and that fusion accelerates execution.
38
Gavarró, Anna. "L1 variation in object pronominalisation, and the import of pragmatics." Probus 31, no. 2 (September 25, 2019): 299–322. http://dx.doi.org/10.1515/probus-2016-0011.
Анотація:
Abstract Much work on referential expressions in monolingual and bilingual acquisition rests on the assumption that early grammars licence null objects even when they are not possible in the corresponding target grammar, in virtue of discourse-pragmatic licencing. This proposal has been made mainly with reference to third person object pronominalisation. Less attention has been given to other pronouns. Here, I show how the pragmatic account of third person object pronouns (along the lines of Serratrice et al. [2004, Crosslinguistic influence in the syntax-pragmatics interface: Subjects and objects in English-Italian bilingual and monolingual acquisition. Bilingualism: Language and Cognition 7(3). 182–205], in the spirit of Hulk and Müller [2000, Bilingual first language acquisition at the interface between syntax and pragmatics. Bilingualism: Language and Cognition 3(3). 227–244], Müller and Hulk [2001, Crosslinguistic influence in bilingual language acquisition: Italian and French as recipient languages. Bilingualism: Language and Cognition 4(1). 1–21]) does not extend to clitics instantiating other person specifications or other grammatical functions. I present an alternative analysis, in terms of the Unique Checking Constraint (Wexler [1998, Very early parameter setting and the unique checking constraint: A new explanation for the optional infinitive stage. Lingua 106. 23–79]) that offers a generalisation over other clitics, in particular indirect object clitics and first person object clitics, which are generally preserved in child grammar – as witnessed by two experiments run on Catalan L1 reported here.
39
AGHA, GUL A., IAN A. MASON, SCOTT F. SMITH, and CAROLYN L. TALCOTT. "A foundation for actor computation." Journal of Functional Programming 7, no. 1 (January 1997): 1–72. http://dx.doi.org/10.1017/s095679689700261x.
Анотація:
We present an actor language which is an extension of a simple functional language, and provide an operational semantics for this extension. Actor configurations represent open distributed systems, by which we mean that the specification of an actor system explicitly takes into account the interface with external components. We study the composability of such systems. We define and study various notions of testing equivalence on actor expressions and configurations. The model we develop provides fairness. An important result is that the three forms of equivalence, namely, convex, must, and may equivalences, collapse to two in the presence of fairness. We further develop methods for proving laws of equivalence and provide example proofs to illustrate our methodology.
40
LIU, ALAN, and JEFFREY J. P. TSAI. "A METHOD FOR REQUIREMENTS ANALYSIS AND KNOWLEDGE ELICITATION." International Journal on Artificial Intelligence Tools 05, no. 01n02 (June 1996): 167–83. http://dx.doi.org/10.1142/s0218213096000122.
Анотація:
Requirements analysis is a knowledge intensive task and it requires an expert to understand what the clients need. In this paper, we introduce a method which contains different artificial intelligence techniques to perform this task, and a prototype knowledge-based requirements analysis system, RAKES, is presented to explain our approach. In this approach, not only the ordinary functional requirements are collected, but also some non-traditional information, such as non-functional requirements like the quality of operations or the background information for constructing the requirements, is gathered through a knowledge-based support. Different kinds of information collected are stored and organized in a knowledge base and can be used as the source of the user input in the latter phases of software development. Algorithms and procedures have been developed for constructing the interface language, organizing the knowledge base, and applying the knowledge base to different tasks. RAKES is integrated to an on-going research, called the FRORL methodology, to offer a systematic way toward requirements analysis, specification production, prototype generation, specification debugging, and code transformation.
41
Le Guernic, Paul, Jean-Pierre Talpin, and Jean-Christophe Le Lann. "POLYCHRONY for System Design." Journal of Circuits, Systems and Computers 12, no. 03 (June 2003): 261–303. http://dx.doi.org/10.1142/s0218126603000763.
Анотація:
Rising complexities and performances of integrated circuits and systems, shortening time-to-market demands for electronic equipments, growing installed bases of intellectual property (IP), requirements for adapting existing IP blocks with new services, all stress high-level design as a prominent research topic and call for the development of appropriate methodological solutions. In this aim, system design based on the so-called "synchronous hypothesis" consists of abstracting the nonfunctional implementation details of a system and lets one benefit from a focused reasoning on the logics behind the instants at which the system functionalities should be secured. With this point of view, synchronous design models and languages provide intuitive (ontological) models for integrated circuits. This affinity explains the ease of generating synchronous circuits and verify their functionalities using compilers and related tools that implement this approach. In the relational mathematical model behind the design language SIGNAL, this affinity goes beyond the domain of purely synchronous circuits, and embraces the context of complex architectures consisting of synchronous circuits and desynchronization protocols: globally asynchronous and locally synchronous architectures (GALS). The unique features of the relational model behind SIGNAL are to provide the notion of polychrony: the capability to describe circuits and systems with several clocks; and to support refinement: the ability to assist and support system design from the early stages of requirement specification, to the later stages of synthesis and deployment. The SIGNAL model provides a design methodology that forms a continuum from synchrony to asynchrony, from specification to implementation, from abstraction to concretization, from interfaces to implementations. SIGNAL gives the opportunity to seamlessly model circuits and devices at multiple levels of abstractions, by implementing mechanisms found in many hardware simulators, while reasoning within a simple and formally defined mathematical model. In the same manner, the flexibility inherent to the abstract notion of signal, handled in the synchronous-desynchronized design model of SIGNAL, invites and favors the design of correct by construction systems by means of well-defined transformations of system specifications (morphisms) that preserve the intended semantics and stated properties of the architecture under design. The aim of the present article is to review and summarize these formal, correct-by-construction, design transformations. Most of them are implemented in the POLYCHRONY tool-set, allowing for a mixed bottom–up and top–down design of an embedded hardware–software system using the SIGNAL design language.
42
MANARIS, BILL Z. "AN ENGINEERING ENVIRONMENT FOR NATURAL LANGUAGE INTERFACES TO INTERACTIVE COMPUTER SYSTEMS." International Journal on Artificial Intelligence Tools 03, no. 04 (December 1994): 557–79. http://dx.doi.org/10.1142/s0218213094000303.
Анотація:
This paper discusses the development of natural language interfaces to interactive computer systems using the NALIGE user interface management system. The task of engineering such interfaces is reduced to producing a set of well-formed specifications which describe lexical, syntactic, semantic, and pragmatic aspects of the selected application domain. These specifications are converted by NALIGE to an autonomous natural language interface that exhibits the prescribed linguistic and functional behavior. Development of several applications is presented to demonstrate how NALIGE and the associated development methodology may facilitate the design and implementation of practical natural language interfaces. This includes a natural language interface to Unix and its subsequent porting to MS-DOS, VAX/VMS, and VM/CMS; a natural language interface for Internet navigation and resource location; a natural language interface for text pattern matching; a natural language interface for text editing; and a natural language interface for electronic mail management. Additionally, design issues and considerations are identified/addressed, such as reuse and portability, content coupling, morphological processing, scalability, and habitability.
43
Oliveira Vale, Arthur, Paul-André Melliès, Zhong Shao, Jérémie Koenig, and Léo Stefanesco. "Layered and object-based game semantics." Proceedings of the ACM on Programming Languages 6, POPL (January 16, 2022): 1–32. http://dx.doi.org/10.1145/3498703.
Анотація:
Large-scale software verification relies critically on the use of compositional languages, semantic models, specifications, and verification techniques. Recent work on certified abstraction layers synthesizes game semantics, the refinement calculus, and algebraic effects to enable the composition of heterogeneous components into larger certified systems. However, in existing models of certified abstraction layers, compositionality is restricted by the lack of encapsulation of state. In this paper, we present a novel game model for certified abstraction layers where the semantics of layer interfaces and implementations are defined solely based on their observable behaviors. Our key idea is to leverage Reddy's pioneer work on modeling the semantics of imperative languages not as functions on global states but as objects with their observable behaviors. We show that a layer interface can be modeled as an object type (i.e., a layer signature) plus an object strategy. A layer implementation is then essentially a regular map, in the sense of Reddy, from an object with the underlay signature to that with the overlay signature. A layer implementation is certified when its composition with the underlay object strategy implements the overlay object strategy. We also describe an extension that allows for non-determinism in layer interfaces. After formulating layer implementations as regular maps between object spaces, we move to concurrency and design a notion of concurrent object space, where sequential traces may be identified modulo permutation of independent operations. We show how to express protected shared object concurrency, and a ticket lock implementation, in a simple model based on regular maps between concurrent object spaces.
44
Baliś, Bartosz, Marian Bubak, Włodzimierz Funika, Roland Wismüller, Marcin Radecki, Tomasz Szepieniec, Tomasz Arodź, and Marcin Kurdziel. "Grid Environment for On-line Application Monitoring and Performance Analysis." Scientific Programming 12, no. 4 (2004): 239–51. http://dx.doi.org/10.1155/2004/896517.
Анотація:
This paper presents an application monitoring infrastructure developed within the CrossGrid project. The software is aimed at enabling performance measurements for the application developer and in this way facilitating the development of applications in the Grid environment. The application monitoring infrastructure is composed of a distributed monitoring system, the OCM-G, and a performance analysis tool called G-PM. The OCM-G is an on-line, grid-enabled, monitoring system, while G-PM is an advanced graphical tool which allows to evaluate and present the results of performance monitoring, to support optimization of the application execution. G-PM supports build-in standard metrics and user-defined metrics expressed in the Performance Measurement Specification Language (PMSL). Communication between the G-PM and the OCM-G is performed according to a well-defined protocol, OMIS (On-line Monitoring Interface Specification). In this paper, the architecture and features of the OCM-G and G-PM are described as well as an example of use of the monitoring infrastructure to visualize the status and communication in the application, to evaluate the performance, including discovering the reason of the performance flaw.
45
GEBSER, MARTIN, ROLAND KAMINSKI, BENJAMIN KAUFMANN, and TORSTEN SCHAUB. "Multi-shot ASP solving with clingo." Theory and Practice of Logic Programming 19, no. 1 (July 10, 2018): 27–82. http://dx.doi.org/10.1017/s1471068418000054.
Анотація:
AbstractWe introduce a new flexible paradigm of grounding and solving in Answer Set Programming (ASP), which we refer to as multi-shot ASP solving, and present its implementation in the ASP systemclingo. Multi-shot ASP solving features grounding and solving processes that deal with continuously changing logic programs. In doing so, they remain operative and accommodate changes in a seamless way. For instance, such processes allow for advanced forms of search, as in optimization or theory solving, or interaction with an environment, as in robotics or query answering. Common to them is that the problem specification evolves during the reasoning process, either because data or constraints are added, deleted, or replaced. This evolutionary aspect adds another dimension to ASP since it brings about state changing operations. We address this issue by providing an operational semantics that characterizes grounding and solving processes in multi-shot ASP solving. This characterization provides a semantic account of grounder and solver states along with the operations manipulating them. The operative nature of multi-shot solving avoids redundancies in relaunching grounder and solver programs and benefits from the solver's learning capacities.clingoaccomplishes this by complementing ASP's declarative input language with control capacities. On the declarative side, a new directive allows for structuring logic programs into named and parameterizable subprograms. The grounding and integration of these subprograms into the solving process is completely modular and fully controllable from the procedural side. To this end,clingooffers a new application programming interface that is conveniently accessible via scripting languages. By strictly separating logic and control,clingoalso abolishes the need for dedicated systems for incremental and reactive reasoning, likeiclingoandoclingo, respectively, and its flexibility goes well beyond the advanced yet still rigid solving processes of the latter.
46
Kim, Kwang S., Hantao Wang, and Ludo Max. "It's About Time: Minimizing Hardware and Software Latencies in Speech Research With Real-Time Auditory Feedback." Journal of Speech, Language, and Hearing Research 63, no. 8 (August 10, 2020): 2522–34. http://dx.doi.org/10.1044/2020_jslhr-19-00419.
Анотація:
Purpose Various aspects of speech production related to auditory–motor integration and learning have been examined through auditory feedback perturbation paradigms in which participants' acoustic speech output is experimentally altered and played back via earphones/headphones “in real time.” Scientific rigor requires high precision in determining and reporting the involved hardware and software latencies. Many reports in the literature, however, are not consistent with the minimum achievable latency for a given experimental setup. Here, we focus specifically on this methodological issue associated with implementing real-time auditory feedback perturbations, and we offer concrete suggestions for increased reproducibility in this particular line of work. Method Hardware and software latencies as well as total feedback loop latency were measured for formant perturbation studies with the Audapter software. Measurements were conducted for various audio interfaces, desktop and laptop computers, and audio drivers. An approach for lowering Audapter's software latency through nondefault parameter specification was also tested. Results Oft-overlooked hardware-specific latencies were not negligible for some of the tested audio interfaces (adding up to 15 ms). Total feedback loop latencies (including both hardware and software latency) were also generally larger than claimed in the literature. Nondefault parameter values can improve Audapter's own processing latency without negative impact on formant tracking. Conclusions Audio interface selection and software parameter optimization substantially affect total feedback loop latency. Thus, the actual total latency (hardware plus software) needs to be correctly measured and described in all published reports. Future speech research with “real-time” auditory feedback perturbations should increase scientific rigor by minimizing this latency.
47
Wing, Jeannette M. "Writing Larch interface language specifications." ACM Transactions on Programming Languages and Systems 9, no. 1 (January 1987): 1–24. http://dx.doi.org/10.1145/9758.10500.
48
Heer, Jeffrey, and Adam Perer. "Orion: A system for modeling, transformation and visualization of multidimensional heterogeneous networks." Information Visualization 13, no. 2 (December 12, 2012): 111–33. http://dx.doi.org/10.1177/1473871612462152.
Анотація:
The study of complex activities such as scientific production and software development often requires modeling connections among heterogeneous entities including people, institutions, and artifacts. Despite advances in algorithms and visualization techniques for understanding such social networks, the process of constructing network models and performing exploratory analysis remains difficult and time-consuming. In this article, we present Orion, a system for interactive modeling, transformation, and visualization of network data. Orion’s interface enables the rapid manipulation of large graphs—including the specification of complex linking relationships—using simple drag-and-drop operations with desired node types. Orion maps these user interactions to statements in a declarative workflow language that incorporates both relational operators (e.g. selection, aggregation, and joins) and network analytics (e.g. centrality measures). We demonstrate how these features enable analysts to flexibly construct and compare networks in domains such as online health communities, electronic medical records, academic collaboration, and distributed software development.
49
Nair, Manjusha, Jinesh Manchan Kannimoola, Bharat Jayaraman, Bipin Nair, and Shyam Diwakar. "Temporal constrained objects for modelling neuronal dynamics." PeerJ Computer Science 4 (July 23, 2018): e159. http://dx.doi.org/10.7717/peerj-cs.159.
Анотація:
Background Several new programming languages and technologies have emerged in the past few decades in order to ease the task of modelling complex systems. Modelling the dynamics of complex systems requires various levels of abstractions and reductive measures in representing the underlying behaviour. This also often requires making a trade-off between how realistic a model should be in order to address the scientific questions of interest and the computational tractability of the model. Methods In this paper, we propose a novel programming paradigm, called temporal constrained objects, which facilitates a principled approach to modelling complex dynamical systems. Temporal constrained objects are an extension of constrained objects with a focus on the analysis and prediction of the dynamic behaviour of a system. The structural aspects of a neuronal system are represented using objects, as in object-oriented languages, while the dynamic behaviour of neurons and synapses are modelled using declarative temporal constraints. Computation in this paradigm is a process of constraint satisfaction within a time-based simulation. Results We identified the feasibility and practicality in automatically mapping different kinds of neuron and synapse models to the constraints of temporal constrained objects. Simple neuronal networks were modelled by composing circuit components, implicitly satisfying the internal constraints of each component and interface constraints of the composition. Simulations show that temporal constrained objects provide significant conciseness in the formulation of these models. The underlying computational engine employed here automatically finds the solutions to the problems stated, reducing the code for modelling and simulation control. All examples reported in this paper have been programmed and successfully tested using the prototype language called TCOB. The code along with the programming environment are available at http://github.com/compneuro/TCOB_Neuron. Discussion Temporal constrained objects provide powerful capabilities for modelling the structural and dynamic aspects of neural systems. Capabilities of the constraint programming paradigm, such as declarative specification, the ability to express partial information and non-directionality, and capabilities of the object-oriented paradigm especially aggregation and inheritance, make this paradigm the right candidate for complex systems and computational modelling studies. With the advent of multi-core parallel computer architectures and techniques or parallel constraint-solving, the paradigm of temporal constrained objects lends itself to highly efficient execution which is necessary for modelling and simulation of large brain circuits.
50
Yusof, Yusri, and Kamran Latif. "A New ISO 14649 Translation Module for Open Architecture CNC Systems." Applied Mechanics and Materials 660 (October 2014): 878–82. http://dx.doi.org/10.4028/www.scientific.net/amm.660.878.
Анотація:
The Computer Numerical Control (CNC) machines works on the technology that uses minicomputers to generate, parse and execute the sequential control. These machines were introduced in 1970’s, this technology replaces the Numerical Control (NC) with the computers. The controller is the main part of the CNC machine that is composed of two parts: software and hardware. The software part of the controller is commonly known as interpreter that translates the International Standards Organization (ISO) data interface model instructions to the hardware part of the controller. Todays commercial CNC systems are operated by ISO 6983 data interface model that is proved to be a low level language and beside that these CNC systems are found to be closed in nature due to the dependency on vendors specification. Due to these shortcomings the current systems are fail to achieve the targets of future CNC system. In order to overcome these problems and limitations the new data interface model and Open Architecture Control (OAC) technology were introduceds. In this paper a new translator for the interpretation of ISO 14649-21 for OAC CNC systems has been presented. This module interprets the data from STEP-NC code and translates as per required structure of CNC machine. Developed module also enables the on machine modification facilities and provides a platform to generate physical output file in .txt and .xml formats as per user defined structure. The development of these kind of systems will makes CNC system more open, flexible, adoptable, interoperable, and intelligent.